deepbox 0.1.0

package/dist/index-DIT_OO9C.d.cts

@@ -0,0 +1,785 @@
+import { D as DType, a as Device, S as Shape, A as Axis, b as TypedArray, c as DEVICES, d as DTYPES, T as TensorLike, e as TensorStorage, i as isDType, f as isDevice } from './tensor-B96jjJLQ.cjs';
+
+/**
+ * Global configuration for Deepbox.
+ *
+ * @property defaultDtype - Default data type for new tensors
+ * @property defaultDevice - Default compute device
+ * @property seed - Random seed for reproducibility (null = not set)
+ */
+type DeepboxConfig = {
+    readonly defaultDtype: DType;
+    readonly defaultDevice: Device;
+    readonly seed: number | null;
+};
+/**
+ * Get the current global configuration.
+ *
+ * Returns a copy of the configuration to prevent external mutation.
+ *
+ * @returns Current configuration object
+ *
+ * @example
+ * ```ts
+ * import { getConfig } from 'deepbox/core';
+ *
+ * const config = getConfig();
+ * console.log(config.defaultDtype);  // 'float32'
+ * ```
+ */
+declare function getConfig(): Readonly<DeepboxConfig>;
+/**
+ * Update global configuration.
+ *
+ * Merges provided settings with current configuration.
+ * Only specified fields are updated.
+ *
+ * @param next - Partial configuration to merge
+ * @throws {DataValidationError} If config is invalid or contains unknown keys
+ *
+ * @example
+ * ```ts
+ * import { setConfig } from 'deepbox/core';
+ *
+ * setConfig({
+ *   defaultDtype: 'float64',
+ *   seed: 42
+ * });
+ * ```
+ */
+declare function setConfig(next: Partial<DeepboxConfig>): void;
+/**
+ * Reset configuration to default values.
+ *
+ * @example
+ * ```ts
+ * import { resetConfig } from 'deepbox/core';
+ *
+ * resetConfig();  // Back to defaults
+ * ```
+ */
+declare function resetConfig(): void;
+/**
+ * Set the global random seed for reproducibility.
+ *
+ * @param seed - Integer seed value
+ * @throws {DataValidationError} If seed is not a safe integer
+ *
+ * @example
+ * ```ts
+ * import { setSeed } from 'deepbox/core';
+ *
+ * setSeed(42);  // All random operations now reproducible
+ * ```
+ */
+declare function setSeed(seed: number): void;
+/**
+ * Get the current random seed.
+ *
+ * @returns Current seed value or null if not set
+ */
+declare function getSeed(): number | null;
+/**
+ * Set the default compute device.
+ *
+ * @param device - Device to use ('cpu', 'webgpu', or 'wasm')
+ * @throws {DataValidationError} If device is not supported
+ *
+ * @example
+ * ```ts
+ * import { setDevice } from 'deepbox/core';
+ *
+ * setDevice('cpu');  // Use CPU for all operations
+ * ```
+ */
+declare function setDevice(device: Device): void;
+/**
+ * Get the current default device.
+ *
+ * @returns Current default device
+ */
+declare function getDevice(): Device;
+/**
+ * Set the default data type for new tensors.
+ *
+ * @param dtype - Data type to use as default
+ * @throws {DataValidationError} If dtype is not supported
+ *
+ * @example
+ * ```ts
+ * import { setDtype } from 'deepbox/core';
+ *
+ * setDtype('float64');  // Use double precision by default
+ * ```
+ */
+declare function setDtype(dtype: DType): void;
+/**
+ * Get the current default data type.
+ *
+ * @returns Current default dtype
+ */
+declare function getDtype(): DType;
+
+/**
+ * Base class for all Deepbox-specific errors.
+ *
+ * Provides a stable `instanceof DeepboxError` discriminator
+ * and consistent `cause` chaining.
+ */
+declare class DeepboxError extends Error {
+    name: string;
+    cause?: unknown;
+    constructor(message?: string, options?: {
+        readonly cause?: unknown;
+    });
+}
+
+/**
+ * Error thrown when tensor shapes cannot be broadcast together.
+ *
+ * Broadcasting allows operations on tensors of different shapes by automatically
+ * expanding dimensions. This error occurs when shapes are incompatible.
+ *
+ * @example
+ * ```ts
+ * // Broadcasting (3, 4) and (4,) works -> (3, 4)
+ * // Broadcasting (3, 4) and (3,) fails
+ * if (!canBroadcast(shape1, shape2)) {
+ *   throw new BroadcastError(shape1, shape2);
+ * }
+ * ```
+ *
+ * References:
+ * - NumPy broadcasting: https://numpy.org/doc/stable/user/basics.broadcasting.html
+ */
+declare class BroadcastError extends DeepboxError {
+    name: string;
+    /** The first shape involved in the broadcast operation */
+    readonly shape1: Shape;
+    /** The second shape involved in the broadcast operation */
+    readonly shape2: Shape;
+    constructor(shape1: Shape, shape2: Shape, context?: string);
+}
+
+/**
+ * Details for convergence failures.
+ *
+ * @property iterations - Number of iterations completed before failure
+ * @property tolerance - Tolerance value used for convergence checks
+ */
+type ConvergenceErrorDetails = {
+    readonly iterations?: number;
+    readonly tolerance?: number;
+};
+/**
+ * Error thrown when an iterative algorithm fails to converge within
+ * the maximum allowed iterations.
+ *
+ * This is a thrown exception that extends {@link DeepboxError}; callers
+ * should handle it with standard try/catch.
+ *
+ * @example
+ * ```ts
+ * if (iterations >= maxIterations) {
+ *   throw new ConvergenceError(
+ *     `Algorithm did not converge after ${maxIterations} iterations`
+ *   );
+ * }
+ * ```
+ *
+ * References:
+ * - scikit-learn convergence diagnostics:
+ *   https://scikit-learn.org/stable/modules/generated/sklearn.exceptions.ConvergenceWarning.html
+ */
+declare class ConvergenceError extends DeepboxError {
+    name: string;
+    /** Number of iterations completed before convergence failure */
+    readonly iterations?: number;
+    /** Tolerance value used for convergence check */
+    readonly tolerance?: number;
+    constructor(message: string, details?: ConvergenceErrorDetails);
+}
+
+/**
+ * Error thrown when an operation is requested on an unsupported or unavailable compute device.
+ *
+ * This is intended for device selection / dispatch layers (e.g. attempting to use `webgpu`
+ * in an environment where WebGPU is not available).
+ */
+declare class DeviceError extends DeepboxError {
+    /**
+     * Discriminator name for this error type.
+     */
+    name: string;
+}
+
+/**
+ * Error thrown when a requested dtype is unsupported or cannot be handled by the current
+ * implementation.
+ *
+ * This is used in low-level dtype utilities (e.g. mapping a `DType` to a TypedArray
+ * constructor) to provide a stable, package-specific error type.
+ */
+declare class DTypeError extends DeepboxError {
+    /**
+     * Discriminator name for this error type.
+     */
+    name: string;
+}
+
+/**
+ * Error thrown when an invalid index is used to access tensor elements.
+ *
+ * @example
+ * ```ts
+ * if (index < 0 || index >= length) {
+ *   throw new IndexError(`Index ${index} is out of bounds for length ${length}`);
+ * }
+ * ```
+ */
+declare class IndexError extends DeepboxError {
+    name: string;
+    /** The invalid index value */
+    readonly index?: number;
+    /** The valid range for the index */
+    readonly validRange?: readonly [number, number];
+    constructor(message: string, details?: {
+        readonly index?: number;
+        readonly validRange?: readonly [number, number];
+    });
+}
+
+/**
+ * Error thrown when invalid parameters are passed to a function or method.
+ *
+ * @example
+ * ```ts
+ * function kmeans(k: number, maxIter: number) {
+ *   if (k <= 0) {
+ *     throw new InvalidParameterError('k must be positive', 'k', k);
+ *   }
+ *   // ... algorithm logic
+ * }
+ * ```
+ */
+declare class InvalidParameterError extends DeepboxError {
+    name: string;
+    /** The name of the invalid parameter */
+    readonly parameterName?: string;
+    /** The invalid value that was provided */
+    readonly value?: unknown;
+    constructor(message: string, parameterName?: string, value?: unknown);
+}
+
+/**
+ * Error thrown when memory allocation fails or memory limits are exceeded.
+ *
+ * @example
+ * ```ts
+ * if (requestedBytes > MAX_MEMORY) {
+ *   throw new MemoryError(`Cannot allocate ${requestedBytes} bytes`);
+ * }
+ * ```
+ */
+declare class MemoryError extends DeepboxError {
+    name: string;
+    /** The amount of memory requested in bytes */
+    readonly requestedBytes?: number;
+    /** The amount of memory available in bytes */
+    readonly availableBytes?: number;
+    constructor(message: string, details?: {
+        readonly requestedBytes?: number;
+        readonly availableBytes?: number;
+    });
+}
+
+/**
+ * Error thrown when a model or estimator is used before being fitted.
+ *
+ * This is analogous to sklearn's NotFittedError.
+ *
+ * @example
+ * ```ts
+ * class MyModel {
+ *   private fitted = false;
+ *
+ *   fit(X: Tensor, y: Tensor) {
+ *     // ... fitting logic
+ *     this.fitted = true;
+ *   }
+ *
+ *   predict(X: Tensor) {
+ *     if (!this.fitted) {
+ *       throw new NotFittedError('Model must be fitted before prediction');
+ *     }
+ *     // ... prediction logic
+ *   }
+ * }
+ * ```
+ *
+ * References:
+ * - scikit-learn NotFittedError: https://scikit-learn.org/stable/modules/generated/sklearn.exceptions.NotFittedError.html
+ */
+declare class NotFittedError extends DeepboxError {
+    name: string;
+    /** The name of the model or estimator that was not fitted */
+    readonly modelName?: string;
+    constructor(message: string, modelName?: string);
+}
+
+/**
+ * Error thrown when a method or code path exists in the public API but is not implemented yet.
+ *
+ * Use this instead of a generic `Error` so callers can reliably detect this specific
+ * capability gap.
+ */
+declare class NotImplementedError extends DeepboxError {
+    /**
+     * Discriminator name for this error type.
+     */
+    name: string;
+    /**
+     * Create a new NotImplementedError.
+     *
+     * @param message - Optional error message.
+     */
+    constructor(message?: string);
+}
+
+/**
+ * Details about a shape mismatch error.
+ *
+ * @property expected - The expected shape
+ * @property received - The actual shape that was received
+ * @property context - Additional context about where the error occurred
+ */
+type ShapeErrorDetails = {
+    readonly expected?: Shape;
+    readonly received?: Shape;
+    readonly context?: string;
+};
+/**
+ * Error thrown when tensor shapes are incompatible or invalid.
+ *
+ * This error is used throughout the library when operations require specific
+ * tensor shapes that don't match the provided tensors.
+ *
+ * @example
+ * ```ts
+ * import { ShapeError } from 'deepbox/core';
+ *
+ * if (tensor.shape[0] !== expectedRows) {
+ *   throw ShapeError.mismatch([expectedRows, cols], tensor.shape, 'matrix multiplication');
+ * }
+ * ```
+ */
+declare class ShapeError extends DeepboxError {
+    name: string;
+    readonly expected: Shape | undefined;
+    readonly received: Shape | undefined;
+    readonly context: string | undefined;
+    constructor(message: string, details?: ShapeErrorDetails);
+    /**
+     * Create a ShapeError for a shape mismatch.
+     *
+     * Convenience factory method for the common case of shape mismatches.
+     *
+     * @param expected - The expected shape
+     * @param received - The actual shape that was received
+     * @param context - Optional context about where the mismatch occurred
+     * @returns A new ShapeError with formatted message and details
+     *
+     * @example
+     * ```ts
+     * throw ShapeError.mismatch([3, 4], [3, 5], 'matrix multiplication');
+     * // Error: Shape mismatch (matrix multiplication): expected [3,4], received [3,5]
+     * ```
+     */
+    static mismatch(expected: Shape, received: Shape, context?: string): ShapeError;
+}
+
+/**
+ * Error thrown when data validation fails.
+ *
+ * Used for input data that doesn't meet expected format or constraints.
+ *
+ * @example
+ * ```ts
+ * if (!Array.isArray(data)) {
+ *   throw new DataValidationError('Expected array input');
+ * }
+ * ```
+ */
+declare class DataValidationError extends DeepboxError {
+    name: string;
+}
+
+/**
+ * Normalize an axis argument to a valid dimension index.
+ *
+ * Supports negative indexing (Python-style) and string aliases:
+ * - "index" or "rows" -> 0
+ * - "columns" -> 1
+ *
+ * @param axis - Axis identifier (index or alias)
+ * @param ndim - Number of dimensions in the tensor
+ * @returns Non-negative integer dimension index
+ * @throws {InvalidParameterError} If axis is out of bounds
+ * @throws {InvalidParameterError} If axis alias is invalid
+ */
+declare function normalizeAxis(axis: Axis, ndim: number): number;
+/**
+ * Normalize a list of axes to valid dimension indices.
+ *
+ * Checks for duplicates and validity of each axis.
+ *
+ * @param axis - Single axis or array of axes
+ * @param ndim - Number of dimensions
+ * @returns Array of unique non-negative integer dimension indices
+ * @throws {InvalidParameterError} If any axis is invalid, out of bounds, or duplicated
+ */
+declare function normalizeAxes(axis: Axis | Axis[], ndim: number): number[];
+
+type NumericDType = Exclude<DType, "string">;
+/**
+ * Ensure a dtype is numeric (non-string).
+ *
+ * @param dtype - Data type identifier
+ * @param context - Context string for error messages
+ * @returns The same dtype narrowed to numeric types
+ * @throws {DTypeError} If dtype is 'string'
+ */
+declare function ensureNumericDType(dtype: DType, context: string): NumericDType;
+/**
+ * Get TypedArray constructor for a given DType.
+ *
+ * Maps Deepbox dtype strings to JavaScript TypedArray constructors.
+ * Used internally for allocating tensor storage.
+ *
+ * **Mapping:**
+ * - `float32` → `Float32Array`
+ * - `float64` → `Float64Array`
+ * - `int32` → `Int32Array`
+ * - `int64` → `BigInt64Array`
+ * - `uint8` → `Uint8Array`
+ * - `bool` → `Uint8Array` (1 byte per boolean)
+ * - `string` → Not supported (throws error)
+ *
+ * @param dtype - Data type identifier
+ * @returns TypedArray constructor for the given dtype
+ * @throws {DTypeError} If dtype is 'string' (not yet supported)
+ *
+ * @example
+ * ```ts
+ * const Ctor = dtypeToTypedArrayCtor('float32');
+ * const arr = new Ctor(10); // Float32Array with 10 elements
+ * ```
+ */
+declare function dtypeToTypedArrayCtor(dtype: DType): Float32ArrayConstructor | Float64ArrayConstructor | Int32ArrayConstructor | BigInt64ArrayConstructor | Uint8ArrayConstructor;
+
+/**
+ * Type-safe typed array accessor utilities.
+ *
+ * These utilities provide safe access to TypedArray elements without
+ * requiring unsafe type assertions. They handle the `noUncheckedIndexedAccess`
+ * TypeScript configuration properly.
+ *
+ * Element accessors for TypedArray storage throw {@link IndexError} on
+ * out-of-bounds access to surface stride/index bugs immediately rather
+ * than silently returning zero.
+ */
+
+/**
+ * Numeric typed arrays (excludes BigInt64Array).
+ */
+type NumericTypedArray = Float32Array | Float64Array | Int32Array | Uint8Array;
+/**
+ * Get an element from a numeric typed array at the specified index.
+ *
+ * @param arr - The numeric typed array
+ * @param index - The index to access
+ * @returns The element at the index
+ * @throws {IndexError} If the index is out of bounds
+ */
+declare function getNumericElement(arr: NumericTypedArray, index: number): number;
+/**
+ * Get an element from a BigInt64Array at the specified index.
+ *
+ * @param arr - The BigInt64Array
+ * @param index - The index to access
+ * @returns The element at the index
+ * @throws {IndexError} If the index is out of bounds
+ */
+declare function getBigIntElement(arr: BigInt64Array, index: number): bigint;
+/**
+ * Get an element from a TypedArray, returning as number.
+ * For BigInt64Array, converts to number (throws if out of safe integer range).
+ *
+ * @param arr - The typed array
+ * @param index - The index to access
+ * @returns The element at the index as a number
+ * @throws {IndexError} If the index is out of bounds
+ * @throws {DataValidationError} If a bigint value exceeds the safe integer range
+ */
+declare function getElementAsNumber(arr: TypedArray, index: number): number;
+/**
+ * Get an element from a shape array at the specified index.
+ * Returns 1 if the index is out of bounds (used in broadcasting where
+ * missing leading dimensions are treated as size 1).
+ *
+ * @param shape - The shape array
+ * @param index - The index to access
+ * @returns The dimension at the index, or 1 if out of bounds
+ */
+declare function getShapeDim(shape: readonly number[], index: number): number;
+/**
+ * Get an element from a number array at the specified index.
+ * Returns the provided default value if the index is out of bounds.
+ *
+ * @param arr - The number array
+ * @param index - The index to access
+ * @param defaultValue - The default value to return if out of bounds (default: 0)
+ * @returns The element at the index, or the default value if out of bounds
+ */
+declare function getArrayElement(arr: readonly number[], index: number, defaultValue?: number): number;
+/**
+ * Safely get a string from a string array at the specified index.
+ * Returns empty string if the index is out of bounds.
+ *
+ * @param arr - The string array
+ * @param index - The index to access
+ * @returns The string at the index, or empty string if out of bounds
+ */
+declare function getStringElement(arr: readonly string[], index: number): string;
+/**
+ * Create a readonly number array from mutable array with proper typing.
+ * This avoids the need for `as Shape` assertions.
+ *
+ * @param arr - The mutable number array
+ * @returns The same array typed as readonly
+ */
+declare function asReadonlyArray<T extends number[]>(arr: T): readonly number[];
+/**
+ * Type guard to check if a typed array is a BigInt64Array.
+ *
+ * @param arr - The typed array to check
+ * @returns True if the array is a BigInt64Array
+ */
+declare function isBigInt64Array(arr: TypedArray): arr is BigInt64Array;
+/**
+ * Type guard to check if a typed array is a numeric (non-BigInt) array.
+ *
+ * @param arr - The typed array to check
+ * @returns True if the array is a numeric typed array
+ */
+declare function isNumericTypedArray(arr: TypedArray): arr is NumericTypedArray;
+
+/**
+ * Type guard to check if a value is one of the supported TypedArray types.
+ *
+ * Returns true only for the exact TypedArray subclasses in the Deepbox
+ * {@link TypedArray} union: Float32Array, Float64Array, Int32Array,
+ * BigInt64Array, and Uint8Array. Returns false for unsupported typed arrays
+ * (e.g. Uint16Array, Int16Array), DataView, and regular arrays.
+ *
+ * @param value - The value to check
+ * @returns True if value is a supported TypedArray, false otherwise
+ *
+ * @example
+ * ```ts
+ * import { isTypedArray } from 'deepbox/core';
+ *
+ * isTypedArray(new Float32Array(10));  // true
+ * isTypedArray(new Uint16Array(10));   // false (unsupported)
+ * isTypedArray([1, 2, 3]);             // false
+ * isTypedArray(new DataView(new ArrayBuffer(10)));  // false
+ * ```
+ */
+declare function isTypedArray(value: unknown): value is TypedArray;
+
+/**
+ * Calculate the total number of elements from a shape.
+ *
+ * @param shape - The shape to calculate size from
+ * @param name - Parameter name for error messages (default: 'shape')
+ * @returns Total number of elements
+ * @throws {DataValidationError} If shape is invalid or size exceeds safe integer range
+ */
+declare function shapeToSize(shape: Shape): number;
+declare function shapeToSize(shape: unknown, name?: string): number;
+/**
+ * Validate that a shape is well-formed.
+ *
+ * Checks that:
+ * - Value is an array
+ * - All elements are finite non-negative integers
+ * - All elements are safe integers
+ *
+ * @param shape - The shape to validate
+ * @param name - Parameter name for error messages (default: 'shape')
+ * @returns The validated shape
+ * @throws {DataValidationError} If shape is invalid
+ */
+declare function validateShape(shape: Shape, name?: string): Shape;
+declare function validateShape(shape: unknown, name?: string): Shape;
+/**
+ * Validate that a `dtype` is supported.
+ *
+ * @param dtype - The data type to validate
+ * @param name - The parameter name for error messages
+ * @returns The validated dtype (typed as {@link DType})
+ * @throws {DataValidationError} If dtype is not valid
+ */
+declare function validateDtype(dtype: DType, name?: string): DType;
+declare function validateDtype(dtype: unknown, name?: string): DType;
+/**
+ * Validate that a `device` is supported.
+ *
+ * @param device - The device to validate
+ * @param name - The parameter name for error messages
+ * @returns The validated device (typed as {@link Device})
+ * @throws {DataValidationError} If device is not valid
+ */
+declare function validateDevice(device: Device, name?: string): Device;
+declare function validateDevice(device: unknown, name?: string): Device;
+/**
+ * Validate that a value is positive (> 0).
+ *
+ * @param value - The value to validate
+ * @param name - The parameter name for error messages
+ * @throws {DataValidationError} If value is not positive
+ */
+declare function validatePositive(value: number, name: string): void;
+/**
+ * Validate that a value is non-negative (>= 0).
+ *
+ * @param value - The value to validate
+ * @param name - The parameter name for error messages
+ * @throws {DataValidationError} If value is negative
+ */
+declare function validateNonNegative(value: number, name: string): void;
+/**
+ * Validate that a value is within a specified range [min, max].
+ *
+ * @param value - The value to validate
+ * @param min - The minimum allowed value (inclusive)
+ * @param max - The maximum allowed value (inclusive)
+ * @param name - The parameter name for error messages
+ * @throws {DataValidationError} If value is out of range or bounds are invalid
+ */
+declare function validateRange(value: number, min: number, max: number, name: string): void;
+/**
+ * Validate that a value is a safe integer.
+ *
+ * @param value - The value to validate
+ * @param name - The parameter name for error messages
+ * @throws {DataValidationError} If value is not a safe integer
+ */
+declare function validateInteger(value: number, name: string): void;
+/**
+ * Validate that a value is one of the allowed options.
+ *
+ * @param value - The value to validate
+ * @param options - The array of allowed values
+ * @param name - The parameter name for error messages
+ * @throws {DataValidationError} If value is not in options
+ */
+declare function validateOneOf<T extends string>(value: unknown, options: readonly T[], name: string): asserts value is T;
+/**
+ * Validate that a value is an array.
+ *
+ * @param arr - The value to validate
+ * @param name - The parameter name for error messages
+ * @throws {DataValidationError} If value is not an array
+ */
+declare function validateArray(arr: unknown, name: string): asserts arr is unknown[];
+
+/**
+ * Deepbox Core
+ *
+ * This module is the stable, dependency-light foundation shared by all other Deepbox
+ * subpackages. It exposes:
+ * - configuration helpers
+ * - error types
+ * - foundational types/constants
+ * - runtime validation and utility helpers
+ */
+
+declare const index_Axis: typeof Axis;
+type index_BroadcastError = BroadcastError;
+declare const index_BroadcastError: typeof BroadcastError;
+type index_ConvergenceError = ConvergenceError;
+declare const index_ConvergenceError: typeof ConvergenceError;
+type index_ConvergenceErrorDetails = ConvergenceErrorDetails;
+declare const index_DEVICES: typeof DEVICES;
+declare const index_DTYPES: typeof DTYPES;
+declare const index_DType: typeof DType;
+type index_DTypeError = DTypeError;
+declare const index_DTypeError: typeof DTypeError;
+type index_DataValidationError = DataValidationError;
+declare const index_DataValidationError: typeof DataValidationError;
+type index_DeepboxConfig = DeepboxConfig;
+type index_DeepboxError = DeepboxError;
+declare const index_DeepboxError: typeof DeepboxError;
+declare const index_Device: typeof Device;
+type index_DeviceError = DeviceError;
+declare const index_DeviceError: typeof DeviceError;
+type index_IndexError = IndexError;
+declare const index_IndexError: typeof IndexError;
+type index_InvalidParameterError = InvalidParameterError;
+declare const index_InvalidParameterError: typeof InvalidParameterError;
+type index_MemoryError = MemoryError;
+declare const index_MemoryError: typeof MemoryError;
+type index_NotFittedError = NotFittedError;
+declare const index_NotFittedError: typeof NotFittedError;
+type index_NotImplementedError = NotImplementedError;
+declare const index_NotImplementedError: typeof NotImplementedError;
+type index_NumericDType = NumericDType;
+type index_NumericTypedArray = NumericTypedArray;
+declare const index_Shape: typeof Shape;
+type index_ShapeError = ShapeError;
+declare const index_ShapeError: typeof ShapeError;
+type index_ShapeErrorDetails = ShapeErrorDetails;
+declare const index_TensorLike: typeof TensorLike;
+declare const index_TensorStorage: typeof TensorStorage;
+declare const index_TypedArray: typeof TypedArray;
+declare const index_asReadonlyArray: typeof asReadonlyArray;
+declare const index_dtypeToTypedArrayCtor: typeof dtypeToTypedArrayCtor;
+declare const index_ensureNumericDType: typeof ensureNumericDType;
+declare const index_getArrayElement: typeof getArrayElement;
+declare const index_getBigIntElement: typeof getBigIntElement;
+declare const index_getConfig: typeof getConfig;
+declare const index_getDevice: typeof getDevice;
+declare const index_getDtype: typeof getDtype;
+declare const index_getElementAsNumber: typeof getElementAsNumber;
+declare const index_getNumericElement: typeof getNumericElement;
+declare const index_getSeed: typeof getSeed;
+declare const index_getShapeDim: typeof getShapeDim;
+declare const index_getStringElement: typeof getStringElement;
+declare const index_isBigInt64Array: typeof isBigInt64Array;
+declare const index_isDType: typeof isDType;
+declare const index_isDevice: typeof isDevice;
+declare const index_isNumericTypedArray: typeof isNumericTypedArray;
+declare const index_isTypedArray: typeof isTypedArray;
+declare const index_normalizeAxes: typeof normalizeAxes;
+declare const index_normalizeAxis: typeof normalizeAxis;
+declare const index_resetConfig: typeof resetConfig;
+declare const index_setConfig: typeof setConfig;
+declare const index_setDevice: typeof setDevice;
+declare const index_setDtype: typeof setDtype;
+declare const index_setSeed: typeof setSeed;
+declare const index_shapeToSize: typeof shapeToSize;
+declare const index_validateArray: typeof validateArray;
+declare const index_validateDevice: typeof validateDevice;
+declare const index_validateDtype: typeof validateDtype;
+declare const index_validateInteger: typeof validateInteger;
+declare const index_validateNonNegative: typeof validateNonNegative;
+declare const index_validateOneOf: typeof validateOneOf;
+declare const index_validatePositive: typeof validatePositive;
+declare const index_validateRange: typeof validateRange;
+declare const index_validateShape: typeof validateShape;
+declare namespace index {
+  export { index_Axis as Axis, index_BroadcastError as BroadcastError, index_ConvergenceError as ConvergenceError, type index_ConvergenceErrorDetails as ConvergenceErrorDetails, index_DEVICES as DEVICES, index_DTYPES as DTYPES, index_DType as DType, index_DTypeError as DTypeError, index_DataValidationError as DataValidationError, type index_DeepboxConfig as DeepboxConfig, index_DeepboxError as DeepboxError, index_Device as Device, index_DeviceError as DeviceError, index_IndexError as IndexError, index_InvalidParameterError as InvalidParameterError, index_MemoryError as MemoryError, index_NotFittedError as NotFittedError, index_NotImplementedError as NotImplementedError, type index_NumericDType as NumericDType, type index_NumericTypedArray as NumericTypedArray, index_Shape as Shape, index_ShapeError as ShapeError, type index_ShapeErrorDetails as ShapeErrorDetails, index_TensorLike as TensorLike, index_TensorStorage as TensorStorage, index_TypedArray as TypedArray, index_asReadonlyArray as asReadonlyArray, index_dtypeToTypedArrayCtor as dtypeToTypedArrayCtor, index_ensureNumericDType as ensureNumericDType, index_getArrayElement as getArrayElement, index_getBigIntElement as getBigIntElement, index_getConfig as getConfig, index_getDevice as getDevice, index_getDtype as getDtype, index_getElementAsNumber as getElementAsNumber, index_getNumericElement as getNumericElement, index_getSeed as getSeed, index_getShapeDim as getShapeDim, index_getStringElement as getStringElement, index_isBigInt64Array as isBigInt64Array, index_isDType as isDType, index_isDevice as isDevice, index_isNumericTypedArray as isNumericTypedArray, index_isTypedArray as isTypedArray, index_normalizeAxes as normalizeAxes, index_normalizeAxis as normalizeAxis, index_resetConfig as resetConfig, index_setConfig as setConfig, index_setDevice as setDevice, index_setDtype as setDtype, index_setSeed as setSeed, index_shapeToSize as shapeToSize, index_validateArray as validateArray, index_validateDevice as validateDevice, index_validateDtype as validateDtype, index_validateInteger as validateInteger, index_validateNonNegative as validateNonNegative, index_validateOneOf as validateOneOf, index_validatePositive as validatePositive, index_validateRange as validateRange, index_validateShape as validateShape };
+}
+
+export { getStringElement as A, BroadcastError as B, ConvergenceError as C, type DeepboxConfig as D, isBigInt64Array as E, isNumericTypedArray as F, isTypedArray as G, type NumericDType as H, IndexError as I, type NumericTypedArray as J, normalizeAxes as K, normalizeAxis as L, MemoryError as M, NotFittedError as N, shapeToSize as O, validateArray as P, validateDevice as Q, validateDtype as R, ShapeError as S, validateInteger as T, validateNonNegative as U, validateOneOf as V, validatePositive as W, validateRange as X, validateShape as Y, getDevice as a, getDtype as b, getSeed as c, setDevice as d, setDtype as e, setSeed as f, getConfig as g, type ConvergenceErrorDetails as h, index as i, DataValidationError as j, DeepboxError as k, DeviceError as l, DTypeError as m, InvalidParameterError as n, NotImplementedError as o, type ShapeErrorDetails as p, asReadonlyArray as q, resetConfig as r, setConfig as s, dtypeToTypedArrayCtor as t, ensureNumericDType as u, getArrayElement as v, getBigIntElement as w, getElementAsNumber as x, getNumericElement as y, getShapeDim as z };