@slexisvn/mlfw 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,3552 @@
+declare class SymInt {
+    static var(name: any): SymInt;
+    static const(value: any): any;
+    static add(a: any, b: any): any;
+    static sub(a: any, b: any): any;
+    static neg(a: any): any;
+    static mul(a: any, b: any): any;
+    static div(a: any, b: any): any;
+    static mod(a: any, b: any): number | SymInt;
+    static max(a: any, b: any): any;
+    static min(a: any, b: any): any;
+    static ceilDiv(a: any, b: any): number | SymInt;
+    static equals(a: any, b: any): any;
+    static substitute(expr: any, varName: any, value: any): any;
+    static evaluate(expr: any, env: any): any;
+    static freeVars(expr: any, result?: Set<any>): Set<any>;
+    static isConst(expr: any): expr is number;
+    static toConst(expr: any): number | null;
+    constructor(type: any, name?: null, args?: any[]);
+    type: any;
+    name: any;
+    args: any[];
+    toString(): any;
+}
+
+type SymIntValue = InstanceType<typeof SymInt>;
+type Dim = number | SymIntValue;
+type Shape$1 = readonly Dim[];
+type ScalarDType = `${ScalarType}`;
+declare enum ScalarType {
+    F16 = "f16",
+    BF16 = "bf16",
+    F32 = "f32",
+    F64 = "f64",
+    I8 = "i8",
+    I16 = "i16",
+    I32 = "i32",
+    I64 = "i64",
+    UI8 = "ui8",
+    BOOL = "bool",
+    INDEX = "index"
+}
+declare class Layout {
+    readonly order: readonly number[];
+    private _hash;
+    constructor(order: readonly number[]);
+    static rowMajor(rank: number): Layout;
+    static columnMajor(rank: number): Layout;
+    get rank(): number;
+    isIdentity(): boolean;
+    inverse(): Layout;
+    compose(other: Layout): Layout;
+    computeStrides(shape: Shape$1): number[];
+    equals(other: unknown): boolean;
+    hash(): number;
+}
+declare class TensorType {
+    readonly shape: readonly Dim[];
+    readonly dtype: ScalarDType;
+    readonly layout: Layout;
+    private _hash;
+    constructor(shape: Shape$1, dtype: ScalarDType, layout?: Layout | null);
+    get rank(): number;
+    get isScalar(): boolean;
+    get isFullyStatic(): boolean;
+    get hasDynamic(): boolean;
+    numel(): number;
+    symbolicNumel(): number | SymIntValue;
+    sizeInBytes(): number;
+    strides(): number[];
+    withShape(s: Shape$1): TensorType;
+    withDtype(d: ScalarDType): TensorType;
+    withLayout(l: Layout): TensorType;
+    equals(other: unknown): boolean;
+    shapeEquals(other: unknown): boolean;
+    shapeCompatible(other: TensorType): boolean;
+    hash(): number;
+    static broadcastShape(...shapes: Shape$1[]): Dim[] | null;
+    static broadcastCompatible(...shapes: Shape$1[]): boolean;
+}
+
+type DType = ScalarDType;
+type NumericTypedArray = Uint16Array | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Uint8Array;
+
+declare enum DeviceType {
+    CPU = "cpu",
+    GPU = "gpu",
+    WASM = "wasm",
+    WEBGPU = "webgpu",
+    META = "meta",
+    LAZY = "lazy"
+}
+type DeviceTypeName = `${DeviceType}`;
+declare class Device {
+    readonly type: DeviceTypeName;
+    readonly index: number;
+    constructor(type: DeviceTypeName, index?: number);
+    dispatchKey(): number;
+    equals(other: Device): boolean;
+    hash(): number;
+    toString(): string;
+}
+declare const CPU_DEVICE: Device;
+declare const GPU_DEVICE: Device;
+declare const WASM_DEVICE: Device;
+declare const WEBGPU_DEVICE: Device;
+declare function getDefaultDevice(): Device;
+declare function setDefaultDevice(device: Device): void;
+
+declare class CPUAllocator {
+    allocate(count: number, dtype: DType): NumericTypedArray;
+    free(_data?: NumericTypedArray): void;
+}
+declare class MetaAllocator {
+    allocate(): null;
+    free(_data?: NumericTypedArray): void;
+}
+type Allocator = CPUAllocator | MetaAllocator;
+declare class StorageImpl {
+    #private;
+    private _data;
+    private _nbytes;
+    private readonly _device;
+    private readonly _allocator;
+    private _refCount;
+    static setHostReadHook(fn: ((data: NumericTypedArray) => void) | null): void;
+    constructor(data: NumericTypedArray | null, nbytes: number, device: Device, allocator: Allocator);
+    static allocate(nbytes: number, dtype: DType, device: Device): StorageImpl;
+    static fromData(data: NumericTypedArray | null, device: Device): StorageImpl;
+    retain(): StorageImpl;
+    release(): void;
+    get refCount(): number;
+    get data(): NumericTypedArray | null;
+    get rawData(): NumericTypedArray | null;
+    get nbytes(): number;
+    get device(): Device;
+    get isValid(): boolean;
+    get isMeta(): boolean;
+    resize(newNbytes: number, dtype: DType): void;
+    clone(): StorageImpl;
+}
+
+declare class Storage {
+    private readonly _impl;
+    constructor(impl: StorageImpl);
+    static allocate(nbytes: number, dtype: DType, device: Device): Storage;
+    static fromData(data: NumericTypedArray | null, device: Device): Storage;
+    get impl(): StorageImpl;
+    get data(): NumericTypedArray | null;
+    get rawData(): NumericTypedArray | null;
+    get nbytes(): number;
+    get device(): Device;
+    get isValid(): boolean;
+    get isMeta(): boolean;
+    retain(): Storage;
+    release(): void;
+    clone(): Storage;
+    resize(nbytes: number, dtype: DType): void;
+}
+
+declare enum DispatchKey {
+    CPU = 0,
+    GPU = 1,
+    WASM = 2,
+    META = 3,
+    LAZY = 4,
+    CUSTOM_0 = 5,
+    CUSTOM_1 = 6,
+    CUSTOM_2 = 7,
+    CUSTOM_3 = 8,
+    BATCHED = 20,
+    VMAP = 24,
+    FUNCTIONALIZE = 28,
+    AUTOCAST = 32,
+    AUTOGRAD = 40,
+    AUTOGRAD_CPU = 41,
+    AUTOGRAD_GPU = 42,
+    AUTOGRAD_WASM = 43,
+    TRACING = 48,
+    NUM_KEYS = 49
+}
+type DispatchKeyValue = DispatchKey;
+declare class DispatchKeySet {
+    private readonly _lo;
+    private readonly _hi;
+    constructor(lo: number, hi: number);
+    static fromKey(key: DispatchKeyValue): DispatchKeySet;
+    static fromKeys(...keys: DispatchKeyValue[]): DispatchKeySet;
+    add(key: DispatchKeyValue): DispatchKeySet;
+    remove(key: DispatchKeyValue): DispatchKeySet;
+    has(key: DispatchKeyValue): boolean;
+    without(key: DispatchKeyValue): DispatchKeySet;
+    union(other: DispatchKeySet): DispatchKeySet;
+    intersect(other: DispatchKeySet): DispatchKeySet;
+    subtract(other: DispatchKeySet): DispatchKeySet;
+    isEmpty(): boolean;
+    equals(other: DispatchKeySet): boolean;
+    highestPriority(): number;
+    lowestPriority(): number;
+    count(): number;
+    [Symbol.iterator](): Generator<DispatchKeyValue>;
+    toString(): string;
+}
+
+declare enum MemoryFormat {
+    CONTIGUOUS = "contiguous",
+    CHANNELS_LAST = "channels_last",
+    PRESERVE = "preserve"
+}
+type MemoryFormatValue = `${MemoryFormat}`;
+
+declare class AutogradMeta {
+    private _grad;
+    private _gradFn;
+    private _outputNr;
+    private _requiresGrad;
+    private _retainGrad;
+    private _gradAccumulator;
+    private _versionAtCreation;
+    constructor();
+    get grad(): Tensor | null;
+    set grad(tensor: Tensor | null);
+    get gradFn(): unknown | null;
+    setGradFn(node: unknown, outputNr?: number): void;
+    get outputNr(): number;
+    get requiresGrad(): boolean;
+    set requiresGrad(flag: boolean);
+    get retainGrad(): boolean;
+    set retainGrad(flag: boolean);
+    get isLeaf(): boolean;
+    get versionAtCreation(): number;
+    set versionAtCreation(v: number);
+    getGradAccumulator(): object | null;
+    setGradAccumulator(acc: object): void;
+    clearGrad(): void;
+    clearGradFn(): void;
+}
+
+declare class TensorImpl {
+    private _storage;
+    private _storageOffset;
+    private _sizes;
+    private _strides;
+    private _dtype;
+    private _device;
+    private _numel;
+    private _keySet;
+    private _autogradMeta;
+    private _version;
+    private _contiguousCache;
+    constructor(storage: Storage, storageOffset: number, sizes: readonly number[], strides: readonly number[] | null, dtype: DType, device: Device);
+    get storage(): Storage;
+    get storageOffset(): number;
+    size(dim: number): number;
+    stride(dim: number): number;
+    sizes(): readonly number[];
+    strides(): readonly number[];
+    dim(): number;
+    numel(): number;
+    get dtype(): DType;
+    get device(): Device;
+    isContiguous(format?: MemoryFormatValue): boolean;
+    setSizesAndStrides(sizes: readonly number[], strides?: readonly number[]): void;
+    setStorageOffset(offset: number): void;
+    bumpVersion(): void;
+    get version(): number;
+    get autogradMeta(): AutogradMeta | null;
+    setAutogradMeta(meta: AutogradMeta | null): void;
+    keySet(): DispatchKeySet;
+    addKeyToSet(key: DispatchKeyValue): void;
+    removeKeyFromSet(key: DispatchKeyValue): void;
+    _updateKeySet(): void;
+    get isMeta(): boolean;
+    shallowCopyFrom(other: TensorImpl): void;
+}
+
+declare class Tensor {
+    readonly _impl: TensorImpl;
+    constructor(impl: TensorImpl);
+    get impl(): TensorImpl;
+    get shape(): readonly number[];
+    get strides(): readonly number[];
+    get dtype(): DType;
+    get device(): Device;
+    get ndim(): number;
+    get rank(): number;
+    get numel(): number;
+    get length(): number;
+    get isContiguous(): boolean;
+    get dispatchKeySet(): DispatchKeySet;
+    get storage(): Storage;
+    get storageOffset(): number;
+    get data(): NumericTypedArray | null;
+    get requiresGrad(): boolean;
+    get gradFn(): unknown | null;
+    get grad(): Tensor | null;
+    set grad(t: Tensor | null);
+    get isLeaf(): boolean;
+    get version(): number;
+    requiresGrad_(flag?: boolean): this;
+    retainGrad(): this;
+    detach(): Tensor;
+    item(): number | bigint;
+    toArray(): number | bigint | NestedArray;
+    toString(): string;
+    [Symbol.iterator](): Generator<Tensor>;
+    _select(dim: number, index: number): Tensor;
+    _ensureAutogradMeta(): AutogradMeta;
+    backward(gradOutput?: Tensor): void;
+}
+type NestedArray = Array<number | bigint | NestedArray>;
+
+declare const GradMode: {
+    isEnabled(): boolean;
+    setEnabled(flag: boolean): void;
+};
+declare function noGrad<T>(fn: () => T): T;
+declare function enableGrad<T>(fn: () => T): T;
+
+type SymbolicDim = Dim | string;
+type SymbolicShape = readonly SymbolicDim[];
+type MutableSymbolicShape = SymbolicDim[];
+type TensorInput$2 = Tensor;
+type TensorOutput = Tensor | SymbolicTensor;
+type MaybePromise<T> = T | Promise<T>;
+type AttrValue = unknown;
+type AttrMap = Record<string, AttrValue>;
+type DynamicShapeSpec = true | Set<number> | null | undefined;
+type DynamicShapes = readonly DynamicShapeSpec[] | null | undefined;
+type IRValueLike = {
+    id?: number;
+    type: TensorType;
+    symbolicShape?: SymbolicShape;
+    addUse?: (link: unknown) => void;
+    removeUse?: (link: unknown) => void;
+    replaceAllUsesWith?: (value: IRValueLike) => void;
+};
+type IROperationLike = {
+    opName: string;
+    operands: IRValueLike[];
+    numOperands: number;
+    numResults: number;
+    getResult(index: number): IRValueLike;
+    erase(): void;
+};
+type IRBlockLike = {
+    arguments: IRValueLike[];
+    firstOp: IROperationLike | null;
+    lastOp: IROperationLike | null;
+    addArgument(type: TensorType): IRValueLike;
+    getArgument(index: number): IRValueLike | undefined;
+    insertBefore(op: IROperationLike, before: IROperationLike): void;
+    pushOp(op: IROperationLike): void;
+    removeArguments(indices: Set<number>): void;
+};
+type GraphFunctionLike$1 = {
+    name: string;
+    inputTypes: readonly TensorType[];
+    outputTypes: readonly TensorType[];
+    entryBlock: IRBlockLike;
+    args: IRValueLike[];
+    getReturnOp(): IROperationLike | null;
+};
+type GraphModuleLike = {
+    addFunction(func: GraphFunctionLike$1): void;
+    functions(): IterableIterator<GraphFunctionLike$1>;
+};
+type CompilableModel = {
+    constructor: {
+        name?: string;
+    };
+    forward(...inputs: TensorOutput[]): MaybePromise<TensorOutput | TensorOutput[]>;
+};
+type CompileOptions = Record<string, unknown> & {
+    name?: string;
+    target?: unknown;
+    backward?: unknown;
+    dynamicShapes?: DynamicShapes;
+    dynamic_shapes?: DynamicShapes;
+    shapeBuckets?: readonly (readonly (readonly number[])[])[];
+    foldWeights?: boolean;
+    quantization?: {
+        foldWeights?: boolean;
+    };
+    mode?: string;
+    rematPolicy?: unknown;
+    remat?: Record<string, unknown>;
+};
+
+type GuardOp = 'eq' | 'ne' | 'gt' | 'ge' | 'lt' | 'le';
+type SymbolInfo = {
+    hint: number;
+    inputIdx: number;
+    dimIdx: number;
+};
+type RelationGuard = {
+    lhs: SymbolicDim;
+    op: GuardOp;
+    rhs: SymbolicDim;
+};
+type DivisibleGuard = {
+    type: 'divisible';
+    sym: SymbolicDim;
+    divisor: number;
+};
+type ShapeGuard = RelationGuard | DivisibleGuard;
+declare class ShapeEnv {
+    private _symbols;
+    private _guards;
+    private _bindings;
+    private _nextId;
+    constructor();
+    allocate(inputIdx: number, dimIdx: number, hint: number): string;
+    produceShapeSpec(inputIdx: number, concreteShape: readonly number[], dynamicDims?: Set<number> | null): {
+        irShape: number[];
+        symShape: MutableSymbolicShape;
+    };
+    guardRelation(lhs: SymbolicDim, op: GuardOp, rhs: SymbolicDim): void;
+    guardDivisible(sym: SymbolicDim, divisor: number): void;
+    bindInputShapes(inputs: readonly TensorInput$2[]): void;
+    evaluateGuards(): {
+        passed: true;
+        failedGuard: null;
+    } | {
+        passed: false;
+        failedGuard: ShapeGuard;
+    };
+    resolveSymbolicShape(symShape: SymbolicShape): number[];
+    _resolve(expr: SymbolicDim): number;
+    get symbols(): Map<string, SymbolInfo>;
+    get guards(): ShapeGuard[];
+    get bindings(): Map<string, number>;
+}
+
+type Shape = readonly number[];
+
+declare class Tracer {
+    private _name;
+    private _shapeEnv;
+    private _inputTypes;
+    private _inputSymShapes;
+    private _outputTypes;
+    private _outputSymShapes;
+    private _inputs;
+    private _func;
+    private _builder;
+    private _module;
+    private _capturedParams;
+    private _capturedParamOrder;
+    constructor(name?: string);
+    get shapeEnv(): ShapeEnv;
+    createInput(shape: Shape, dtype: DType, dynamicDims?: Set<number> | null): {
+        shape: number[];
+        dtype: DType;
+        tensorType: TensorType;
+    };
+    _initGraph(): SymbolicTensor[];
+    recordOp(opName: string, tensorArgs: readonly TensorOutput[], attrs: AttrMap): SymbolicTensor | SymbolicTensor[];
+    _propagateSymbolicShape(opName: string, op: IROperationLike, tensorArgs: readonly TensorOutput[], resultType: TensorType, resultIndex?: number): SymbolicShape;
+    scan(xsValues: readonly TensorOutput[], carryValues: readonly TensorOutput[], stepFn: (carry: SymbolicTensor[], xs: SymbolicTensor[]) => [SymbolicTensor[], SymbolicTensor[]]): [SymbolicTensor[], SymbolicTensor[]];
+    captureConstant(tensor: Tensor): SymbolicTensor;
+    get capturedParams(): Tensor[];
+    markOutput(symbolicTensor: TensorOutput): void;
+    markOutputs(symbolicTensors: readonly SymbolicTensor[]): void;
+    get outputSymShapes(): SymbolicShape[];
+    getGraphModule(): GraphModuleLike;
+    activate(): void;
+    deactivate(): void;
+    private _requireBuilder;
+    private _requireFunc;
+    private _requireModule;
+}
+
+declare class SymbolicTensor extends Tensor {
+    private _irValue;
+    private _tracer;
+    private _symbolicShape;
+    constructor(irValue: IRValueLike, shape: readonly number[], dtype: DType, tracer: Tracer, symbolicShape: SymbolicShape);
+    get irValue(): IRValueLike;
+    get tracer(): Tracer;
+    get symbolicShape(): SymbolicShape;
+    get dispatchKeySet(): DispatchKeySet;
+    get isSymbolic(): boolean;
+}
+
+declare const TraceLevel: Readonly<{
+    SILENT: 0;
+    INFO: 1;
+    VERBOSE: 2;
+    DEBUG: 3;
+}>;
+
+declare function printModule(module: any): string;
+
+declare function preloadCudaRuntime(): Promise<any>;
+declare function preloadWebGPU(): Promise<any>;
+
+declare function flushWebGPUEager(): Promise<void>;
+
+declare enum IValueTag {
+    TENSOR = 0,
+    INT = 1,
+    FLOAT = 2,
+    BOOL = 3,
+    INT_LIST = 4,
+    TENSOR_LIST = 5,
+    STRING = 6,
+    NONE = 7,
+    DEVICE = 8,
+    DTYPE = 9
+}
+type IValueTagValue = IValueTag;
+type BoxedFn = (keySet: unknown, stack: IValue[]) => IValue | IValue[] | unknown;
+type UnboxedFn = (keySet: unknown, ...args: unknown[]) => unknown;
+declare class IValue {
+    readonly tag: IValueTagValue;
+    readonly value: unknown;
+    constructor(tag: IValueTagValue, value: unknown);
+    static tensor(t: unknown): IValue;
+    static int(n: number): IValue;
+    static float(n: number): IValue;
+    static bool(b: boolean): IValue;
+    static intList(arr: unknown[]): IValue;
+    static tensorList(arr: unknown[]): IValue;
+    static string(s: string): IValue;
+    static none(): IValue;
+    static device(d: unknown): IValue;
+    static dtype(d: unknown): IValue;
+    isTensor(): boolean;
+    isInt(): boolean;
+    isFloat(): boolean;
+    isBool(): boolean;
+    isIntList(): boolean;
+    isTensorList(): boolean;
+    isString(): boolean;
+    isNone(): boolean;
+    toTensor(): unknown;
+    toInt(): unknown;
+    toFloat(): unknown;
+    toBool(): unknown;
+    toIntList(): unknown;
+    toTensorList(): unknown;
+    toString(): unknown;
+    toDevice(): unknown;
+    toDtype(): unknown;
+}
+
+declare class KernelFunction {
+    private readonly _boxed;
+    private readonly _unboxed;
+    constructor(boxed?: BoxedFn, unboxed?: UnboxedFn);
+    static fromBoxed(fn: BoxedFn): KernelFunction;
+    static fromUnboxed(fn: UnboxedFn): KernelFunction;
+    static fromBoth(boxed: BoxedFn, unboxed: UnboxedFn): KernelFunction;
+    get isBoxed(): boolean;
+    get isUnboxed(): boolean;
+    callUnboxed(keySet: unknown, ...args: unknown[]): unknown;
+    callBoxed(keySet: unknown, stack: IValue[]): unknown;
+    _callBoxedAsUnboxed(keySet: unknown, args: unknown[]): unknown;
+    _callUnboxedAsBoxed(keySet: unknown, stack: IValue[]): IValue[];
+}
+
+declare enum ArgKind {
+    TENSOR = "Tensor",
+    SCALAR = "Scalar",
+    INT = "int",
+    FLOAT = "float",
+    BOOL = "bool",
+    INT_LIST = "int[]",
+    TENSOR_LIST = "Tensor[]",
+    DTYPE = "Dtype",
+    DEVICE = "Device",
+    STRING = "str",
+    MEMORY_FORMAT = "MemoryFormat"
+}
+type ArgKindValue = `${ArgKind}`;
+type ReturnSpec = Readonly<{
+    kind: ArgKindValue;
+}>;
+declare class SchemaArg {
+    readonly name: string;
+    readonly kind: ArgKindValue;
+    readonly defaultValue: string | null;
+    readonly isOut: boolean;
+    constructor(name: string, kind: ArgKindValue, defaultValue?: string, isOut?: boolean);
+    get isTensor(): boolean;
+}
+declare class OperatorSchema {
+    readonly namespace: string;
+    readonly name: string;
+    readonly overload: string;
+    readonly args: readonly SchemaArg[];
+    readonly returns: readonly ReturnSpec[];
+    private _key;
+    private _tensorArgIndices;
+    constructor(namespace: string, name: string, overload: string, args: readonly SchemaArg[], returns: readonly ReturnSpec[]);
+    qualifiedName(): string;
+    key(): string;
+    get tensorArgIndices(): readonly number[];
+    get numTensorArgs(): number;
+}
+
+type KernelLookup = Readonly<{
+    key: DispatchKeyValue | -1;
+    kernel: KernelFunction;
+}>;
+declare class OperatorEntry {
+    private readonly _schema;
+    private readonly _kernels;
+    private _catchAll;
+    constructor(schema: OperatorSchema);
+    get schema(): OperatorSchema;
+    registerKernel(key: DispatchKeyValue, kernelFn: KernelFunction): void;
+    removeKernel(key: DispatchKeyValue): void;
+    lookupKernel(key: DispatchKeyValue): KernelFunction | null;
+    hasKernel(key: DispatchKeyValue): boolean;
+    get catchAll(): KernelFunction | null;
+    setCatchAll(kernelFn: KernelFunction): void;
+    bestKernel(keySet: DispatchKeySet): KernelLookup | null;
+    registeredKeys(): DispatchKeyValue[];
+}
+
+declare class OperatorHandle {
+    private readonly _entry;
+    private readonly _schema;
+    constructor(entry: OperatorEntry, schema: OperatorSchema);
+    get entry(): OperatorEntry;
+    get schema(): OperatorSchema;
+    get name(): string;
+    get qualifiedName(): string;
+    get key(): string;
+    get tensorArgIndices(): readonly number[];
+    lookupKernel(dispatchKey: DispatchKeyValue): KernelFunction | null;
+    bestKernel(keySet: DispatchKeySet): KernelLookup | null;
+}
+
+declare class FallbackTable {
+    private readonly _kernels;
+    constructor();
+    register(key: DispatchKeyValue, kernelFn: KernelFunction): void;
+    remove(key: DispatchKeyValue): void;
+    lookup(key: DispatchKeyValue): KernelFunction | null;
+    has(key: DispatchKeyValue): boolean;
+    registeredKeys(): DispatchKeyValue[];
+}
+
+type DispatchArg = unknown;
+declare class Dispatcher {
+    private readonly _entries;
+    private readonly _handles;
+    private readonly _fallbacks;
+    constructor();
+    registerOp(schema: OperatorSchema): OperatorHandle;
+    findOp(name: string): OperatorHandle | null;
+    findOrRegisterOp(name: string): OperatorHandle;
+    registerKernel(name: string, key: DispatchKeyValue, kernelFn: KernelFunction): void;
+    registerFallback(key: DispatchKeyValue, kernelFn: KernelFunction): void;
+    dispatch(handle: OperatorHandle, keySet: DispatchKeySet, ...args: DispatchArg[]): unknown;
+    redispatch(handle: OperatorHandle, keySet: DispatchKeySet, ...args: DispatchArg[]): unknown;
+    _dispatchInternal(handle: OperatorHandle, keySet: DispatchKeySet, args: DispatchArg[]): unknown;
+    callOp(name: string, ...args: DispatchArg[]): unknown;
+    listOps(): string[];
+    hasOp(name: string): boolean;
+    get fallbacks(): FallbackTable;
+}
+declare const dispatcher: Dispatcher;
+
+type TensorOptions = {
+    shape?: readonly number[];
+    dtype?: DType;
+    device?: Device;
+    requiresGrad?: boolean;
+    offset?: number;
+};
+type TensorDataOptions = Pick<TensorOptions, 'dtype' | 'device'>;
+
+declare function empty(shape: readonly number[], opts?: TensorOptions): Tensor;
+declare function zeros(shape: readonly number[], opts?: TensorOptions): Tensor;
+declare function ones(shape: readonly number[], opts?: TensorOptions): Tensor;
+declare function full(shape: readonly number[], value: number | bigint, opts?: TensorOptions): Tensor;
+declare function randn(shape: readonly number[], opts?: TensorOptions): Tensor;
+declare function arange(start: number, end?: number, step?: number, opts?: TensorOptions): Tensor;
+declare function eye(n: number, m?: number, opts?: TensorOptions): Tensor;
+declare function randperm(n: number, opts?: TensorOptions): Tensor;
+declare function linspace(start: number, end: number, steps: number, opts?: TensorOptions): Tensor;
+
+declare function emptyLike(tensor: Tensor, opts?: TensorOptions): Tensor;
+declare function zerosLike(tensor: Tensor, opts?: TensorOptions): Tensor;
+declare function onesLike(tensor: Tensor, opts?: TensorOptions): Tensor;
+declare function fullLike(tensor: Tensor, value: number | bigint, opts?: TensorOptions): Tensor;
+declare function randnLike(tensor: Tensor, opts?: TensorOptions): Tensor;
+
+type NestedNumberArray = readonly (number | NestedNumberArray)[];
+type TensorInput$1 = number | ArrayLike<number> | NestedNumberArray | NumericTypedArray;
+declare function tensor(data: TensorInput$1, opts?: TensorOptions): Tensor;
+declare function fromBuffer(buffer: NumericTypedArray, shape: readonly number[], dtype: DType, opts?: TensorOptions): Tensor;
+declare function scalar(value: number, opts?: TensorOptions): Tensor;
+
+type TensorInput = Tensor | number;
+type PaddingArg = readonly number[] | readonly (readonly number[])[];
+declare function _dispatch(name: string, ...args: unknown[]): unknown;
+declare function add(self: Tensor, other: TensorInput): Tensor;
+declare function sub(self: Tensor, other: TensorInput): Tensor;
+declare function mul(self: Tensor, other: TensorInput): Tensor;
+declare function div(self: Tensor, other: TensorInput): Tensor;
+declare function neg(self: Tensor): Tensor;
+declare function pow(self: Tensor, exponent: TensorInput): Tensor;
+declare function remainder(self: Tensor, other: TensorInput): Tensor;
+declare function maximum(self: Tensor, other: TensorInput): Tensor;
+declare function minimum(self: Tensor, other: TensorInput): Tensor;
+declare function exp(self: Tensor): Tensor;
+declare function log(self: Tensor): Tensor;
+declare function sqrt(self: Tensor): Tensor;
+declare function rsqrt(self: Tensor): Tensor;
+declare function abs(self: Tensor): Tensor;
+declare function sin(self: Tensor): Tensor;
+declare function cos(self: Tensor): Tensor;
+declare function tanh$1(self: Tensor): Tensor;
+declare function erf(self: Tensor): Tensor;
+declare function erfc(self: Tensor): Tensor;
+declare function lgamma(self: Tensor): Tensor;
+declare function gamma(self: Tensor): Tensor;
+declare function sigmoid$1(self: Tensor): Tensor;
+declare function relu$1(self: Tensor): Tensor;
+declare function gelu$1(self: Tensor): Tensor;
+declare function silu$1(self: Tensor): Tensor;
+declare function sign(self: Tensor): Tensor;
+declare function floor(self: Tensor): Tensor;
+declare function ceil(self: Tensor): Tensor;
+declare function eq(self: Tensor, other: TensorInput): Tensor;
+declare function ne(self: Tensor, other: TensorInput): Tensor;
+declare function lt(self: Tensor, other: TensorInput): Tensor;
+declare function le(self: Tensor, other: TensorInput): Tensor;
+declare function gt(self: Tensor, other: TensorInput): Tensor;
+declare function ge(self: Tensor, other: TensorInput): Tensor;
+declare function where(condition: Tensor, self: Tensor, other: Tensor): Tensor;
+declare function clamp(self: Tensor, min: TensorInput, max: TensorInput): Tensor;
+declare function pad(self: Tensor, low: readonly number[], high: readonly number[], value?: TensorInput): Tensor;
+declare function one_hot(indices: Tensor, depth: number): Tensor;
+declare function index_select(self: Tensor, dim: number, index: Tensor): Tensor;
+declare function gather(self: Tensor, dim: number, index: Tensor): Tensor;
+declare function scatter_add(self: Tensor, dim: number, index: Tensor, src: Tensor): Tensor;
+declare function scatter(self: Tensor, dim: number, index: Tensor, src: Tensor): Tensor;
+declare function sum(self: Tensor, dim?: number | readonly number[] | null, keepdim?: boolean): Tensor;
+declare function mean(self: Tensor, dim?: number | readonly number[] | null, keepdim?: boolean): Tensor;
+declare function max(self: Tensor, dim?: number | readonly number[] | null, keepdim?: boolean): Tensor;
+declare function min(self: Tensor, dim?: number | readonly number[] | null, keepdim?: boolean): Tensor;
+declare function argmax(self: Tensor, dim?: number | null, keepdim?: boolean): Tensor;
+declare function argmin(self: Tensor, dim?: number | null, keepdim?: boolean): Tensor;
+declare function prod(self: Tensor, dim?: number | readonly number[] | null, keepdim?: boolean): Tensor;
+declare function matmul(self: Tensor, other: Tensor): Tensor;
+declare function dot(self: Tensor, other: Tensor): Tensor;
+declare function cat(tensors: readonly Tensor[], dim: number): Tensor;
+declare function stack(tensors: readonly Tensor[], dim: number): Tensor;
+declare function clone(self: Tensor): Tensor;
+declare function fill(self: Tensor, value: number | bigint): Tensor;
+declare function reshape(self: Tensor, shape: readonly number[]): Tensor;
+declare function transpose(self: Tensor, dim0: number, dim1: number): Tensor;
+declare function permute(self: Tensor, dims: readonly number[]): Tensor;
+declare function broadcast_in_dim(self: Tensor, resultShape: readonly number[], broadcastDimensions: readonly number[]): Tensor;
+declare function expand(self: Tensor, shape: readonly number[]): Tensor;
+declare function slice(self: Tensor, dim: number, start: number, end?: number | null, step?: number): Tensor;
+declare function unsqueeze(self: Tensor, dim: number): Tensor;
+declare function squeeze(self: Tensor, dim?: number | null): Tensor;
+declare function narrow(self: Tensor, dim: number, start: number, length: number): Tensor;
+declare function select(self: Tensor, dim: number, index: number): Tensor;
+declare function contiguous(self: Tensor): Tensor;
+declare function repeat(self: Tensor, reps: readonly number[]): Tensor;
+declare function tile(self: Tensor, reps: readonly number[]): Tensor;
+declare function split(self: Tensor, sizeOrSizes: number | readonly number[], dim?: number): Tensor[];
+declare function chunk(self: Tensor, chunks: number, dim?: number): Tensor[];
+declare function roll(self: Tensor, shift: number, dim?: number): Tensor;
+declare function flip(self: Tensor, dims: number | readonly number[]): Tensor;
+declare function cumsum(self: Tensor, dim?: number): Tensor;
+declare function sort(self: Tensor, dim?: number, descending?: boolean): Tensor;
+declare function argsort(self: Tensor, dim?: number, descending?: boolean): Tensor;
+declare function topk(self: Tensor, k: number, dim?: number, largest?: boolean): Tensor[];
+declare function softmax$1(self: Tensor, dim: number): Tensor;
+declare function log_softmax$1(self: Tensor, dim: number): Tensor;
+declare function layer_norm(input: Tensor, weight: Tensor, bias: Tensor, axis: number, eps: number): Tensor;
+declare function batch_norm(input: Tensor, weight: Tensor, bias: Tensor, mean: Tensor, variance: Tensor, axis: number, eps: number): Tensor;
+declare function conv2d(input: Tensor, weight: Tensor, strides: readonly number[], padding: PaddingArg, dilation: readonly number[], groups: number): Tensor;
+declare function pool2d(input: Tensor, poolType: string, kernelSize: readonly number[], strides: readonly number[], padding: PaddingArg): Tensor;
+declare function embedding(weight: Tensor, indices: Tensor): Tensor;
+
+declare const ops__dispatch: typeof _dispatch;
+declare const ops_abs: typeof abs;
+declare const ops_add: typeof add;
+declare const ops_argmax: typeof argmax;
+declare const ops_argmin: typeof argmin;
+declare const ops_argsort: typeof argsort;
+declare const ops_batch_norm: typeof batch_norm;
+declare const ops_broadcast_in_dim: typeof broadcast_in_dim;
+declare const ops_cat: typeof cat;
+declare const ops_ceil: typeof ceil;
+declare const ops_chunk: typeof chunk;
+declare const ops_clamp: typeof clamp;
+declare const ops_clone: typeof clone;
+declare const ops_contiguous: typeof contiguous;
+declare const ops_conv2d: typeof conv2d;
+declare const ops_cos: typeof cos;
+declare const ops_cumsum: typeof cumsum;
+declare const ops_div: typeof div;
+declare const ops_dot: typeof dot;
+declare const ops_embedding: typeof embedding;
+declare const ops_eq: typeof eq;
+declare const ops_erf: typeof erf;
+declare const ops_erfc: typeof erfc;
+declare const ops_exp: typeof exp;
+declare const ops_expand: typeof expand;
+declare const ops_fill: typeof fill;
+declare const ops_flip: typeof flip;
+declare const ops_floor: typeof floor;
+declare const ops_gamma: typeof gamma;
+declare const ops_gather: typeof gather;
+declare const ops_ge: typeof ge;
+declare const ops_gt: typeof gt;
+declare const ops_index_select: typeof index_select;
+declare const ops_layer_norm: typeof layer_norm;
+declare const ops_le: typeof le;
+declare const ops_lgamma: typeof lgamma;
+declare const ops_log: typeof log;
+declare const ops_lt: typeof lt;
+declare const ops_matmul: typeof matmul;
+declare const ops_max: typeof max;
+declare const ops_maximum: typeof maximum;
+declare const ops_mean: typeof mean;
+declare const ops_min: typeof min;
+declare const ops_minimum: typeof minimum;
+declare const ops_mul: typeof mul;
+declare const ops_narrow: typeof narrow;
+declare const ops_ne: typeof ne;
+declare const ops_neg: typeof neg;
+declare const ops_one_hot: typeof one_hot;
+declare const ops_pad: typeof pad;
+declare const ops_permute: typeof permute;
+declare const ops_pool2d: typeof pool2d;
+declare const ops_pow: typeof pow;
+declare const ops_prod: typeof prod;
+declare const ops_remainder: typeof remainder;
+declare const ops_repeat: typeof repeat;
+declare const ops_reshape: typeof reshape;
+declare const ops_roll: typeof roll;
+declare const ops_rsqrt: typeof rsqrt;
+declare const ops_scatter: typeof scatter;
+declare const ops_scatter_add: typeof scatter_add;
+declare const ops_select: typeof select;
+declare const ops_sign: typeof sign;
+declare const ops_sin: typeof sin;
+declare const ops_slice: typeof slice;
+declare const ops_sort: typeof sort;
+declare const ops_split: typeof split;
+declare const ops_sqrt: typeof sqrt;
+declare const ops_squeeze: typeof squeeze;
+declare const ops_stack: typeof stack;
+declare const ops_sub: typeof sub;
+declare const ops_sum: typeof sum;
+declare const ops_tile: typeof tile;
+declare const ops_topk: typeof topk;
+declare const ops_transpose: typeof transpose;
+declare const ops_unsqueeze: typeof unsqueeze;
+declare const ops_where: typeof where;
+declare namespace ops {
+  export { ops__dispatch as _dispatch, ops_abs as abs, ops_add as add, ops_argmax as argmax, ops_argmin as argmin, ops_argsort as argsort, ops_batch_norm as batch_norm, ops_broadcast_in_dim as broadcast_in_dim, ops_cat as cat, ops_ceil as ceil, ops_chunk as chunk, ops_clamp as clamp, ops_clone as clone, ops_contiguous as contiguous, ops_conv2d as conv2d, ops_cos as cos, ops_cumsum as cumsum, ops_div as div, ops_dot as dot, ops_embedding as embedding, ops_eq as eq, ops_erf as erf, ops_erfc as erfc, ops_exp as exp, ops_expand as expand, ops_fill as fill, ops_flip as flip, ops_floor as floor, ops_gamma as gamma, ops_gather as gather, ops_ge as ge, gelu$1 as gelu, ops_gt as gt, ops_index_select as index_select, ops_layer_norm as layer_norm, ops_le as le, ops_lgamma as lgamma, ops_log as log, log_softmax$1 as log_softmax, ops_lt as lt, ops_matmul as matmul, ops_max as max, ops_maximum as maximum, ops_mean as mean, ops_min as min, ops_minimum as minimum, ops_mul as mul, ops_narrow as narrow, ops_ne as ne, ops_neg as neg, ops_one_hot as one_hot, ops_pad as pad, ops_permute as permute, ops_pool2d as pool2d, ops_pow as pow, ops_prod as prod, relu$1 as relu, ops_remainder as remainder, ops_repeat as repeat, ops_reshape as reshape, ops_roll as roll, ops_rsqrt as rsqrt, ops_scatter as scatter, ops_scatter_add as scatter_add, ops_select as select, sigmoid$1 as sigmoid, ops_sign as sign, silu$1 as silu, ops_sin as sin, ops_slice as slice, softmax$1 as softmax, ops_sort as sort, ops_split as split, ops_sqrt as sqrt, ops_squeeze as squeeze, ops_stack as stack, ops_sub as sub, ops_sum as sum, tanh$1 as tanh, ops_tile as tile, ops_topk as topk, ops_transpose as transpose, ops_unsqueeze as unsqueeze, ops_where as where };
+}
+
+type NNTensor = Tensor & {
+    isSymbolic?: boolean;
+    reshape(shape: readonly number[]): NNTensor;
+    transpose(dim0: number, dim1: number): NNTensor;
+    permute(dims: readonly number[]): NNTensor;
+    unsqueeze(dim: number): NNTensor;
+    detach(): NNTensor;
+};
+type OptionalTensor = NNTensor | null;
+type TensorPair = [NNTensor, NNTensor];
+
+declare class Parameter extends Tensor {
+    constructor(data: Tensor | TensorImpl, requiresGrad?: boolean);
+    get isParameter(): true;
+}
+
+type StateDictValue = Tensor | {
+    _impl?: {
+        storage: {
+            data: NumericTypedArray | null;
+        };
+    };
+    data?: NumericTypedArray | null;
+};
+declare class Module {
+    [key: string]: unknown;
+    protected _parameters: Map<string, Parameter | null>;
+    protected _buffers: Map<string, Tensor | null>;
+    protected _modules: Map<string, Module | null>;
+    protected _training: boolean;
+    private _detected?;
+    constructor();
+    forward(..._inputs: unknown[]): unknown;
+    call(...inputs: unknown[]): unknown;
+    registerParameter(name: string, param: Parameter | null): void;
+    registerBuffer(name: string, tensor: Tensor | null): void;
+    registerModule(name: string, module: Module | null): void;
+    parameters(recurse?: boolean): Generator<Parameter>;
+    namedParameters(prefix?: string, recurse?: boolean): Generator<[string, Parameter]>;
+    buffers(recurse?: boolean): Generator<Tensor>;
+    children(): Generator<Module>;
+    namedChildren(): Generator<[string, Module]>;
+    modules(): Generator<Module>;
+    namedModules(prefix?: string): Generator<[string, Module]>;
+    stateDict(prefix?: string): Map<string, Tensor>;
+    loadStateDict(dict: Map<string, StateDictValue>): void;
+    train(mode?: boolean): this;
+    eval(): this;
+    get training(): boolean;
+    to(device: Device | string): this;
+    apply(fn: (module: Module) => void): this;
+    zeroGrad(): this;
+    _autoDetect(): void;
+    toString(): string;
+    _buildRepr(indent: string): string;
+}
+
+type KaimingMode = 'fan_in' | 'fan_out';
+declare function _calculateFanInFanOut(tensor: Tensor): {
+    fanIn: number;
+    fanOut: number;
+};
+declare function resetLinearParameters(weight: Tensor, bias?: Tensor | null): void;
+declare function uniform_<T extends Tensor>(tensor: T, a?: number, b?: number): T;
+declare function normal_<T extends Tensor>(tensor: T, mean?: number, std?: number): T;
+declare function zeros_<T extends Tensor>(tensor: T): T;
+declare function ones_<T extends Tensor>(tensor: T): T;
+declare function constant_<T extends Tensor>(tensor: T, val: number): T;
+declare function xavier_uniform_<T extends Tensor>(tensor: T, gain?: number): T;
+declare function xavier_normal_<T extends Tensor>(tensor: T, gain?: number): T;
+declare function kaiming_uniform_<T extends Tensor>(tensor: T, a?: number, mode?: KaimingMode, nonlinearity?: string): T;
+declare function kaiming_normal_<T extends Tensor>(tensor: T, a?: number, mode?: KaimingMode, nonlinearity?: string): T;
+
+declare const init__calculateFanInFanOut: typeof _calculateFanInFanOut;
+declare const init_constant_: typeof constant_;
+declare const init_kaiming_normal_: typeof kaiming_normal_;
+declare const init_kaiming_uniform_: typeof kaiming_uniform_;
+declare const init_normal_: typeof normal_;
+declare const init_ones_: typeof ones_;
+declare const init_resetLinearParameters: typeof resetLinearParameters;
+declare const init_uniform_: typeof uniform_;
+declare const init_xavier_normal_: typeof xavier_normal_;
+declare const init_xavier_uniform_: typeof xavier_uniform_;
+declare const init_zeros_: typeof zeros_;
+declare namespace init {
+  export { init__calculateFanInFanOut as _calculateFanInFanOut, init_constant_ as constant_, init_kaiming_normal_ as kaiming_normal_, init_kaiming_uniform_ as kaiming_uniform_, init_normal_ as normal_, init_ones_ as ones_, init_resetLinearParameters as resetLinearParameters, init_uniform_ as uniform_, init_xavier_normal_ as xavier_normal_, init_xavier_uniform_ as xavier_uniform_, init_zeros_ as zeros_ };
+}
+
+declare function relu(input: Tensor): Tensor;
+declare function gelu(input: Tensor): Tensor;
+declare function silu(input: Tensor): Tensor;
+declare function sigmoid(input: Tensor): Tensor;
+declare function tanh(input: Tensor): Tensor;
+declare function softmax(input: Tensor, dim?: number): Tensor;
+declare function log_softmax(input: Tensor, dim?: number): Tensor;
+declare function leaky_relu(input: Tensor, negativeSlope?: number): Tensor;
+declare function elu(input: Tensor, alpha?: number): Tensor;
+
+declare const activation_elu: typeof elu;
+declare const activation_gelu: typeof gelu;
+declare const activation_leaky_relu: typeof leaky_relu;
+declare const activation_log_softmax: typeof log_softmax;
+declare const activation_relu: typeof relu;
+declare const activation_sigmoid: typeof sigmoid;
+declare const activation_silu: typeof silu;
+declare const activation_softmax: typeof softmax;
+declare const activation_tanh: typeof tanh;
+declare namespace activation {
+  export { activation_elu as elu, activation_gelu as gelu, activation_leaky_relu as leaky_relu, activation_log_softmax as log_softmax, activation_relu as relu, activation_sigmoid as sigmoid, activation_silu as silu, activation_softmax as softmax, activation_tanh as tanh };
+}
+
+type Pair2$1 = [number, number];
+type PairPadding2d$1 = [Pair2$1, Pair2$1] | Pair2$1;
+type ConvSize2d = number | Pair2$1;
+type ConvPadding2d = number | PairPadding2d$1;
+
+type Pair2 = [number, number];
+type PairPadding2d = [Pair2, Pair2] | Pair2;
+type Pool2dSize = number | Pair2;
+type Pool2dPadding = number | PairPadding2d;
+
+type LossReduction = 'mean' | 'sum' | 'none';
+
+declare class Linear extends Module {
+    inFeatures: number;
+    outFeatures: number;
+    weight: Parameter;
+    bias: Parameter | null;
+    constructor(inFeatures: number, outFeatures: number, bias?: boolean);
+    _resetParameters(): void;
+    forward(input: NNTensor): NNTensor;
+}
+
+type Conv2dOptions = {
+    stride?: ConvSize2d;
+    padding?: ConvPadding2d;
+    dilation?: ConvSize2d;
+    groups?: number;
+    bias?: boolean;
+};
+type Conv1dOptions = {
+    stride?: number | readonly number[];
+    padding?: number | Pair2$1;
+    dilation?: number | readonly number[];
+    groups?: number;
+    bias?: boolean;
+};
+declare class Conv2d extends Module {
+    inChannels: number;
+    outChannels: number;
+    kernelSize: Pair2$1;
+    stride: Pair2$1;
+    padding: ConvPadding2d;
+    dilation: Pair2$1;
+    groups: number;
+    weight: Parameter;
+    bias: Parameter | null;
+    constructor(inChannels: number, outChannels: number, kernelSize: ConvSize2d, opts?: Conv2dOptions);
+    _resetParameters(): void;
+    forward(input: Tensor): Tensor;
+}
+declare class Conv1d extends Module {
+    inChannels: number;
+    outChannels: number;
+    kernelSize: number;
+    stride: number | readonly number[];
+    padding: number | Pair2$1;
+    dilation: number | readonly number[];
+    groups: number;
+    weight: Parameter;
+    bias: Parameter | null;
+    constructor(inChannels: number, outChannels: number, kernelSize: number | readonly number[], opts?: Conv1dOptions);
+    forward(input: Tensor): Tensor;
+}
+
+declare class ReLU extends Module {
+    forward(input: Tensor): Tensor;
+}
+declare class GELU extends Module {
+    forward(input: Tensor): Tensor;
+}
+declare class SiLU extends Module {
+    forward(input: Tensor): Tensor;
+}
+declare class Sigmoid extends Module {
+    forward(input: Tensor): Tensor;
+}
+declare class Tanh extends Module {
+    forward(input: Tensor): Tensor;
+}
+declare class LeakyReLU extends Module {
+    negativeSlope: number;
+    constructor(negativeSlope?: number);
+    forward(input: Tensor): Tensor;
+}
+declare class ELU extends Module {
+    alpha: number;
+    constructor(alpha?: number);
+    forward(input: Tensor): Tensor;
+}
+declare class Softmax extends Module {
+    dim: number;
+    constructor(dim?: number);
+    forward(input: Tensor): Tensor;
+}
+declare class LogSoftmax extends Module {
+    dim: number;
+    constructor(dim?: number);
+    forward(input: Tensor): Tensor;
+}
+
+declare class LayerNorm extends Module {
+    normalizedShape: number[];
+    eps: number;
+    weight: Parameter | null;
+    bias: Parameter | null;
+    constructor(normalizedShape: number | readonly number[], eps?: number, elementwiseAffine?: boolean);
+    forward(input: NNTensor): NNTensor;
+}
+declare class GroupNorm extends Module {
+    numGroups: number;
+    numChannels: number;
+    eps: number;
+    weight: Parameter | null;
+    bias: Parameter | null;
+    constructor(numGroups: number, numChannels: number, eps?: number, affine?: boolean);
+    forward(input: NNTensor): NNTensor;
+}
+declare class BatchNorm1d extends Module {
+    numFeatures: number;
+    eps: number;
+    weight: Parameter | null;
+    bias: Parameter | null;
+    runningMean: NNTensor;
+    runningVar: NNTensor;
+    constructor(numFeatures: number, eps?: number, affine?: boolean);
+    forward(input: NNTensor): NNTensor;
+}
+declare class BatchNorm2d extends BatchNorm1d {
+    constructor(numFeatures: number, eps?: number, affine?: boolean);
+}
+
+declare class MaxPool2d extends Module {
+    kernelSize: Pair2;
+    stride: Pair2;
+    padding: Pool2dPadding;
+    constructor(kernelSize: Pool2dSize, stride?: Pool2dSize | null, padding?: Pool2dPadding);
+    forward(input: Tensor): Tensor;
+}
+declare class AvgPool2d extends Module {
+    kernelSize: Pair2;
+    stride: Pair2;
+    padding: Pool2dPadding;
+    constructor(kernelSize: Pool2dSize, stride?: Pool2dSize | null, padding?: Pool2dPadding);
+    forward(input: Tensor): Tensor;
+}
+declare class AdaptiveAvgPool2d extends Module {
+    outputSize: Pair2;
+    constructor(outputSize: Pool2dSize);
+    forward(input: Tensor): Tensor;
+}
+
+declare class Dropout extends Module {
+    p: number;
+    constructor(p?: number);
+    forward(input: Tensor): Tensor;
+}
+
+declare class MSELoss extends Module {
+    reduction: LossReduction;
+    constructor(reduction?: LossReduction);
+    forward(input: Tensor, target: Tensor): Tensor;
+}
+declare class CrossEntropyLoss extends Module {
+    reduction: LossReduction;
+    ignoreIndex: number;
+    constructor(reduction?: LossReduction, ignoreIndex?: number);
+    forward(input: Tensor, target: Tensor): Tensor;
+}
+declare class NLLLoss extends Module {
+    reduction: LossReduction;
+    ignoreIndex: number;
+    constructor(reduction?: LossReduction, ignoreIndex?: number);
+    forward(input: Tensor, target: Tensor): Tensor;
+}
+declare class BCELoss extends Module {
+    reduction: LossReduction;
+    constructor(reduction?: LossReduction);
+    forward(input: Tensor, target: Tensor): Tensor;
+}
+
+declare class Embedding extends Module {
+    numEmbeddings: number;
+    embeddingDim: number;
+    weight: Parameter;
+    constructor(numEmbeddings: number, embeddingDim: number);
+    forward(indices: Tensor): Tensor;
+}
+
+declare class GRUCell extends Module {
+    inputSize: number;
+    hiddenSize: number;
+    x2h: Linear;
+    h2h: Linear;
+    constructor(inputSize: number, hiddenSize: number, bias?: boolean);
+    forward(input: NNTensor, hidden?: NNTensor | null): NNTensor;
+}
+declare class GRU extends Module {
+    inputSize: number;
+    hiddenSize: number;
+    numLayers: number;
+    batchFirst: boolean;
+    cells: GRUCell[];
+    constructor(inputSize: number, hiddenSize: number, numLayers?: number, batchFirst?: boolean, bias?: boolean);
+    forward(input: NNTensor, h0?: NNTensor | null): [NNTensor, NNTensor];
+}
+
+declare class LSTMCell extends Module {
+    inputSize: number;
+    hiddenSize: number;
+    x2h: Linear;
+    h2h: Linear;
+    constructor(inputSize: number, hiddenSize: number, bias?: boolean);
+    forward(input: NNTensor, state?: TensorPair | null): TensorPair;
+}
+declare class LSTM extends Module {
+    inputSize: number;
+    hiddenSize: number;
+    numLayers: number;
+    batchFirst: boolean;
+    cells: LSTMCell[];
+    constructor(inputSize: number, hiddenSize: number, numLayers?: number, batchFirst?: boolean, bias?: boolean);
+    forward(input: NNTensor, state?: TensorPair | null): [NNTensor, TensorPair];
+}
+
+declare class Sequential extends Module {
+    private _length;
+    constructor(...modules: Module[]);
+    forward(input: unknown): unknown;
+    get length(): number;
+    [Symbol.iterator](): Generator<Module>;
+    push(module: Module): this;
+}
+declare class ModuleList extends Module {
+    private _list;
+    constructor(modules?: Module[]);
+    get length(): number;
+    get(i: number): Module | undefined;
+    push(module: Module): this;
+    [Symbol.iterator](): Generator<Module>;
+    forward(): never;
+}
+declare class ModuleDict extends Module {
+    private _dict;
+    constructor(modules?: Record<string, Module>);
+    get(key: string): Module | undefined;
+    set(key: string, module: Module): this;
+    has(key: string): boolean;
+    get size(): number;
+    keys(): Generator<string>;
+    values(): Generator<Module>;
+    [Symbol.iterator](): Generator<[string, Module]>;
+    forward(): never;
+}
+
+declare class Flatten extends Module {
+    startDim: number;
+    endDim: number;
+    constructor(startDim?: number, endDim?: number);
+    forward(input: Tensor): Tensor;
+}
+
+type ActivationName = 'relu' | 'gelu' | string;
+type ActivationFn = (input: NNTensor) => NNTensor;
+declare class MultiheadAttention extends Module {
+    embedDim: number;
+    numHeads: number;
+    headDim: number;
+    batchFirst: boolean;
+    dropout: number;
+    qProj: Linear;
+    kProj: Linear;
+    vProj: Linear;
+    outProj: Linear;
+    constructor(embedDim: number, numHeads: number, dropout?: number, bias?: boolean, kdim?: number | null, vdim?: number | null, batchFirst?: boolean);
+    forward(query: NNTensor, key: NNTensor, value: NNTensor, attnMask?: OptionalTensor, keyPaddingMask?: OptionalTensor, isCausal?: boolean): NNTensor;
+}
+declare class TransformerEncoderLayer extends Module {
+    selfAttn: MultiheadAttention;
+    linear1: Linear;
+    linear2: Linear;
+    norm1: LayerNorm;
+    norm2: LayerNorm;
+    dropout1: Dropout;
+    dropout2: Dropout;
+    dropoutFFN: Dropout;
+    _activation: ActivationFn;
+    _activationName: ActivationName;
+    normFirst: boolean;
+    _dModel: number;
+    _nhead: number;
+    _dimFeedforward: number;
+    _dropout: number;
+    _layerNormEps: number;
+    _batchFirst: boolean;
+    constructor(dModel: number, nhead: number, dimFeedforward?: number, dropout?: number, activation?: ActivationName, layerNormEps?: number, batchFirst?: boolean, normFirst?: boolean);
+    forward(src: NNTensor, srcMask?: OptionalTensor, srcKeyPaddingMask?: OptionalTensor, isCausal?: boolean): NNTensor;
+    _forwardPostNorm(src: NNTensor, srcMask: OptionalTensor, srcKeyPaddingMask: OptionalTensor, isCausal: boolean): NNTensor;
+    _forwardPreNorm(src: NNTensor, srcMask: OptionalTensor, srcKeyPaddingMask: OptionalTensor, isCausal: boolean): NNTensor;
+}
+declare class TransformerDecoderLayer extends Module {
+    selfAttn: MultiheadAttention;
+    crossAttn: MultiheadAttention;
+    linear1: Linear;
+    linear2: Linear;
+    norm1: LayerNorm;
+    norm2: LayerNorm;
+    norm3: LayerNorm;
+    dropout1: Dropout;
+    dropout2: Dropout;
+    dropout3: Dropout;
+    dropoutFFN: Dropout;
+    _activation: ActivationFn;
+    _activationName: ActivationName;
+    normFirst: boolean;
+    _dModel: number;
+    _nhead: number;
+    _dimFeedforward: number;
+    _dropout: number;
+    _layerNormEps: number;
+    _batchFirst: boolean;
+    constructor(dModel: number, nhead: number, dimFeedforward?: number, dropout?: number, activation?: ActivationName, layerNormEps?: number, batchFirst?: boolean, normFirst?: boolean);
+    forward(tgt: NNTensor, memory: NNTensor, tgtMask?: OptionalTensor, memoryMask?: OptionalTensor, tgtKeyPaddingMask?: OptionalTensor, memoryKeyPaddingMask?: OptionalTensor, isCausal?: boolean): NNTensor;
+    _forwardPostNorm(tgt: NNTensor, memory: NNTensor, tgtMask: OptionalTensor, memoryMask: OptionalTensor, tgtKeyPaddingMask: OptionalTensor, memoryKeyPaddingMask: OptionalTensor, isCausal: boolean): NNTensor;
+    _forwardPreNorm(tgt: NNTensor, memory: NNTensor, tgtMask: OptionalTensor, memoryMask: OptionalTensor, tgtKeyPaddingMask: OptionalTensor, memoryKeyPaddingMask: OptionalTensor, isCausal: boolean): NNTensor;
+}
+declare class TransformerEncoder extends Module {
+    layers: ModuleList;
+    norm: LayerNorm | null;
+    constructor(encoderLayer: TransformerEncoderLayer, numLayers: number, norm?: LayerNorm | null);
+    forward(src: NNTensor, mask?: OptionalTensor, srcKeyPaddingMask?: OptionalTensor, isCausal?: boolean): NNTensor;
+}
+declare class TransformerDecoder extends Module {
+    layers: ModuleList;
+    norm: LayerNorm | null;
+    constructor(decoderLayer: TransformerDecoderLayer, numLayers: number, norm?: LayerNorm | null);
+    forward(tgt: NNTensor, memory: NNTensor, tgtMask?: OptionalTensor, memoryMask?: OptionalTensor, tgtKeyPaddingMask?: OptionalTensor, memoryKeyPaddingMask?: OptionalTensor, isCausal?: boolean): NNTensor;
+}
+declare class Transformer extends Module {
+    encoder: TransformerEncoder;
+    decoder: TransformerDecoder;
+    dModel: number;
+    constructor({ dModel, nhead, numEncoderLayers, numDecoderLayers, dimFeedforward, dropout, activation, batchFirst, normFirst, layerNormEps, }?: {
+        dModel?: number;
+        nhead?: number;
+        numEncoderLayers?: number;
+        numDecoderLayers?: number;
+        dimFeedforward?: number;
+        dropout?: number;
+        activation?: ActivationName;
+        batchFirst?: boolean;
+        normFirst?: boolean;
+        layerNormEps?: number;
+    });
+    forward(src: NNTensor, tgt: NNTensor, srcMask?: OptionalTensor, tgtMask?: OptionalTensor, memoryMask?: OptionalTensor, srcKeyPaddingMask?: OptionalTensor, tgtKeyPaddingMask?: OptionalTensor, memoryKeyPaddingMask?: OptionalTensor): NNTensor;
+    static generateSquareSubsequentMask(sz: number): NNTensor;
+}
+
+declare class PositionalEncoding extends Module {
+    dropoutLayer: Dropout;
+    pe: Tensor;
+    constructor(dModel: number, maxLen?: number, dropout?: number);
+    forward(x: Tensor): Tensor;
+}
+
+declare const F: {
+    scaled_dot_product_attention(query: NNTensor, key: NNTensor, value: NNTensor, attnMask?: OptionalTensor, dropoutP?: number, isCausal?: boolean, training?: boolean): NNTensor;
+    embedding(weight: Tensor, indices: Tensor): Tensor;
+    mse_loss(input: Tensor, target: Tensor, reduction?: LossReduction): Tensor;
+    nll_loss(input: Tensor, target: Tensor, reduction?: LossReduction, ignoreIndex?: number | null): Tensor;
+    cross_entropy(input: Tensor, target: Tensor, reduction?: LossReduction, ignoreIndex?: number | null): Tensor;
+    binary_cross_entropy(input: Tensor, target: Tensor, reduction?: LossReduction): Tensor;
+    dropout(input: Tensor, p?: number, training?: boolean): Tensor;
+    max_pool2d(input: Tensor, kernelSize: Pool2dSize, stride?: Pool2dSize | null, padding?: Pool2dPadding): Tensor;
+    avg_pool2d(input: Tensor, kernelSize: Pool2dSize, stride?: Pool2dSize | null, padding?: Pool2dPadding): Tensor;
+    adaptive_avg_pool2d(input: Tensor, outputSize: Pool2dSize): Tensor;
+    conv2d(input: Tensor, weight: Tensor, bias: Tensor | null, stride?: ConvSize2d, padding?: ConvPadding2d, dilation?: ConvSize2d, groups?: number): Tensor;
+    conv1d(input: Tensor, weight: Tensor, bias: Tensor | null, stride?: number | readonly number[], padding?: number | Pair2$1, dilation?: number | readonly number[], groups?: number): Tensor;
+    linear(input: NNTensor, weight: NNTensor, bias?: OptionalTensor): NNTensor;
+    layer_norm(input: NNTensor, normalizedShape: readonly number[], weight: OptionalTensor, bias: OptionalTensor, eps?: number): NNTensor;
+    group_norm(input: NNTensor, numGroups: number, weight: OptionalTensor, bias: OptionalTensor, eps?: number): NNTensor;
+    batch_norm(input: NNTensor, runningMean: OptionalTensor, runningVar: OptionalTensor, weight: OptionalTensor, bias: OptionalTensor, training?: boolean, eps?: number, momentum?: number): NNTensor;
+    relu(input: Tensor): Tensor;
+    gelu(input: Tensor): Tensor;
+    silu(input: Tensor): Tensor;
+    sigmoid(input: Tensor): Tensor;
+    tanh(input: Tensor): Tensor;
+    softmax(input: Tensor, dim?: number): Tensor;
+    log_softmax(input: Tensor, dim?: number): Tensor;
+    leaky_relu(input: Tensor, negativeSlope?: number): Tensor;
+    elu(input: Tensor, alpha?: number): Tensor;
+};
+
+type index$6_AdaptiveAvgPool2d = AdaptiveAvgPool2d;
+declare const index$6_AdaptiveAvgPool2d: typeof AdaptiveAvgPool2d;
+type index$6_AvgPool2d = AvgPool2d;
+declare const index$6_AvgPool2d: typeof AvgPool2d;
+type index$6_BCELoss = BCELoss;
+declare const index$6_BCELoss: typeof BCELoss;
+type index$6_BatchNorm1d = BatchNorm1d;
+declare const index$6_BatchNorm1d: typeof BatchNorm1d;
+type index$6_BatchNorm2d = BatchNorm2d;
+declare const index$6_BatchNorm2d: typeof BatchNorm2d;
+type index$6_Conv1d = Conv1d;
+declare const index$6_Conv1d: typeof Conv1d;
+type index$6_Conv2d = Conv2d;
+declare const index$6_Conv2d: typeof Conv2d;
+type index$6_CrossEntropyLoss = CrossEntropyLoss;
+declare const index$6_CrossEntropyLoss: typeof CrossEntropyLoss;
+type index$6_Dropout = Dropout;
+declare const index$6_Dropout: typeof Dropout;
+type index$6_ELU = ELU;
+declare const index$6_ELU: typeof ELU;
+type index$6_Embedding = Embedding;
+declare const index$6_Embedding: typeof Embedding;
+declare const index$6_F: typeof F;
+type index$6_Flatten = Flatten;
+declare const index$6_Flatten: typeof Flatten;
+type index$6_GELU = GELU;
+declare const index$6_GELU: typeof GELU;
+type index$6_GRU = GRU;
+declare const index$6_GRU: typeof GRU;
+type index$6_GRUCell = GRUCell;
+declare const index$6_GRUCell: typeof GRUCell;
+type index$6_GroupNorm = GroupNorm;
+declare const index$6_GroupNorm: typeof GroupNorm;
+type index$6_LSTM = LSTM;
+declare const index$6_LSTM: typeof LSTM;
+type index$6_LSTMCell = LSTMCell;
+declare const index$6_LSTMCell: typeof LSTMCell;
+type index$6_LayerNorm = LayerNorm;
+declare const index$6_LayerNorm: typeof LayerNorm;
+type index$6_LeakyReLU = LeakyReLU;
+declare const index$6_LeakyReLU: typeof LeakyReLU;
+type index$6_Linear = Linear;
+declare const index$6_Linear: typeof Linear;
+type index$6_LogSoftmax = LogSoftmax;
+declare const index$6_LogSoftmax: typeof LogSoftmax;
+type index$6_MSELoss = MSELoss;
+declare const index$6_MSELoss: typeof MSELoss;
+type index$6_MaxPool2d = MaxPool2d;
+declare const index$6_MaxPool2d: typeof MaxPool2d;
+type index$6_Module = Module;
+declare const index$6_Module: typeof Module;
+type index$6_ModuleDict = ModuleDict;
+declare const index$6_ModuleDict: typeof ModuleDict;
+type index$6_ModuleList = ModuleList;
+declare const index$6_ModuleList: typeof ModuleList;
+type index$6_MultiheadAttention = MultiheadAttention;
+declare const index$6_MultiheadAttention: typeof MultiheadAttention;
+type index$6_NLLLoss = NLLLoss;
+declare const index$6_NLLLoss: typeof NLLLoss;
+type index$6_Parameter = Parameter;
+declare const index$6_Parameter: typeof Parameter;
+type index$6_PositionalEncoding = PositionalEncoding;
+declare const index$6_PositionalEncoding: typeof PositionalEncoding;
+type index$6_ReLU = ReLU;
+declare const index$6_ReLU: typeof ReLU;
+type index$6_Sequential = Sequential;
+declare const index$6_Sequential: typeof Sequential;
+type index$6_SiLU = SiLU;
+declare const index$6_SiLU: typeof SiLU;
+type index$6_Sigmoid = Sigmoid;
+declare const index$6_Sigmoid: typeof Sigmoid;
+type index$6_Softmax = Softmax;
+declare const index$6_Softmax: typeof Softmax;
+type index$6_Tanh = Tanh;
+declare const index$6_Tanh: typeof Tanh;
+type index$6_Transformer = Transformer;
+declare const index$6_Transformer: typeof Transformer;
+type index$6_TransformerDecoder = TransformerDecoder;
+declare const index$6_TransformerDecoder: typeof TransformerDecoder;
+type index$6_TransformerDecoderLayer = TransformerDecoderLayer;
+declare const index$6_TransformerDecoderLayer: typeof TransformerDecoderLayer;
+type index$6_TransformerEncoder = TransformerEncoder;
+declare const index$6_TransformerEncoder: typeof TransformerEncoder;
+type index$6_TransformerEncoderLayer = TransformerEncoderLayer;
+declare const index$6_TransformerEncoderLayer: typeof TransformerEncoderLayer;
+declare const index$6_init: typeof init;
+declare namespace index$6 {
+  export { index$6_AdaptiveAvgPool2d as AdaptiveAvgPool2d, index$6_AvgPool2d as AvgPool2d, index$6_BCELoss as BCELoss, index$6_BatchNorm1d as BatchNorm1d, index$6_BatchNorm2d as BatchNorm2d, index$6_Conv1d as Conv1d, index$6_Conv2d as Conv2d, index$6_CrossEntropyLoss as CrossEntropyLoss, index$6_Dropout as Dropout, index$6_ELU as ELU, index$6_Embedding as Embedding, index$6_F as F, index$6_Flatten as Flatten, index$6_GELU as GELU, index$6_GRU as GRU, index$6_GRUCell as GRUCell, index$6_GroupNorm as GroupNorm, index$6_LSTM as LSTM, index$6_LSTMCell as LSTMCell, index$6_LayerNorm as LayerNorm, index$6_LeakyReLU as LeakyReLU, index$6_Linear as Linear, index$6_LogSoftmax as LogSoftmax, index$6_MSELoss as MSELoss, index$6_MaxPool2d as MaxPool2d, index$6_Module as Module, index$6_ModuleDict as ModuleDict, index$6_ModuleList as ModuleList, index$6_MultiheadAttention as MultiheadAttention, index$6_NLLLoss as NLLLoss, index$6_Parameter as Parameter, index$6_PositionalEncoding as PositionalEncoding, index$6_ReLU as ReLU, index$6_Sequential as Sequential, index$6_SiLU as SiLU, index$6_Sigmoid as Sigmoid, index$6_Softmax as Softmax, index$6_Tanh as Tanh, index$6_Transformer as Transformer, index$6_TransformerDecoder as TransformerDecoder, index$6_TransformerDecoderLayer as TransformerDecoderLayer, index$6_TransformerEncoder as TransformerEncoder, index$6_TransformerEncoderLayer as TransformerEncoderLayer, activation as functional, index$6_init as init };
+}
+
+declare class Dataset<T = unknown> implements Iterable<T> {
+    get length(): number;
+    get(index: number): T;
+    [Symbol.iterator](): Generator<T>;
+}
+declare class TensorDataset extends Dataset<Tensor[]> {
+    private readonly _tensors;
+    private readonly _length;
+    constructor(...tensors: Tensor[]);
+    get length(): number;
+    get(index: number): Tensor[];
+}
+declare class MapDataset<TIn, TOut> extends Dataset<TOut> {
+    private readonly _dataset;
+    private readonly _transform;
+    constructor(dataset: Dataset<TIn>, transform: (sample: TIn) => TOut);
+    get length(): number;
+    get(index: number): TOut;
+}
+
+type Sized = {
+    length: number;
+};
+declare class Sampler implements Iterable<number | number[]> {
+    [Symbol.iterator](): Generator<number | number[]>;
+}
+declare class SequentialSampler extends Sampler implements Iterable<number> {
+    private readonly _dataSource;
+    constructor(dataSource: Sized);
+    [Symbol.iterator](): Generator<number>;
+}
+declare class RandomSampler extends Sampler implements Iterable<number> {
+    private readonly _dataSource;
+    constructor(dataSource: Sized);
+    [Symbol.iterator](): Generator<number>;
+}
+declare class BatchSampler extends Sampler implements Iterable<number[]> {
+    readonly _dropLast: boolean;
+    private readonly _sampler;
+    private readonly _batchSize;
+    constructor(sampler: Iterable<number>, batchSize: number, dropLast?: boolean);
+    [Symbol.iterator](): Generator<number[]>;
+}
+
+declare function defaultCollate(batch: readonly unknown[]): unknown;
+
+type CollateFn<T, TBatch> = (samples: T[]) => TBatch;
+type DataLoaderOptions<T, TBatch> = {
+    batchSize?: number | null;
+    shuffle?: boolean;
+    sampler?: Iterable<number> | null;
+    batchSampler?: Iterable<number[]> | null;
+    dropLast?: boolean;
+    collate?: CollateFn<T, TBatch>;
+};
+declare class DataLoader<T = unknown, TBatch = unknown> implements Iterable<TBatch> {
+    private readonly _dataset;
+    private readonly _collate;
+    private readonly _batchSampler;
+    private readonly _batchSize;
+    private readonly _dropLast;
+    constructor(dataset: Dataset<T>, opts?: DataLoaderOptions<T, TBatch>);
+    get dataset(): Dataset<T>;
+    get length(): number;
+    [Symbol.iterator](): Generator<TBatch>;
+}
+
+type index$5_BatchSampler = BatchSampler;
+declare const index$5_BatchSampler: typeof BatchSampler;
+type index$5_DataLoader<T = unknown, TBatch = unknown> = DataLoader<T, TBatch>;
+declare const index$5_DataLoader: typeof DataLoader;
+type index$5_Dataset<T = unknown> = Dataset<T>;
+declare const index$5_Dataset: typeof Dataset;
+type index$5_MapDataset<TIn, TOut> = MapDataset<TIn, TOut>;
+declare const index$5_MapDataset: typeof MapDataset;
+type index$5_RandomSampler = RandomSampler;
+declare const index$5_RandomSampler: typeof RandomSampler;
+type index$5_Sampler = Sampler;
+declare const index$5_Sampler: typeof Sampler;
+type index$5_SequentialSampler = SequentialSampler;
+declare const index$5_SequentialSampler: typeof SequentialSampler;
+type index$5_TensorDataset = TensorDataset;
+declare const index$5_TensorDataset: typeof TensorDataset;
+declare const index$5_defaultCollate: typeof defaultCollate;
+declare namespace index$5 {
+  export { index$5_BatchSampler as BatchSampler, index$5_DataLoader as DataLoader, index$5_Dataset as Dataset, index$5_MapDataset as MapDataset, index$5_RandomSampler as RandomSampler, index$5_Sampler as Sampler, index$5_SequentialSampler as SequentialSampler, index$5_TensorDataset as TensorDataset, index$5_defaultCollate as defaultCollate };
+}
+
+declare class Vocab {
+    private readonly _tokenToId;
+    private readonly _idToToken;
+    constructor(specials?: readonly string[]);
+    add(token: string): number;
+    getId(token: string, fallback?: number): number;
+    getToken(id: number): string | undefined;
+    has(token: string): boolean;
+    get size(): number;
+    tokens(): string[];
+    static fromTokens(tokens: unknown): Vocab;
+}
+
+declare const TOKENIZER_FORMAT = "mlfw-tokenizer";
+declare const TOKENIZER_VERSION = 1;
+declare const DEFAULT_SPECIALS: Readonly<{
+    pad: "<pad>";
+    unk: "<unk>";
+    bos: "<bos>";
+    eos: "<eos>";
+}>;
+type TokenizerMode = 'word' | 'char' | 'bpe';
+type SpecialKey = 'pad' | 'unk' | 'bos' | 'eos';
+type SpecialTokens = Record<SpecialKey, string>;
+type PartialSpecialTokens = Partial<SpecialTokens> | readonly string[];
+type StrategyData = {
+    lowercase?: boolean;
+    numMerges?: number;
+    endOfWord?: string;
+    merges?: [string, string][];
+};
+type TokenizerOptions = {
+    mode?: TokenizerMode;
+    specialTokens?: PartialSpecialTokens;
+    vocabSize?: number | null;
+    lowercase?: boolean;
+    numMerges?: number;
+    endOfWord?: string;
+};
+type EncodeOptions = {
+    addBos?: boolean;
+    addEos?: boolean;
+};
+type DecodeOptions = {
+    skipSpecial?: boolean;
+};
+type EncodeBatchOptions = EncodeOptions & {
+    maxLen?: number;
+    padId?: number;
+};
+type TokenizerJSON = {
+    format: typeof TOKENIZER_FORMAT;
+    version: typeof TOKENIZER_VERSION;
+    mode: TokenizerMode;
+    config: StrategyData & {
+        vocabSize: number | null;
+    };
+    specialTokens: SpecialTokens;
+    vocab: string[];
+    strategy: StrategyData;
+};
+declare class Tokenizer {
+    private _mode;
+    private _specials;
+    private _maxVocab;
+    private _strategy;
+    private _vocab;
+    constructor(options?: TokenizerOptions);
+    get mode(): TokenizerMode;
+    get vocabSize(): number;
+    get padId(): number;
+    get unkId(): number;
+    get bosId(): number;
+    get eosId(): number;
+    _ensureFit(): void;
+    _fitVocab(): Vocab;
+    _specialId(name: SpecialKey): number;
+    fit(texts: string | readonly string[]): this;
+    toJSON(): TokenizerJSON;
+    save(path: string): void;
+    static load(path: string): Tokenizer;
+    static fromJSON(data: unknown): Tokenizer;
+    encode(text: string, options?: EncodeOptions): number[];
+    decode(ids: Iterable<number>, options?: DecodeOptions): string;
+    encodeBatch(texts: string | readonly string[], options?: EncodeBatchOptions): Tensor;
+}
+
+declare const index$4_DEFAULT_SPECIALS: typeof DEFAULT_SPECIALS;
+declare const index$4_TOKENIZER_FORMAT: typeof TOKENIZER_FORMAT;
+declare const index$4_TOKENIZER_VERSION: typeof TOKENIZER_VERSION;
+type index$4_Tokenizer = Tokenizer;
+declare const index$4_Tokenizer: typeof Tokenizer;
+type index$4_Vocab = Vocab;
+declare const index$4_Vocab: typeof Vocab;
+declare namespace index$4 {
+  export { index$4_DEFAULT_SPECIALS as DEFAULT_SPECIALS, index$4_TOKENIZER_FORMAT as TOKENIZER_FORMAT, index$4_TOKENIZER_VERSION as TOKENIZER_VERSION, index$4_Tokenizer as Tokenizer, index$4_Vocab as Vocab };
+}
+
+type OptimizerParam = Tensor;
+type OptimizerStateValue = number | boolean | string | readonly number[] | NumericTypedArray | undefined;
+type OptimizerState = Record<string, OptimizerStateValue>;
+type OptimizerParamGroup = {
+    params: OptimizerParam[];
+    [key: string]: OptimizerStateValue | OptimizerParam[];
+};
+type ParamGroupInput = {
+    params: Iterable<OptimizerParam> | OptimizerParam[];
+    [key: string]: OptimizerStateValue | Iterable<OptimizerParam> | OptimizerParam[];
+};
+type OptimizerParams = Iterable<OptimizerParam> | OptimizerParam[] | ParamGroupInput[];
+type OptimizerStateDict = {
+    state: Map<number, OptimizerState>;
+    paramGroups: Array<Record<string, OptimizerStateValue>>;
+};
+
+declare class Optimizer {
+    protected _defaults: Record<string, unknown>;
+    protected _paramGroups: OptimizerParamGroup[];
+    protected _state: Map<number, OptimizerState>;
+    private readonly _paramIndex;
+    private _nextId;
+    constructor(params: OptimizerParams, defaults: Record<string, unknown>);
+    get paramGroups(): OptimizerParamGroup[];
+    get defaults(): Record<string, unknown>;
+    step(): void;
+    zeroGrad(setToNone?: boolean): void;
+    stateDict(): OptimizerStateDict;
+    loadStateDict(dict: OptimizerStateDict): void;
+    _addParamGroup(group: ParamGroupInput): void;
+    _getParamId(param: OptimizerParam): number | undefined;
+    _getState(param: OptimizerParam): OptimizerState;
+}
+
+declare class SGD extends Optimizer {
+    constructor(params: ConstructorParameters<typeof Optimizer>[0], { lr, momentum, dampening, weightDecay, nesterov }?: {
+        lr?: number | undefined;
+        momentum?: number | undefined;
+        dampening?: number | undefined;
+        weightDecay?: number | undefined;
+        nesterov?: boolean | undefined;
+    });
+    step(): void;
+}
+
+declare class Adam extends Optimizer {
+    constructor(params: ConstructorParameters<typeof Optimizer>[0], { lr, betas, eps, weightDecay, amsgrad }?: {
+        lr?: number | undefined;
+        betas?: number[] | undefined;
+        eps?: number | undefined;
+        weightDecay?: number | undefined;
+        amsgrad?: boolean | undefined;
+    });
+    step(): void;
+}
+
+declare class AdamW extends Optimizer {
+    constructor(params: ConstructorParameters<typeof Optimizer>[0], { lr, betas, eps, weightDecay, amsgrad }?: {
+        lr?: number | undefined;
+        betas?: number[] | undefined;
+        eps?: number | undefined;
+        weightDecay?: number | undefined;
+        amsgrad?: boolean | undefined;
+    });
+    step(): void;
+}
+
+declare class LRScheduler {
+    protected readonly _optimizer: Optimizer;
+    protected readonly _baseLRs: number[];
+    protected _lastEpoch: number;
+    protected _lastLR: number[] | null;
+    constructor(optimizer: Optimizer, lastEpoch?: number);
+    _init(): void;
+    getLR(): number[];
+    getLastLR(): number[] | null;
+    step(): void;
+}
+declare class StepLR extends LRScheduler {
+    private readonly _stepSize;
+    private readonly _gamma;
+    constructor(optimizer: Optimizer, stepSize: number, gamma?: number, lastEpoch?: number);
+    getLR(): number[];
+}
+declare class CosineAnnealingLR extends LRScheduler {
+    private readonly _tMax;
+    private readonly _etaMin;
+    constructor(optimizer: Optimizer, tMax: number, etaMin?: number, lastEpoch?: number);
+    getLR(): number[];
+}
+declare class ReduceLROnPlateau {
+    private readonly _optimizer;
+    private readonly _mode;
+    private readonly _factor;
+    private readonly _patience;
+    private readonly _threshold;
+    private readonly _thresholdMode;
+    private readonly _cooldown;
+    private readonly _minLR;
+    private readonly _eps;
+    private _best;
+    private _numBadEpochs;
+    private _cooldownCounter;
+    constructor(optimizer: Optimizer, { mode, factor, patience, threshold, thresholdMode, cooldown, minLR, eps, }?: {
+        mode?: string;
+        factor?: number;
+        patience?: number;
+        threshold?: number;
+        thresholdMode?: string;
+        cooldown?: number;
+        minLR?: number;
+        eps?: number;
+    });
+    step(metric?: number): void;
+    _isBetter(current: number): boolean;
+    _reduceAllLRs(): void;
+}
+
+declare function clipGradNorm_(parameters: Iterable<Tensor> | Tensor[], maxNorm: number, normType?: number): number;
+declare function clipGradValue_(parameters: Iterable<Tensor> | Tensor[], clipValue: number): void;
+
+declare class TargetFeatures {
+    constructor(config: any);
+    kind: any;
+    name: any;
+    vectorWidth: any;
+    numCores: any;
+    maxThreadsPerBlock: any;
+    maxBlockDimX: any;
+    maxBlockDimY: any;
+    maxBlockDimZ: any;
+    maxGridDimX: any;
+    maxGridDimY: any;
+    maxGridDimZ: any;
+    sharedMemoryBytes: any;
+    memoryBudgetBytes: any;
+    registersPerThread: any;
+    warpSize: any;
+    memoryBandwidthGBs: any;
+    computeTFLOPs: any;
+    cacheLineSizeBytes: any;
+    l1CacheBytes: any;
+    l2CacheBytes: any;
+    supportsFloat16: any;
+    supportsTensorCore: any;
+    libraryOps: any;
+    enableEpilogueFusion: any;
+    preferredConvLayout: any;
+    layoutAwareOps: any;
+    preferredBlockFactor: any;
+    supportsBlockedLayout: any;
+    supportsInt8: any;
+    simd: any;
+    host: any;
+    attrs: Map<string, any>;
+    getAttr(key: any, fallback?: null): any;
+    hasAttr(key: any): boolean;
+    withAttr(key: any, value: any): this;
+    isGPU(): boolean;
+    isWebGPU(): boolean;
+    isCPU(): boolean;
+    isWasm(): boolean;
+    supportsThreadBinding(): boolean;
+    supportsVectorization(): boolean;
+    maxParallelism(): any;
+    supportsSimd(): any;
+    hasLibraryOp(opName: any): any;
+}
+declare function CPUTarget(overrides?: {}): TargetFeatures;
+declare function CUDATarget(overrides?: {}): TargetFeatures;
+declare function WasmTarget(overrides?: {}): TargetFeatures;
+declare function WebGPUTarget(overrides?: {}): TargetFeatures;
+
+type CompiledKernel = {
+    run(name: string, ...args: unknown[]): void;
+};
+type TargetLike = ReturnType<typeof CPUTarget>;
+type GraphFunctionLike = unknown;
+type FusedDefaults = Record<string, unknown>;
+type FusedSGDOptions = {
+    lr?: number;
+    momentum?: number;
+    dampening?: number;
+    weightDecay?: number;
+    nesterov?: boolean;
+};
+type FusedAdamOptions = {
+    lr?: number;
+    betas?: readonly [number, number];
+    eps?: number;
+    weightDecay?: number;
+    amsgrad?: boolean;
+};
+declare class FusedOptimizer extends Optimizer {
+    protected _target: TargetLike;
+    private _kernels;
+    constructor(params: OptimizerParams, defaults: FusedDefaults, target?: TargetLike | null);
+    _kernel(numel: number): CompiledKernel;
+    _buildGraph(_numel: number): GraphFunctionLike;
+}
+declare class FusedSGD extends FusedOptimizer {
+    constructor(params: OptimizerParams, { lr, momentum, dampening, weightDecay, nesterov }?: FusedSGDOptions, target?: TargetLike | null);
+    _buildGraph(n: number): GraphFunctionLike;
+    step(): void;
+}
+declare class FusedAdam extends FusedOptimizer {
+    constructor(params: OptimizerParams, { lr, betas, eps, weightDecay, amsgrad }?: FusedAdamOptions, target?: TargetLike | null);
+    _buildGraph(n: number): GraphFunctionLike;
+    step(): void;
+}
+
+declare class GradScaler {
+    enabled: boolean;
+    private _scale;
+    private readonly _growthFactor;
+    private readonly _backoffFactor;
+    private readonly _growthInterval;
+    private _growthTracker;
+    _foundInf: boolean;
+    private _unscaled;
+    constructor(opts?: {
+        enabled?: boolean;
+        initScale?: number;
+        growthFactor?: number;
+        backoffFactor?: number;
+        growthInterval?: number;
+    });
+    getScale(): number;
+    get growthTracker(): number;
+    scale(loss: Tensor): Tensor;
+    unscale_(optimizer: Optimizer): boolean;
+    step(optimizer: Optimizer): boolean;
+    update(newScale?: number): void;
+}
+
+type index$3_Adam = Adam;
+declare const index$3_Adam: typeof Adam;
+type index$3_AdamW = AdamW;
+declare const index$3_AdamW: typeof AdamW;
+type index$3_CosineAnnealingLR = CosineAnnealingLR;
+declare const index$3_CosineAnnealingLR: typeof CosineAnnealingLR;
+type index$3_FusedAdam = FusedAdam;
+declare const index$3_FusedAdam: typeof FusedAdam;
+type index$3_FusedOptimizer = FusedOptimizer;
+declare const index$3_FusedOptimizer: typeof FusedOptimizer;
+type index$3_FusedSGD = FusedSGD;
+declare const index$3_FusedSGD: typeof FusedSGD;
+type index$3_GradScaler = GradScaler;
+declare const index$3_GradScaler: typeof GradScaler;
+type index$3_LRScheduler = LRScheduler;
+declare const index$3_LRScheduler: typeof LRScheduler;
+type index$3_Optimizer = Optimizer;
+declare const index$3_Optimizer: typeof Optimizer;
+type index$3_ReduceLROnPlateau = ReduceLROnPlateau;
+declare const index$3_ReduceLROnPlateau: typeof ReduceLROnPlateau;
+type index$3_SGD = SGD;
+declare const index$3_SGD: typeof SGD;
+type index$3_StepLR = StepLR;
+declare const index$3_StepLR: typeof StepLR;
+declare const index$3_clipGradNorm_: typeof clipGradNorm_;
+declare const index$3_clipGradValue_: typeof clipGradValue_;
+declare namespace index$3 {
+  export { index$3_Adam as Adam, index$3_AdamW as AdamW, index$3_CosineAnnealingLR as CosineAnnealingLR, index$3_FusedAdam as FusedAdam, index$3_FusedOptimizer as FusedOptimizer, index$3_FusedSGD as FusedSGD, index$3_GradScaler as GradScaler, index$3_LRScheduler as LRScheduler, index$3_Optimizer as Optimizer, index$3_ReduceLROnPlateau as ReduceLROnPlateau, index$3_SGD as SGD, index$3_StepLR as StepLR, index$3_clipGradNorm_ as clipGradNorm_, index$3_clipGradValue_ as clipGradValue_ };
+}
+
+type TraceFunction = (...inputs: SymbolicTensor[]) => MaybePromise<TensorOutput | TensorOutput[]>;
+declare function trace(fn: TraceFunction, exampleInputs: readonly Tensor[], opts?: CompileOptions): MaybePromise<GraphModuleLike>;
+declare function compile(model: CompilableModel, exampleInputs?: Tensor[], opts?: CompileOptions): unknown;
+
+type StepValue = TensorOutput | TensorOutput[];
+type ScanFn = (carry: StepValue, xs: StepValue) => [StepValue, StepValue];
+declare function scan(fn: ScanFn, initCarry: StepValue, xs: StepValue): [StepValue, StepValue];
+
+declare function compileWithBackward(model: CompilableModel, exampleInputs?: Tensor[], opts?: CompileOptions): unknown;
+
+declare class Callback {
+    setup(_trainer: unknown, _model: unknown, _stage: unknown): void;
+    teardown(_trainer: unknown, _model: unknown, _stage: unknown): void;
+    onFitStart(_trainer: unknown, _model: unknown): void;
+    onFitEnd(_trainer: unknown, _model: unknown): void;
+    onTrainStart(_trainer: unknown, _model: unknown): void;
+    onTrainEnd(_trainer: unknown, _model: unknown): void;
+    onTrainEpochStart(_trainer: unknown, _model: unknown): void;
+    onTrainEpochEnd(_trainer: unknown, _model: unknown): void;
+    onTrainBatchStart(_trainer: unknown, _model: unknown, _batch: unknown, _batchIdx: unknown): void;
+    onTrainBatchEnd(_trainer: unknown, _model: unknown, _outputs: unknown, _batch: unknown, _batchIdx: unknown): void;
+    onValidationStart(_trainer: unknown, _model: unknown): void;
+    onValidationEnd(_trainer: unknown, _model: unknown): void;
+    onValidationEpochStart(_trainer: unknown, _model: unknown): void;
+    onValidationEpochEnd(_trainer: unknown, _model: unknown): void;
+    onValidationBatchStart(_trainer: unknown, _model: unknown, _batch: unknown, _batchIdx: unknown): void;
+    onValidationBatchEnd(_trainer: unknown, _model: unknown, _outputs: unknown, _batch: unknown, _batchIdx: unknown): void;
+    onTestStart(_trainer: unknown, _model: unknown): void;
+    onTestEnd(_trainer: unknown, _model: unknown): void;
+    onTestBatchStart(_trainer: unknown, _model: unknown, _batch: unknown, _batchIdx: unknown): void;
+    onTestBatchEnd(_trainer: unknown, _model: unknown, _outputs: unknown, _batch: unknown, _batchIdx: unknown): void;
+    onPredictStart(_trainer: unknown, _model: unknown): void;
+    onPredictEnd(_trainer: unknown, _model: unknown): void;
+    onPredictBatchStart(_trainer: unknown, _model: unknown, _batch: unknown, _batchIdx: unknown): void;
+    onPredictBatchEnd(_trainer: unknown, _model: unknown, _outputs: unknown, _batch: unknown, _batchIdx: unknown): void;
+    onBeforeBackward(_trainer: unknown, _model: unknown, _loss: unknown): void;
+    onAfterBackward(_trainer: unknown, _model: unknown): void;
+    onBeforeOptimizerStep(_trainer: unknown, _model: unknown, _optimizer: unknown): void;
+    onBeforeZeroGrad(_trainer: unknown, _model: unknown, _optimizer: unknown): void;
+    onSaveCheckpoint(_trainer: unknown, _model: unknown, _checkpoint: unknown): void;
+    onLoadCheckpoint(_trainer: unknown, _model: unknown, _checkpoint: unknown): void;
+}
+
+declare enum Stage {
+    IDLE = "idle",
+    TRAINING = "training",
+    VALIDATING = "validating",
+    TESTING = "testing",
+    PREDICTING = "predicting"
+}
+type ReduceFnName = 'mean' | 'sum' | 'min' | 'max' | 'last';
+declare class MetricAccumulator {
+    private _accumulators;
+    private _reduceFns;
+    constructor();
+    update(name: string, value: MetricValue, reduceFx?: ReduceFnName): void;
+    compute(name: string): number | undefined;
+    computeAll(): NumericMetricRecord;
+    reset(): void;
+    has(name: string): boolean;
+    get size(): number;
+}
+declare class TrainerState {
+    stage: Stage;
+    epoch: number;
+    globalStep: number;
+    maxEpochs: number;
+    maxSteps: number;
+    shouldStop: boolean;
+    stepMetrics: MetricAccumulator;
+    epochMetrics: MetricAccumulator;
+    numTrainingBatches?: number;
+    numValBatches?: number;
+    _progBarMetrics?: Map<string, number>;
+    constructor();
+    resetEpochMetrics(): void;
+    resetStepMetrics(): void;
+}
+declare class SingleDeviceStrategy {
+    device: Device | null;
+    constructor();
+    setup(model: unknown, device: Device): void;
+    toDevice(value: unknown): unknown;
+    backward(loss: {
+        backward(): void;
+    }): void;
+    optimizerStep(optimizer: {
+        step(): void;
+    }): void;
+}
+
+declare enum HOOKS {
+    ON_FIT_START = "onFitStart",
+    ON_FIT_END = "onFitEnd",
+    ON_TRAIN_START = "onTrainStart",
+    ON_TRAIN_END = "onTrainEnd",
+    ON_TRAIN_EPOCH_START = "onTrainEpochStart",
+    ON_TRAIN_EPOCH_END = "onTrainEpochEnd",
+    ON_TRAIN_BATCH_START = "onTrainBatchStart",
+    ON_TRAIN_BATCH_END = "onTrainBatchEnd",
+    ON_VALIDATION_START = "onValidationStart",
+    ON_VALIDATION_END = "onValidationEnd",
+    ON_VALIDATION_EPOCH_START = "onValidationEpochStart",
+    ON_VALIDATION_EPOCH_END = "onValidationEpochEnd",
+    ON_VALIDATION_BATCH_START = "onValidationBatchStart",
+    ON_VALIDATION_BATCH_END = "onValidationBatchEnd",
+    ON_TEST_START = "onTestStart",
+    ON_TEST_END = "onTestEnd",
+    ON_TEST_BATCH_START = "onTestBatchStart",
+    ON_TEST_BATCH_END = "onTestBatchEnd",
+    ON_PREDICT_START = "onPredictStart",
+    ON_PREDICT_END = "onPredictEnd",
+    ON_PREDICT_BATCH_START = "onPredictBatchStart",
+    ON_PREDICT_BATCH_END = "onPredictBatchEnd",
+    SETUP = "setup",
+    TEARDOWN = "teardown",
+    ON_BEFORE_BACKWARD = "onBeforeBackward",
+    ON_AFTER_BACKWARD = "onAfterBackward",
+    ON_BEFORE_OPTIMIZER_STEP = "onBeforeOptimizerStep",
+    ON_BEFORE_ZERO_GRAD = "onBeforeZeroGrad",
+    ON_SAVE_CHECKPOINT = "onSaveCheckpoint",
+    ON_LOAD_CHECKPOINT = "onLoadCheckpoint"
+}
+type HookName = string;
+type LogModel = LightningModuleLike & {
+    _logBuffer: Map<string, unknown>;
+};
+declare class CallbackConnector {
+    private _callbacks;
+    constructor(callbacks?: Callback[]);
+    get callbacks(): Callback[];
+    add(callback: Callback): void;
+    dispatch(hookName: HookName, ...args: unknown[]): void;
+    remove(callback: Callback): void;
+}
+declare class LoggerConnector {
+    private _loggers;
+    private _state;
+    constructor(loggers: (Logger | Logger[]) | undefined, state: TrainerState);
+    drain(model: LogModel): void;
+    flushStepMetrics(step: number): NumericMetricRecord;
+    flushEpochMetrics(step: number): NumericMetricRecord;
+    logHyperparams(params: HyperparameterRecord): void;
+}
+
+type MetricResult = number | number[] | number[][];
+type MetricValue = number | {
+    item(): number | bigint;
+};
+type UnknownRecord = Record<string, unknown>;
+type NumericMetricRecord = Record<string, number>;
+type HyperparameterRecord = UnknownRecord;
+type LoggerOptions = {
+    name?: string;
+    version?: number | null;
+};
+type ClassificationTask = 'binary' | 'multiclass';
+type AccuracyTask = ClassificationTask | 'multilabel';
+type AverageMode = 'macro' | 'micro' | 'weighted' | 'none';
+type TrainerLike = {
+    state: {
+        epoch: number;
+        globalStep: number;
+        maxEpochs?: number;
+        numTrainingBatches?: number;
+        numValBatches?: number;
+        _progBarMetrics?: Map<string, unknown>;
+        epochMetrics?: {
+            computeAll(): Record<string, number | undefined>;
+        };
+    };
+    accumulateGradBatches?: number;
+    limitTrainBatches?: number | null;
+    limitValBatches?: number | null;
+    shouldStop?: boolean;
+    callbackConnector?: {
+        dispatch(hook: string, ...args: unknown[]): void;
+    };
+};
+type OptimizerGroupLike = {
+    lr: number;
+    momentum?: number;
+    [key: string]: unknown;
+};
+type OptimizerLike = {
+    paramGroups: OptimizerGroupLike[];
+    defaults?: Record<string, unknown>;
+    step(): void;
+    zeroGrad(): void;
+    stateDict?(): unknown;
+};
+type LightningModuleLike = {
+    _currentOptimizers?: OptimizerLike[];
+    _logBuffer: Map<string, unknown>;
+    _trainer?: unknown;
+    _device?: Device | null;
+    __compiledTrainStep?: CompiledTrainStep;
+    __eagerGraphRunner?: EagerGraphRunner;
+    automaticOptimization: boolean;
+    log(name: string, value: unknown, options?: UnknownRecord): void;
+    stateDict?(): unknown;
+    loadStateDict?(state: unknown): void;
+    parameters?(): Iterable<unknown>;
+    train(): void;
+    eval(): void;
+    forward(...args: unknown[]): unknown;
+    trainingStep(batch: unknown, batchIdx: number): unknown;
+    validationStep(batch: unknown, batchIdx: number): unknown;
+    testStep(batch: unknown, batchIdx: number): unknown;
+    predictStep(batch: unknown, batchIdx: number): unknown;
+    configureOptimizers(): unknown;
+    onTrainEpochStart(): void;
+    onTrainEpochEnd(): void;
+    onValidationEpochStart(): void;
+    onValidationEpochEnd(): void;
+    onTestEpochStart(): void;
+    onTestEpochEnd(): void;
+};
+type DataLoaderLike = Iterable<unknown> & {
+    length: number;
+};
+type TrainerCoreLike = {
+    state: TrainerState;
+    strategy: SingleDeviceStrategy;
+    callbackConnector: CallbackConnector;
+    loggerConnector: LoggerConnector;
+    fitLoop: {
+        validationLoop: {
+            run(model: LightningModuleLike, dataLoader: DataLoaderLike, trainer: TrainerCoreLike, schedulerConfigs: Array<SchedulerConfig | null> | null): Promise<NumericMetricRecord>;
+        };
+    };
+    checkValEveryNEpoch: number;
+    accumulateGradBatches: number;
+    limitTrainBatches: number | null;
+    limitValBatches: number | null;
+    limitTestBatches: number | null;
+    logEveryNSteps: number;
+    gradientClipVal: number | null;
+    gradientClipAlgorithm: string;
+    compile: boolean;
+    compileMode: string;
+    cudaGraph: boolean;
+    cudaGraphWarmupSteps: number;
+    _flushEagerInference(): Promise<void>;
+};
+type TrainerOptions = {
+    maxEpochs?: number;
+    maxSteps?: number;
+    accelerator?: 'auto' | 'cpu' | 'gpu' | 'wasm' | 'webgpu';
+    precision?: string;
+    callbacks?: Callback[];
+    logger?: boolean | Logger | Logger[] | null;
+    enableCheckpointing?: boolean;
+    enableProgress?: boolean;
+    gradientClipVal?: number | null;
+    gradientClipAlgorithm?: string;
+    accumulateGradBatches?: number;
+    limitTrainBatches?: number | null;
+    limitValBatches?: number | null;
+    limitTestBatches?: number | null;
+    valCheckInterval?: number;
+    checkValEveryNEpoch?: number;
+    logEveryNSteps?: number;
+    deterministic?: boolean;
+    fastDevRun?: boolean | number;
+    defaultRootDir?: string;
+    compile?: boolean;
+    compileMode?: string;
+    cudaGraph?: boolean;
+    cudaGraphWarmupSteps?: number;
+};
+type CompiledTrainStep = {
+    (...args: unknown[]): unknown;
+    capturedParams(): Array<{
+        grad: unknown;
+    }>;
+    backward(seed: unknown): unknown;
+};
+type EagerGraphRunner = {
+    phase: 'warmup' | 'disabled' | 'replay';
+    seen: number;
+    inputs?: Array<{
+        dptr: unknown;
+    }>;
+    captured?: {
+        exec: unknown;
+    };
+    exec?: unknown;
+    lossDptr?: unknown;
+    lossScratch?: Float32Array;
+    captureError?: unknown;
+};
+type TensorLike = {
+    readonly shape: readonly number[];
+    readonly _impl: {
+        readonly storage: {
+            readonly data: NumericTypedArray;
+        };
+    };
+};
+
+declare class Logger {
+    protected _name: string;
+    protected _version: number | null;
+    constructor({ name, version }?: LoggerOptions);
+    get name(): string;
+    get version(): number | null;
+    logMetrics(_metrics: NumericMetricRecord, _step: number): void;
+    logHyperparams(_params: HyperparameterRecord): void;
+    finalize(): void;
+}
+
+type LogOptions = {
+    onStep?: boolean | null;
+    onEpoch?: boolean | null;
+    reduceFx?: ReduceFnName;
+    progBar?: boolean;
+};
+type LogEntry = {
+    value: MetricValue;
+    onStep: boolean;
+    onEpoch: boolean;
+    reduceFx: ReduceFnName;
+    progBar: boolean;
+};
+type TrainerRef = {
+    state: {
+        epoch: number;
+        globalStep: number;
+        stage: Stage | string;
+    };
+    logger: Logger | null;
+    loggers: Logger[];
+    strategy?: {
+        backward(loss: {
+            backward(): void;
+        }): void;
+    };
+};
+type SchedulerLike = {
+    step(...args: unknown[]): void;
+};
+type SchedulerConfig = {
+    scheduler: SchedulerLike;
+    interval: 'step' | 'epoch';
+    frequency: number;
+    monitor: string | null;
+};
+declare class LightningModule extends Module {
+    _trainer: TrainerRef | null;
+    _logBuffer: Map<string, LogEntry>;
+    _automaticOptimization: boolean;
+    _currentOptimizers: OptimizerLike[];
+    _device: Device | null;
+    constructor();
+    get trainer(): TrainerRef | null;
+    get currentEpoch(): number;
+    get globalStep(): number;
+    get device(): Device | null;
+    get logger(): Logger | null;
+    get loggers(): Logger[];
+    get automaticOptimization(): boolean;
+    set automaticOptimization(value: boolean);
+    get optimizers(): OptimizerLike[];
+    trainingStep(_batch: unknown, _batchIdx: number): unknown;
+    validationStep(_batch: unknown, _batchIdx: number): unknown;
+    testStep(_batch: unknown, _batchIdx: number): unknown;
+    predictStep(batch: unknown, _batchIdx: number): unknown;
+    configureOptimizers(): unknown;
+    onTrainEpochStart(): void;
+    onTrainEpochEnd(): void;
+    onValidationEpochStart(): void;
+    onValidationEpochEnd(): void;
+    onTestEpochStart(): void;
+    onTestEpochEnd(): void;
+    log(name: string, value: MetricValue, { onStep, onEpoch, reduceFx, progBar, }?: LogOptions): void;
+    logDict(dict: Record<string, MetricValue>, opts?: LogOptions): void;
+    manualBackward(loss: {
+        backward(): void;
+    }): void;
+}
+
+type TrainingOutput = unknown;
+declare class TrainingLoop {
+    run(model: LightningModuleLike, dataLoader: DataLoaderLike, trainer: TrainerCoreLike, optimizers: OptimizerLike[], schedulerConfigs: Array<SchedulerConfig | null>): Promise<NumericMetricRecord>;
+    _automaticStep(model: LightningModuleLike, batch: unknown, batchIdx: number, trainer: TrainerCoreLike, optimizers: OptimizerLike[], schedulerConfigs: Array<SchedulerConfig | null>, strategy: SingleDeviceStrategy, accumGrad: number, callbacks: CallbackConnector): Promise<TrainingOutput>;
+    _compiledStep(model: LightningModuleLike, batch: unknown, batchIdx: number, trainer: TrainerCoreLike, optimizers: OptimizerLike[], schedulerConfigs: Array<SchedulerConfig | null>, accumGrad: number): Promise<unknown>;
+    _eagerTrainStepCore(model: LightningModuleLike, batch: unknown, optimizers: OptimizerLike[], strategy: SingleDeviceStrategy, trainer: TrainerCoreLike | null): Promise<unknown>;
+    _graphedStep(model: LightningModuleLike, batch: unknown, trainer: TrainerCoreLike, optimizers: OptimizerLike[], schedulerConfigs: Array<SchedulerConfig | null>, strategy: SingleDeviceStrategy): Promise<unknown>;
+    _logGraphLoss(trainer: TrainerCoreLike, value: number): void;
+    _clipGradients(model: LightningModuleLike, trainer: TrainerCoreLike): void;
+    _stepStepSchedulers(schedulerConfigs: Array<SchedulerConfig | null> | null, globalStep: number): void;
+    _stepEpochSchedulers(schedulerConfigs: Array<SchedulerConfig | null> | null, epoch: number): void;
+}
+
+declare class ValidationLoop {
+    run(model: LightningModuleLike, dataLoader: DataLoaderLike, trainer: TrainerCoreLike, schedulerConfigs: Array<SchedulerConfig | null> | null): Promise<NumericMetricRecord>;
+    private _stepPlateauSchedulers;
+}
+
+declare class FitLoop {
+    private _trainingLoop;
+    private _validationLoop;
+    constructor();
+    get trainingLoop(): TrainingLoop;
+    get validationLoop(): ValidationLoop;
+    run(model: LightningModuleLike, trainLoader: DataLoaderLike, valLoader: DataLoaderLike | null, trainer: TrainerCoreLike, optimizers: OptimizerLike[], schedulerConfigs: Array<SchedulerConfig | null>): Promise<void>;
+    _shouldRunValidation(epoch: number, trainer: TrainerCoreLike): boolean;
+}
+
+declare class Trainer {
+    private _state;
+    private _compile;
+    private _compileMode;
+    private _cudaGraph;
+    private _cudaGraphWarmupSteps;
+    private _accelerator;
+    private _precision;
+    private _gradientClipVal;
+    private _gradientClipAlgorithm;
+    private _accumulateGradBatches;
+    private _limitTrainBatches;
+    private _limitValBatches;
+    private _limitTestBatches;
+    private _valCheckInterval;
+    private _checkValEveryNEpoch;
+    private _logEveryNSteps;
+    private _deterministic;
+    private _defaultRootDir;
+    private _loggers;
+    private _strategy;
+    private _fitLoop;
+    private _evaluationLoop;
+    private _predictionLoop;
+    private _callbackConnector;
+    private _loggerConnector;
+    private _model;
+    private _webgpuMod;
+    constructor({ maxEpochs, maxSteps, accelerator, precision, callbacks, logger, enableCheckpointing, enableProgress, gradientClipVal, gradientClipAlgorithm, accumulateGradBatches, limitTrainBatches, limitValBatches, limitTestBatches, valCheckInterval, checkValEveryNEpoch, logEveryNSteps, deterministic, fastDevRun, defaultRootDir, compile, compileMode, cudaGraph, cudaGraphWarmupSteps, }?: TrainerOptions);
+    get state(): TrainerState;
+    get strategy(): SingleDeviceStrategy;
+    get callbackConnector(): CallbackConnector;
+    get loggerConnector(): LoggerConnector;
+    get fitLoop(): FitLoop;
+    get gradientClipVal(): number | null;
+    get gradientClipAlgorithm(): string;
+    get compile(): boolean;
+    get compileMode(): string;
+    get cudaGraph(): boolean;
+    get cudaGraphWarmupSteps(): number;
+    get accumulateGradBatches(): number;
+    set accumulateGradBatches(v: number);
+    get limitTrainBatches(): number | null;
+    get limitValBatches(): number | null;
+    get limitTestBatches(): number | null;
+    get checkValEveryNEpoch(): number;
+    get logEveryNSteps(): number;
+    get shouldStop(): boolean;
+    set shouldStop(v: boolean);
+    get currentEpoch(): number;
+    get globalStep(): number;
+    get logger(): Logger | null;
+    get loggers(): Logger[];
+    get callbacks(): Callback[];
+    get model(): LightningModuleLike | null;
+    get defaultRootDir(): string;
+    fit(model: LightningModuleLike, trainLoader: DataLoaderLike, valLoader?: DataLoaderLike | null): Promise<void>;
+    validate(model: LightningModuleLike, dataLoader: DataLoaderLike): Promise<NumericMetricRecord>;
+    test(model: LightningModuleLike, dataLoader: DataLoaderLike): Promise<NumericMetricRecord>;
+    predict(model: LightningModuleLike, dataLoader: DataLoaderLike): Promise<unknown[]>;
+    _resolveDevice(): Device;
+    _guardEagerWebGPU(device: Device, stage: string, hasValidation?: boolean): void;
+    _guardCudaGraph(device: Device, hasValidation?: boolean): void;
+    _prepareDevice(device: Device): Promise<void>;
+    _flushEagerInference(): Promise<void>;
+    _resolveLoggers(loggerConfig: TrainerOptions['logger']): Logger[];
+    _extractHyperparams(model: LightningModuleLike, optimizers: OptimizerLike[]): HyperparameterRecord;
+}
+
+declare class EvaluationLoop {
+    run(model: LightningModuleLike, dataLoader: DataLoaderLike, trainer: TrainerCoreLike): Promise<NumericMetricRecord>;
+}
+
+declare class PredictionLoop {
+    run(model: LightningModuleLike, dataLoader: DataLoaderLike, trainer: TrainerCoreLike): Promise<unknown[]>;
+}
+
+type CheckpointMode = 'min' | 'max';
+type BestKEntry = {
+    score: number;
+    path: string;
+};
+type ModelCheckpointOptions = {
+    dirpath?: string;
+    filename?: string;
+    monitor?: string | null;
+    mode?: CheckpointMode;
+    saveTopK?: number;
+    saveLast?: boolean;
+    everyNEpochs?: number;
+};
+type CheckpointModel = Omit<LightningModuleLike, '_currentOptimizers'> & {
+    stateDict(): unknown;
+    _currentOptimizers?: CheckpointOptimizer[];
+};
+type CheckpointOptimizer = {
+    stateDict(): unknown;
+    loadStateDict(state: unknown): void;
+};
+declare class ModelCheckpoint extends Callback {
+    private _dirpath;
+    private _filename;
+    private _monitor;
+    private _mode;
+    private _saveTopK;
+    private _saveLast;
+    private _everyNEpochs;
+    private _bestK;
+    private _recent;
+    private _compareFn;
+    private _bestModelPath;
+    private _lastModelPath;
+    constructor({ dirpath, filename, monitor, mode, saveTopK, saveLast, everyNEpochs, }?: ModelCheckpointOptions);
+    get bestModelPath(): string | null;
+    get lastModelPath(): string | null;
+    get bestKModels(): BestKEntry[];
+    onTrainEpochEnd(trainer: TrainerLike, model: CheckpointModel): void;
+    private _findInsertIndex;
+    private _updateBest;
+    private _saveCheckpoint;
+    private _fillTemplate;
+    private _ensureDir;
+    private _tryDelete;
+}
+declare function loadCheckpoint(path: string): unknown;
+declare function applyCheckpoint(checkpoint: unknown, model: LightningModuleLike, optimizers?: CheckpointOptimizer[]): unknown;
+
+declare function serializeCheckpoint(checkpoint: unknown): Uint8Array;
+declare function deserializeCheckpoint(bytes: Uint8Array | ArrayBufferLike): unknown;
+
+type EarlyStoppingMode = 'min' | 'max';
+type EarlyStoppingOptions = {
+    monitor?: string;
+    patience?: number;
+    mode?: EarlyStoppingMode;
+    minDelta?: number;
+    checkOnTrainEpochEnd?: boolean;
+};
+declare class EarlyStopping extends Callback {
+    private _monitor;
+    private _patience;
+    private _mode;
+    private _minDelta;
+    private _checkOnTrainEpochEnd;
+    private _waitCount;
+    private _bestScore;
+    private _compareFn;
+    constructor({ monitor, patience, mode, minDelta, checkOnTrainEpochEnd, }?: EarlyStoppingOptions);
+    get monitor(): string;
+    get patience(): number;
+    get bestScore(): number | null;
+    get waitCount(): number;
+    onValidationEnd(trainer: TrainerLike, _model?: unknown): void;
+    onTrainEpochEnd(trainer: TrainerLike, _model?: unknown): void;
+    private _check;
+    reset(): void;
+}
+
+type ProgressOptions = {
+    barLength?: number;
+};
+declare class ProgressCallback extends Callback {
+    private _barLength;
+    private _trainBatchCount;
+    private _valBatchCount;
+    private _epochStartTime;
+    private _lastLen;
+    private _active;
+    constructor({ barLength }?: ProgressOptions);
+    onTrainEpochStart(trainer: TrainerLike, _model: unknown): void;
+    onTrainBatchEnd(trainer: TrainerLike, _model: unknown, _outputs: unknown, _batch: unknown, _batchIdx: unknown): void;
+    onTrainEpochEnd(trainer: TrainerLike, _model: unknown): void;
+    onTrainEnd(_trainer: unknown, _model: unknown): void;
+    onValidationEpochStart(_trainer: unknown, _model: unknown): void;
+    onValidationBatchEnd(trainer: TrainerLike, _model: unknown, _outputs: unknown, _batch: unknown, _batchIdx: unknown): void;
+    onValidationEnd(trainer: TrainerLike, _model: unknown): void;
+    private _trainTotal;
+    private _valTotal;
+    private _render;
+    private _bar;
+    private _formatProgBarMetrics;
+}
+
+type LearningRateMonitorOptions = {
+    logMomentum?: boolean;
+};
+type LRHistoryEntry = {
+    step: number;
+    lr: number;
+};
+declare class LearningRateMonitor extends Callback {
+    private _logMomentum;
+    private _lrHistory;
+    constructor({ logMomentum }?: LearningRateMonitorOptions);
+    get lrHistory(): Record<string, LRHistoryEntry[]>;
+    onTrainBatchStart(trainer: TrainerLike, model: LightningModuleLike, _batch: unknown, _batchIdx: unknown): void;
+}
+
+declare class Timer extends Callback {
+    private _fitStartTime;
+    private _epochStartTime;
+    private _epochDurations;
+    private _validationDurations;
+    private _totalTrainingTime;
+    private _valStartTime;
+    constructor();
+    get epochDurations(): number[];
+    get validationDurations(): number[];
+    get totalTrainingTime(): number;
+    onFitStart(_trainer: unknown, _model: unknown): void;
+    onFitEnd(_trainer: unknown, _model: unknown): void;
+    onTrainEpochStart(_trainer: unknown, _model: unknown): void;
+    onTrainEpochEnd(_trainer: unknown, _model: unknown): void;
+    onValidationStart(_trainer: unknown, _model: unknown): void;
+    onValidationEnd(_trainer: unknown, _model: unknown): void;
+}
+
+type GradientAccumulationOptions = {
+    scheduling: Record<string, number>;
+};
+declare class GradientAccumulationScheduler extends Callback {
+    private _scheduling;
+    private _sortedEpochs;
+    constructor({ scheduling }: GradientAccumulationOptions);
+    onTrainEpochStart(trainer: TrainerLike, _model?: unknown): void;
+    getCurrentAccumulation(epoch: number): number;
+}
+
+type ConsoleLoggerOptions = LoggerOptions & {
+    logFrequency?: number;
+};
+declare class ConsoleLogger extends Logger {
+    private _logFrequency;
+    private _callCount;
+    constructor(opts?: ConsoleLoggerOptions);
+    logMetrics(metrics: NumericMetricRecord, step: number): void;
+    logHyperparams(params: HyperparameterRecord): void;
+}
+
+type CSVLoggerOptions = LoggerOptions & {
+    saveDir?: string;
+    flushInterval?: number;
+};
+declare class CSVLogger extends Logger {
+    private _saveDir;
+    private _flushInterval;
+    private _columns;
+    private _columnSet;
+    private _buffer;
+    private _filePath;
+    private _headerWritten;
+    protected _version: number | null;
+    constructor({ saveDir, name, version, flushInterval, }?: CSVLoggerOptions);
+    get logDir(): string;
+    logMetrics(metrics: NumericMetricRecord, step: number): void;
+    logHyperparams(params: HyperparameterRecord): void;
+    finalize(): void;
+    private _flush;
+    private _getFilePath;
+    private _ensureDir;
+    private _resolveVersion;
+}
+
+declare class Metric {
+    protected _computed: MetricResult | null;
+    constructor();
+    update(_preds: unknown, _target: unknown): void;
+    compute(): MetricResult;
+    reset(): void;
+    forward(preds: unknown, target: unknown): MetricResult;
+    get value(): MetricResult | null;
+}
+
+declare class MeanMetric extends Metric {
+    private _sum;
+    private _count;
+    constructor();
+    update(value: MetricValue, weight?: number): void;
+    compute(): number;
+    reset(): void;
+}
+declare class SumMetric extends Metric {
+    private _sum;
+    constructor();
+    update(value: MetricValue): void;
+    compute(): number;
+    reset(): void;
+}
+
+type MetricMap = Record<string, Metric>;
+declare class MetricCollection {
+    private _metrics;
+    constructor(metrics?: MetricMap);
+    add(name: string, metric: Metric): this;
+    update(preds: TensorLike, target: TensorLike): void;
+    compute(): Record<string, MetricResult>;
+    reset(): void;
+    forward(preds: TensorLike, target: TensorLike): Record<string, MetricResult>;
+    get(name: string): Metric | undefined;
+    has(name: string): boolean;
+    get size(): number;
+    [Symbol.iterator](): MapIterator<[string, Metric]>;
+}
+
+type AccuracyOptions = {
+    task?: AccuracyTask;
+    numClasses?: number | null;
+    topK?: number;
+    threshold?: number;
+};
+declare class Accuracy extends Metric {
+    private _task;
+    private _numClasses;
+    private _topK;
+    private _threshold;
+    private _correct;
+    private _total;
+    constructor({ task, numClasses, topK, threshold }?: AccuracyOptions);
+    update(preds: TensorLike, target: TensorLike): void;
+    compute(): number;
+    reset(): void;
+    private _updateBinary;
+    private _updateMulticlass;
+    private _updateMultilabel;
+}
+
+type ClassificationOptions = {
+    task?: ClassificationTask;
+    numClasses?: number;
+    average?: AverageMode;
+};
+declare class Precision extends Metric {
+    private _task;
+    private _numClasses;
+    private _average;
+    private _tp;
+    private _fp;
+    private _support;
+    constructor({ task, numClasses, average }?: ClassificationOptions);
+    update(preds: TensorLike, target: TensorLike): void;
+    compute(): number | number[];
+    reset(): void;
+}
+declare class Recall extends Metric {
+    private _task;
+    private _numClasses;
+    private _average;
+    private _tp;
+    private _fn;
+    private _support;
+    constructor({ task, numClasses, average }?: ClassificationOptions);
+    update(preds: TensorLike, target: TensorLike): void;
+    compute(): number | number[];
+    reset(): void;
+}
+declare class F1Score extends Metric {
+    private _task;
+    private _numClasses;
+    private _average;
+    private _tp;
+    private _fp;
+    private _fn;
+    private _support;
+    constructor({ task, numClasses, average }?: ClassificationOptions);
+    update(preds: TensorLike, target: TensorLike): void;
+    compute(): number | number[];
+    reset(): void;
+}
+
+type ConfusionMatrixOptions = {
+    numClasses: number;
+};
+declare class ConfusionMatrix extends Metric {
+    private _numClasses;
+    private _matrix;
+    constructor({ numClasses }: ConfusionMatrixOptions);
+    update(preds: TensorLike, target: TensorLike): void;
+    compute(): number[][];
+    reset(): void;
+}
+
+type index$2_Accuracy = Accuracy;
+declare const index$2_Accuracy: typeof Accuracy;
+type index$2_CSVLogger = CSVLogger;
+declare const index$2_CSVLogger: typeof CSVLogger;
+type index$2_Callback = Callback;
+declare const index$2_Callback: typeof Callback;
+type index$2_CallbackConnector = CallbackConnector;
+declare const index$2_CallbackConnector: typeof CallbackConnector;
+type index$2_ConfusionMatrix = ConfusionMatrix;
+declare const index$2_ConfusionMatrix: typeof ConfusionMatrix;
+type index$2_ConsoleLogger = ConsoleLogger;
+declare const index$2_ConsoleLogger: typeof ConsoleLogger;
+type index$2_EarlyStopping = EarlyStopping;
+declare const index$2_EarlyStopping: typeof EarlyStopping;
+type index$2_EvaluationLoop = EvaluationLoop;
+declare const index$2_EvaluationLoop: typeof EvaluationLoop;
+type index$2_F1Score = F1Score;
+declare const index$2_F1Score: typeof F1Score;
+type index$2_FitLoop = FitLoop;
+declare const index$2_FitLoop: typeof FitLoop;
+type index$2_GradientAccumulationScheduler = GradientAccumulationScheduler;
+declare const index$2_GradientAccumulationScheduler: typeof GradientAccumulationScheduler;
+type index$2_HOOKS = HOOKS;
+declare const index$2_HOOKS: typeof HOOKS;
+type index$2_LearningRateMonitor = LearningRateMonitor;
+declare const index$2_LearningRateMonitor: typeof LearningRateMonitor;
+type index$2_LightningModule = LightningModule;
+declare const index$2_LightningModule: typeof LightningModule;
+type index$2_Logger = Logger;
+declare const index$2_Logger: typeof Logger;
+type index$2_LoggerConnector = LoggerConnector;
+declare const index$2_LoggerConnector: typeof LoggerConnector;
+type index$2_MeanMetric = MeanMetric;
+declare const index$2_MeanMetric: typeof MeanMetric;
+type index$2_Metric = Metric;
+declare const index$2_Metric: typeof Metric;
+type index$2_MetricAccumulator = MetricAccumulator;
+declare const index$2_MetricAccumulator: typeof MetricAccumulator;
+type index$2_MetricCollection = MetricCollection;
+declare const index$2_MetricCollection: typeof MetricCollection;
+type index$2_ModelCheckpoint = ModelCheckpoint;
+declare const index$2_ModelCheckpoint: typeof ModelCheckpoint;
+type index$2_Precision = Precision;
+declare const index$2_Precision: typeof Precision;
+type index$2_PredictionLoop = PredictionLoop;
+declare const index$2_PredictionLoop: typeof PredictionLoop;
+type index$2_ProgressCallback = ProgressCallback;
+declare const index$2_ProgressCallback: typeof ProgressCallback;
+type index$2_Recall = Recall;
+declare const index$2_Recall: typeof Recall;
+type index$2_SingleDeviceStrategy = SingleDeviceStrategy;
+declare const index$2_SingleDeviceStrategy: typeof SingleDeviceStrategy;
+type index$2_Stage = Stage;
+declare const index$2_Stage: typeof Stage;
+type index$2_SumMetric = SumMetric;
+declare const index$2_SumMetric: typeof SumMetric;
+type index$2_Timer = Timer;
+declare const index$2_Timer: typeof Timer;
+type index$2_Trainer = Trainer;
+declare const index$2_Trainer: typeof Trainer;
+type index$2_TrainerState = TrainerState;
+declare const index$2_TrainerState: typeof TrainerState;
+type index$2_TrainingLoop = TrainingLoop;
+declare const index$2_TrainingLoop: typeof TrainingLoop;
+type index$2_ValidationLoop = ValidationLoop;
+declare const index$2_ValidationLoop: typeof ValidationLoop;
+declare const index$2_applyCheckpoint: typeof applyCheckpoint;
+declare const index$2_deserializeCheckpoint: typeof deserializeCheckpoint;
+declare const index$2_loadCheckpoint: typeof loadCheckpoint;
+declare const index$2_serializeCheckpoint: typeof serializeCheckpoint;
+declare namespace index$2 {
+  export { index$2_Accuracy as Accuracy, index$2_CSVLogger as CSVLogger, index$2_Callback as Callback, index$2_CallbackConnector as CallbackConnector, index$2_ConfusionMatrix as ConfusionMatrix, index$2_ConsoleLogger as ConsoleLogger, index$2_EarlyStopping as EarlyStopping, index$2_EvaluationLoop as EvaluationLoop, index$2_F1Score as F1Score, index$2_FitLoop as FitLoop, index$2_GradientAccumulationScheduler as GradientAccumulationScheduler, index$2_HOOKS as HOOKS, index$2_LearningRateMonitor as LearningRateMonitor, index$2_LightningModule as LightningModule, index$2_Logger as Logger, index$2_LoggerConnector as LoggerConnector, index$2_MeanMetric as MeanMetric, index$2_Metric as Metric, index$2_MetricAccumulator as MetricAccumulator, index$2_MetricCollection as MetricCollection, index$2_ModelCheckpoint as ModelCheckpoint, index$2_Precision as Precision, index$2_PredictionLoop as PredictionLoop, index$2_ProgressCallback as ProgressCallback, index$2_Recall as Recall, index$2_SingleDeviceStrategy as SingleDeviceStrategy, index$2_Stage as Stage, index$2_SumMetric as SumMetric, index$2_Timer as Timer, index$2_Trainer as Trainer, index$2_TrainerState as TrainerState, index$2_TrainingLoop as TrainingLoop, index$2_ValidationLoop as ValidationLoop, index$2_applyCheckpoint as applyCheckpoint, index$2_deserializeCheckpoint as deserializeCheckpoint, index$2_loadCheckpoint as loadCheckpoint, index$2_serializeCheckpoint as serializeCheckpoint };
+}
+
+declare namespace fs {
+    function readFile(path: any): any;
+    function readBinary(path: any): any;
+    function writeFile(path: any, data: any): void;
+    function writeBinary(path: any, data: any): void;
+    function appendFile(path: any, data: any): void;
+    function exists(path: any): any;
+    function mkdir(path: any): void;
+    function readdir(path: any): any;
+    function remove(path: any): void;
+    function rename(from: any, to: any): void;
+}
+
+declare function svd(a: Tensor): {
+    U: Tensor;
+    S: Tensor;
+    V: Tensor;
+};
+declare function eigh(a: Tensor): {
+    values: Tensor;
+    vectors: Tensor;
+};
+declare function qr(a: Tensor): {
+    Q: Tensor;
+    R: Tensor;
+};
+declare const cholesky: (a: Tensor) => Tensor;
+declare const inv: (a: Tensor) => Tensor;
+declare const pinv: (a: Tensor) => Tensor;
+declare const cov: (a: Tensor) => Tensor;
+declare const solve: (a: Tensor, b: Tensor) => Tensor;
+declare const lstsq: (a: Tensor, b: Tensor) => Tensor;
+declare const det: (a: Tensor) => number | bigint;
+
+declare const linalg_cholesky: typeof cholesky;
+declare const linalg_cov: typeof cov;
+declare const linalg_det: typeof det;
+declare const linalg_eigh: typeof eigh;
+declare const linalg_inv: typeof inv;
+declare const linalg_lstsq: typeof lstsq;
+declare const linalg_pinv: typeof pinv;
+declare const linalg_qr: typeof qr;
+declare const linalg_solve: typeof solve;
+declare const linalg_svd: typeof svd;
+declare namespace linalg {
+  export { linalg_cholesky as cholesky, linalg_cov as cov, linalg_det as det, linalg_eigh as eigh, linalg_inv as inv, linalg_lstsq as lstsq, linalg_pinv as pinv, linalg_qr as qr, linalg_solve as solve, linalg_svd as svd };
+}
+
+type MLTensor = Tensor & {
+    reshape(shape: readonly number[]): MLTensor;
+    transpose(dim0: number, dim1: number): MLTensor;
+    narrow(dim: number, start: number, length: number): MLTensor;
+    toArray(): ArrayLike<number | bigint>;
+};
+type FitPredictEstimator = {
+    fit(X: MLTensor, y: MLTensor): FitPredictEstimator;
+    predict(X: MLTensor): MLTensor;
+    score?(X: MLTensor, y: MLTensor): number;
+};
+
+declare class StandardScaler {
+    withMean: boolean;
+    withStd: boolean;
+    mean_: Float64Array | null;
+    scale_: Float64Array | null;
+    private _cols?;
+    constructor({ withMean, withStd }?: {
+        withMean?: boolean;
+        withStd?: boolean;
+    });
+    fit(X: MLTensor): this;
+    transform(X: MLTensor): MLTensor;
+    fit_transform(X: MLTensor): MLTensor;
+    inverse_transform(X: MLTensor): MLTensor;
+}
+declare class LabelEncoder {
+    classes_: number[] | null;
+    private _lookup;
+    constructor();
+    fit(y: MLTensor): this;
+    transform(y: MLTensor): MLTensor;
+    fit_transform(y: MLTensor): MLTensor;
+    inverse_transform(y: MLTensor): number[];
+}
+declare class OneHotEncoder {
+    classes_: number[] | null;
+    constructor();
+    fit(y: MLTensor): this;
+    transform(y: MLTensor): MLTensor;
+    fit_transform(y: MLTensor): MLTensor;
+}
+declare class MinMaxScaler {
+    featureRange: readonly [number, number];
+    min_: null;
+    dataMin_: Float64Array | null;
+    dataRange_: Float64Array | null;
+    constructor({ featureRange }?: {
+        featureRange?: readonly [number, number];
+    });
+    fit(X: MLTensor): this;
+    transform(X: MLTensor): MLTensor;
+    fit_transform(X: MLTensor): MLTensor;
+}
+
+declare function mean_squared_error(yTrue: MLTensor, yPred: MLTensor): number;
+declare function mean_absolute_error(yTrue: MLTensor, yPred: MLTensor): number;
+declare function r2_score(yTrue: MLTensor, yPred: MLTensor): number;
+declare function accuracy_score(yTrue: MLTensor, yPred: MLTensor): number;
+declare function confusion_matrix(yTrue: MLTensor, yPred: MLTensor): number[][];
+
+declare class LinearRegression {
+    fitIntercept: boolean;
+    weight_: MLTensor | null;
+    constructor({ fitIntercept }?: {
+        fitIntercept?: boolean;
+    });
+    fit(X: MLTensor, y: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+    score(X: MLTensor, y: MLTensor): number;
+}
+declare class Ridge {
+    alpha: number;
+    fitIntercept: boolean;
+    coef_: MLTensor | null;
+    intercept_: MLTensor | null;
+    constructor({ alpha, fitIntercept }?: {
+        alpha?: number;
+        fitIntercept?: boolean;
+    });
+    fit(X: MLTensor, y: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+    score(X: MLTensor, y: MLTensor): number;
+}
+declare class ElasticNet {
+    alpha: number;
+    l1Ratio: number;
+    fitIntercept: boolean;
+    maxIter: number;
+    tol: number;
+    coef_: MLTensor | null;
+    intercept_: MLTensor | null;
+    constructor({ alpha, l1Ratio, fitIntercept, maxIter, tol }?: {
+        alpha?: number;
+        l1Ratio?: number;
+        fitIntercept?: boolean;
+        maxIter?: number;
+        tol?: number;
+    });
+    fit(X: MLTensor, y: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+    score(X: MLTensor, y: MLTensor): number;
+}
+declare class Lasso extends ElasticNet {
+    constructor({ alpha, fitIntercept, maxIter, tol }?: {
+        alpha?: number;
+        fitIntercept?: boolean;
+        maxIter?: number;
+        tol?: number;
+    });
+}
+declare class LogisticRegression {
+    C: number;
+    lr: number;
+    maxIter: number;
+    W_: MLTensor | null;
+    b_: MLTensor | null;
+    classes_: number[] | null;
+    constructor({ C, lr, maxIter }?: {
+        C?: number;
+        lr?: number;
+        maxIter?: number;
+    });
+    fit(X: MLTensor, y: MLTensor): this;
+    decisionLogits(X: MLTensor): MLTensor;
+    predict(X: MLTensor): MLTensor;
+    score(X: MLTensor, y: MLTensor): number;
+}
+
+declare class PCA {
+    nComponents: number | null;
+    components_: MLTensor | null;
+    mean_: MLTensor | null;
+    explainedVariance_: number[] | null;
+    explainedVarianceRatio_: number[] | null;
+    private _nc?;
+    constructor({ nComponents }?: {
+        nComponents?: number | null;
+    });
+    fit(X: MLTensor): this;
+    transform(X: MLTensor): MLTensor;
+    fit_transform(X: MLTensor): MLTensor;
+    inverse_transform(Xr: MLTensor): MLTensor;
+}
+
+declare class KMeans {
+    nClusters: number;
+    maxIter: number;
+    nInit: number;
+    randomState: number;
+    clusterCenters_: MLTensor | null;
+    labels_: MLTensor | null;
+    inertia_: number | null;
+    constructor({ nClusters, maxIter, nInit, randomState }?: {
+        nClusters?: number;
+        maxIter?: number;
+        nInit?: number;
+        randomState?: number;
+    });
+    fit(X: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+    fit_predict(X: MLTensor): MLTensor | null;
+}
+
+declare class BaseKNN {
+    nNeighbors: number;
+    protected _classify: boolean;
+    protected _X: MLTensor | null;
+    protected _y: MLTensor | null;
+    constructor(nNeighbors: number, classify: boolean);
+    fit(X: MLTensor, y: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+}
+declare class KNeighborsClassifier extends BaseKNN {
+    constructor({ nNeighbors }?: {
+        nNeighbors?: number | undefined;
+    });
+    score(X: MLTensor, y: MLTensor): number;
+}
+declare class KNeighborsRegressor extends BaseKNN {
+    constructor({ nNeighbors }?: {
+        nNeighbors?: number | undefined;
+    });
+    score(X: MLTensor, y: MLTensor): number;
+}
+
+declare class GaussianNB {
+    means_: MLTensor | null;
+    variances_: MLTensor | null;
+    priors_: MLTensor | null;
+    classes_: MLTensor | null;
+    constructor();
+    fit(X: MLTensor, y: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+    score(X: MLTensor, y: MLTensor): number;
+}
+
+type TreeParams = {
+    maxDepth?: number;
+    minSamplesSplit?: number;
+    minSamplesLeaf?: number;
+    maxFeatures?: number;
+    randomState?: number;
+};
+type ResolvedTreeParams = Required<Pick<TreeParams, 'maxDepth' | 'minSamplesSplit' | 'minSamplesLeaf' | 'maxFeatures'>>;
+type TreeNodes = [MLTensor, MLTensor, MLTensor, MLTensor, MLTensor];
+declare class BaseTree {
+    maxDepth: number;
+    minSamplesSplit: number;
+    minSamplesLeaf: number;
+    maxFeatures: number;
+    randomState: number;
+    protected _classify: boolean;
+    protected _nodes: TreeNodes | null;
+    constructor(params: TreeParams, classify: boolean);
+    fit(X: MLTensor, y: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+}
+declare class DecisionTreeRegressor extends BaseTree {
+    constructor(params?: TreeParams);
+    score(X: MLTensor, y: MLTensor): number;
+}
+declare class DecisionTreeClassifier extends BaseTree {
+    constructor(params?: TreeParams);
+    score(X: MLTensor, y: MLTensor): number;
+}
+declare class BaseForest {
+    nEstimators: number;
+    maxDepth: number;
+    minSamplesSplit: number;
+    minSamplesLeaf: number;
+    maxFeatures: number;
+    randomState: number;
+    protected _classify: boolean;
+    protected _trees: TreeNodes[];
+    constructor(params: TreeParams & {
+        nEstimators?: number;
+    }, classify: boolean);
+    fit(X: MLTensor, y: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+}
+declare class RandomForestRegressor extends BaseForest {
+    constructor(params?: TreeParams & {
+        nEstimators?: number;
+    });
+    score(X: MLTensor, y: MLTensor): number;
+}
+declare class RandomForestClassifier extends BaseForest {
+    constructor(params?: TreeParams & {
+        nEstimators?: number;
+    });
+    score(X: MLTensor, y: MLTensor): number;
+}
+declare class GradientBoostingRegressor {
+    nEstimators: number;
+    learningRate: number;
+    params: ResolvedTreeParams;
+    randomState: number;
+    init_: number;
+    private _trees;
+    constructor({ nEstimators, learningRate, maxDepth, minSamplesSplit, minSamplesLeaf, randomState }?: TreeParams & {
+        nEstimators?: number;
+        learningRate?: number;
+    });
+    fit(X: MLTensor, y: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+    score(X: MLTensor, y: MLTensor): number;
+}
+declare class GradientBoostingClassifier {
+    nEstimators: number;
+    learningRate: number;
+    params: ResolvedTreeParams;
+    randomState: number;
+    classes_: number[] | null;
+    private _stages;
+    constructor({ nEstimators, learningRate, maxDepth, minSamplesSplit, minSamplesLeaf, randomState }?: TreeParams & {
+        nEstimators?: number;
+        learningRate?: number;
+    });
+    fit(X: MLTensor, y: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+    score(X: MLTensor, y: MLTensor): number;
+}
+
+type SplitOptions = {
+    testSize?: number;
+    shuffle?: boolean;
+    randomState?: number;
+};
+type Fold = {
+    train: number[];
+    test: number[];
+};
+type ScoringFn = (yTrue: MLTensor, yPred: MLTensor) => number;
+type EstimatorFactory<T extends FitPredictEstimator = FitPredictEstimator> = (params?: Record<string, unknown> | null) => T;
+declare function train_test_split(X: MLTensor, y: MLTensor, { testSize, shuffle, randomState }?: SplitOptions): [MLTensor, MLTensor, MLTensor, MLTensor];
+declare class KFold {
+    nSplits: number;
+    shuffle: boolean;
+    randomState: number;
+    constructor({ nSplits, shuffle, randomState }?: {
+        nSplits?: number;
+        shuffle?: boolean;
+        randomState?: number;
+    });
+    split(n: number): Fold[];
+}
+declare class TimeSeriesSplit {
+    nSplits: number;
+    constructor({ nSplits }?: {
+        nSplits?: number;
+    });
+    split(n: number): Fold[];
+}
+declare function cross_val_score(makeEstimator: EstimatorFactory, X: MLTensor, y: MLTensor, { cv, scoring, shuffle, randomState }?: {
+    cv?: number;
+    scoring?: ScoringFn | null;
+    shuffle?: boolean;
+    randomState?: number;
+}): number[];
+declare class GridSearchCV {
+    makeEstimator: EstimatorFactory;
+    paramGrid: Record<string, readonly unknown[]>;
+    cv: number;
+    scoring: ScoringFn | null;
+    bestParams_: Record<string, unknown> | null;
+    bestScore_: number;
+    bestEstimator_: FitPredictEstimator | null;
+    constructor(makeEstimator: EstimatorFactory, paramGrid: Record<string, readonly unknown[]>, { cv, scoring }?: {
+        cv?: number;
+        scoring?: ScoringFn | null;
+    });
+    fit(X: MLTensor, y: MLTensor): this;
+    predict(X: MLTensor): MLTensor;
+}
+
+type index$1_DecisionTreeClassifier = DecisionTreeClassifier;
+declare const index$1_DecisionTreeClassifier: typeof DecisionTreeClassifier;
+type index$1_DecisionTreeRegressor = DecisionTreeRegressor;
+declare const index$1_DecisionTreeRegressor: typeof DecisionTreeRegressor;
+type index$1_ElasticNet = ElasticNet;
+declare const index$1_ElasticNet: typeof ElasticNet;
+type index$1_GaussianNB = GaussianNB;
+declare const index$1_GaussianNB: typeof GaussianNB;
+type index$1_GradientBoostingClassifier = GradientBoostingClassifier;
+declare const index$1_GradientBoostingClassifier: typeof GradientBoostingClassifier;
+type index$1_GradientBoostingRegressor = GradientBoostingRegressor;
+declare const index$1_GradientBoostingRegressor: typeof GradientBoostingRegressor;
+type index$1_GridSearchCV = GridSearchCV;
+declare const index$1_GridSearchCV: typeof GridSearchCV;
+type index$1_KFold = KFold;
+declare const index$1_KFold: typeof KFold;
+type index$1_KMeans = KMeans;
+declare const index$1_KMeans: typeof KMeans;
+type index$1_KNeighborsClassifier = KNeighborsClassifier;
+declare const index$1_KNeighborsClassifier: typeof KNeighborsClassifier;
+type index$1_KNeighborsRegressor = KNeighborsRegressor;
+declare const index$1_KNeighborsRegressor: typeof KNeighborsRegressor;
+type index$1_LabelEncoder = LabelEncoder;
+declare const index$1_LabelEncoder: typeof LabelEncoder;
+type index$1_Lasso = Lasso;
+declare const index$1_Lasso: typeof Lasso;
+type index$1_LinearRegression = LinearRegression;
+declare const index$1_LinearRegression: typeof LinearRegression;
+type index$1_LogisticRegression = LogisticRegression;
+declare const index$1_LogisticRegression: typeof LogisticRegression;
+type index$1_MinMaxScaler = MinMaxScaler;
+declare const index$1_MinMaxScaler: typeof MinMaxScaler;
+type index$1_OneHotEncoder = OneHotEncoder;
+declare const index$1_OneHotEncoder: typeof OneHotEncoder;
+type index$1_PCA = PCA;
+declare const index$1_PCA: typeof PCA;
+type index$1_RandomForestClassifier = RandomForestClassifier;
+declare const index$1_RandomForestClassifier: typeof RandomForestClassifier;
+type index$1_RandomForestRegressor = RandomForestRegressor;
+declare const index$1_RandomForestRegressor: typeof RandomForestRegressor;
+type index$1_Ridge = Ridge;
+declare const index$1_Ridge: typeof Ridge;
+type index$1_StandardScaler = StandardScaler;
+declare const index$1_StandardScaler: typeof StandardScaler;
+type index$1_TimeSeriesSplit = TimeSeriesSplit;
+declare const index$1_TimeSeriesSplit: typeof TimeSeriesSplit;
+declare const index$1_accuracy_score: typeof accuracy_score;
+declare const index$1_confusion_matrix: typeof confusion_matrix;
+declare const index$1_cross_val_score: typeof cross_val_score;
+declare const index$1_mean_absolute_error: typeof mean_absolute_error;
+declare const index$1_mean_squared_error: typeof mean_squared_error;
+declare const index$1_r2_score: typeof r2_score;
+declare const index$1_train_test_split: typeof train_test_split;
+declare namespace index$1 {
+  export { index$1_DecisionTreeClassifier as DecisionTreeClassifier, index$1_DecisionTreeRegressor as DecisionTreeRegressor, index$1_ElasticNet as ElasticNet, index$1_GaussianNB as GaussianNB, index$1_GradientBoostingClassifier as GradientBoostingClassifier, index$1_GradientBoostingRegressor as GradientBoostingRegressor, index$1_GridSearchCV as GridSearchCV, index$1_KFold as KFold, index$1_KMeans as KMeans, index$1_KNeighborsClassifier as KNeighborsClassifier, index$1_KNeighborsRegressor as KNeighborsRegressor, index$1_LabelEncoder as LabelEncoder, index$1_Lasso as Lasso, index$1_LinearRegression as LinearRegression, index$1_LogisticRegression as LogisticRegression, index$1_MinMaxScaler as MinMaxScaler, index$1_OneHotEncoder as OneHotEncoder, index$1_PCA as PCA, index$1_RandomForestClassifier as RandomForestClassifier, index$1_RandomForestRegressor as RandomForestRegressor, index$1_Ridge as Ridge, index$1_StandardScaler as StandardScaler, index$1_TimeSeriesSplit as TimeSeriesSplit, index$1_accuracy_score as accuracy_score, index$1_confusion_matrix as confusion_matrix, index$1_cross_val_score as cross_val_score, index$1_mean_absolute_error as mean_absolute_error, index$1_mean_squared_error as mean_squared_error, index$1_r2_score as r2_score, index$1_train_test_split as train_test_split };
+}
+
+type NumericVectorInput = Tensor | number | ArrayLike<number>;
+type NumericMatrixInput = Tensor | ReadonlyArray<ArrayLike<number>>;
+type NumericElementInput = Tensor | number;
+type NumericArrayInput = Tensor | ArrayLike<number>;
+type NumericShape = number | readonly number[];
+type ScalarFn$1 = (x: number) => number;
+type VectorFn = (x: number[]) => number;
+type GradientFn = (x: number[]) => number[];
+type ResidualFn = (x: number[]) => number[];
+type JacobianFn = (x: number[], m: number) => number[][];
+type Bounds = ReadonlyArray<readonly [number, number] | null | undefined>;
+type TestResult = {
+    statistic: number;
+    pvalue: number;
+    df?: number;
+};
+
+type DistOptions = {
+    loc?: number;
+    scale?: number;
+    df?: number;
+    d1?: number;
+    d2?: number;
+    refineSteps?: number;
+    tol?: number;
+    lowerLimit?: number;
+};
+declare const normal: {
+    cdf: (x: NumericElementInput, opts?: DistOptions) => number | Tensor;
+    pdf: (x: NumericElementInput, opts?: DistOptions) => number | Tensor;
+    ppf: (p: NumericElementInput, opts?: DistOptions) => number | Tensor;
+};
+declare const studentT: {
+    cdf: (x: NumericElementInput, df?: number, opts?: DistOptions) => number | Tensor;
+    pdf: (x: NumericElementInput, df?: number, opts?: DistOptions) => number | Tensor;
+    ppf: (p: NumericElementInput, df?: number, opts?: DistOptions) => number | Tensor;
+};
+declare const chi2: {
+    cdf: (x: NumericElementInput, df?: number, opts?: DistOptions) => number | Tensor;
+    pdf: (x: NumericElementInput, df?: number, opts?: DistOptions) => number | Tensor;
+    ppf: (p: NumericElementInput, df?: number, opts?: DistOptions) => number | Tensor;
+};
+declare const fisherF: {
+    cdf: (x: NumericElementInput, d1?: number, d2?: number, opts?: DistOptions) => number | Tensor;
+    pdf: (x: NumericElementInput, d1?: number, d2?: number, opts?: DistOptions) => number | Tensor;
+    ppf: (p: NumericElementInput, d1?: number, d2?: number, opts?: DistOptions) => number | Tensor;
+};
+
+declare function erfScalar(x: number): number;
+declare function erfcScalar(x: number): number;
+declare function lgammaScalar(x: number): number;
+declare function gammaScalar(x: number): number;
+declare function digammaScalar(x: number): number;
+
+type PpfOptions = {
+    refineSteps?: number;
+};
+declare function lowerGammaRegularized(a: number, x: number): number;
+declare function betaRegularized(a: number, b: number, x: number): number;
+declare function normalCdfScalar(z: number): number;
+declare function normalPdfScalar(z: number): number;
+declare function normalPpfScalar(p: number, opts?: PpfOptions): number;
+
+type NelderMeadOptions = {
+    maxIter?: number;
+    tol?: number;
+    initialStep?: number;
+    zeroStep?: number;
+    alpha?: number;
+    gamma?: number;
+    rho?: number;
+    sigma?: number;
+};
+type MinimizeResult$4 = {
+    point: number[];
+    value: number;
+    iterations: number;
+    converged: boolean;
+};
+declare function nelderMead(f: VectorFn, x0: readonly number[], opts?: NelderMeadOptions): MinimizeResult$4;
+
+type DifferentialEvolutionOptions = {
+    seed?: number;
+    populationSize?: number;
+    mutation?: number;
+    recombination?: number;
+    maxIter?: number;
+    tol?: number;
+};
+type MinimizeResult$3 = {
+    point: number[];
+    value: number;
+    iterations: number;
+    converged: boolean;
+};
+declare function differentialEvolution(f: VectorFn, bounds: ReadonlyArray<readonly [number, number]>, opts?: DifferentialEvolutionOptions): MinimizeResult$3;
+
+type LbfgsOptions = {
+    memory?: number;
+    maxIter?: number;
+    gtol?: number;
+    ftol?: number;
+    step?: number;
+    gradient?: GradientFn;
+};
+type MinimizeResult$2 = {
+    point: number[];
+    value: number;
+    iterations: number;
+    converged: boolean;
+};
+declare function lbfgs(f: VectorFn, x0: readonly number[], opts?: LbfgsOptions): MinimizeResult$2;
+declare function lbfgsB(f: VectorFn, x0: readonly number[], bounds: Bounds, opts?: LbfgsOptions): MinimizeResult$2;
+
+type LMOptions = {
+    maxIter?: number;
+    tol?: number;
+    step?: number;
+    jacobian?: JacobianFn;
+    lambda?: number;
+};
+type MinimizeResult$1 = {
+    point: number[];
+    value: number;
+    iterations: number;
+    converged: boolean;
+};
+declare function levenbergMarquardt(residual: ResidualFn, x0: readonly number[], opts?: LMOptions): MinimizeResult$1;
+
+type MinimizeResult = {
+    point: number[];
+    value: number;
+    iterations: number;
+    converged: boolean;
+};
+type InnerMinimizer = (f: VectorFn, x0: readonly number[], opts?: object) => MinimizeResult;
+type ConstrainedOptions = {
+    bounds?: Bounds | null;
+    inequalities?: VectorFn[];
+    equalities?: VectorFn[];
+    outerIter?: number;
+    ctol?: number;
+    penaltyGrowth?: number;
+    inner?: InnerMinimizer;
+    innerOpts?: object;
+    penalty?: number;
+};
+declare function constrainedMinimize(f: VectorFn, x0: readonly number[], opts?: ConstrainedOptions): MinimizeResult;
+
+type RootOptions = {
+    tol?: number;
+    maxIter?: number;
+    step?: number;
+    derivative?: (x: number) => number;
+};
+type RootResult = {
+    root: number;
+    iterations: number;
+    converged: boolean;
+};
+declare function bisect(f: (x: number) => number, a: number, b: number, opts?: RootOptions): RootResult;
+declare function newton(f: (x: number) => number, x0: number, opts?: RootOptions): RootResult;
+declare function brentq(f: (x: number) => number, a: number, b: number, opts?: RootOptions): RootResult;
+
+type IntegrateOptions = {
+    n?: number;
+    tol?: number;
+    maxDepth?: number;
+};
+type ScalarFn = (x: number) => number;
+declare function trapezoid(f: ScalarFn, a: number, b: number, opts?: IntegrateOptions): number;
+declare function simpson(f: ScalarFn, a: number, b: number, opts?: IntegrateOptions): number;
+declare function quadrature(f: ScalarFn, a: number, b: number, opts?: IntegrateOptions): number;
+
+declare function linearInterp(xs: readonly number[], ys: readonly number[], xq: number): number;
+declare function linearInterp(xs: readonly number[], ys: readonly number[], xq: readonly number[]): number[];
+type CubicSpline = {
+    xs: readonly number[];
+    ys: readonly number[];
+    coefficients: number[];
+    evaluate: {
+        (xq: number): number;
+        (xq: readonly number[]): number[];
+    };
+};
+declare function cubicSpline(xs: readonly number[], ys: readonly number[]): CubicSpline;
+
+declare const fft: (x: Tensor) => Tensor;
+declare const ifft: (x: Tensor) => Tensor;
+
+type MeanOptions = {
+    popmean?: number;
+};
+type TTestOptions = MeanOptions & {
+    equalVar?: boolean;
+};
+type Chi2Options = {
+    ddof?: number;
+};
+type KsOptions = {
+    loc?: number;
+    scale?: number;
+};
+declare function tTest1Samp(x: NumericVectorInput, opts?: MeanOptions): TestResult;
+declare function tTestInd(x: NumericVectorInput, y: NumericVectorInput, opts?: TTestOptions): TestResult;
+declare function tTestPaired(x: NumericVectorInput, y: NumericVectorInput, opts?: MeanOptions): TestResult;
+declare function chi2Gof(observed: NumericVectorInput, expected?: NumericVectorInput | null, opts?: Chi2Options): TestResult;
+declare function chi2Independence(table: NumericMatrixInput): TestResult;
+declare function ksTest1Samp(x: NumericVectorInput, cdf?: ScalarFn$1, opts?: KsOptions): Omit<TestResult, 'df'>;
+declare function ksTest2Samp(x: NumericVectorInput, y: NumericVectorInput): Omit<TestResult, 'df'>;
+declare function jarqueBera(x: NumericVectorInput): TestResult;
+declare function dagostinoK2(x: NumericVectorInput): TestResult;
+declare function andersonDarling(x: NumericVectorInput): Omit<TestResult, 'df'>;
+declare function mannWhitneyU(x: NumericVectorInput, y: NumericVectorInput): Omit<TestResult, 'df'>;
+
+type AcfOptions = {
+    nlags?: number;
+};
+type LjungBoxOptions = {
+    lags?: number;
+    modelDf?: number;
+};
+type PeriodogramOptions = {
+    detrend?: boolean;
+};
+declare function acf(x: NumericVectorInput, opts?: AcfOptions): Tensor;
+declare function pacf(x: NumericVectorInput, opts?: AcfOptions): Tensor;
+declare function ljungBox(x: NumericVectorInput, opts?: LjungBoxOptions): TestResult;
+declare function durbinWatson(x: NumericVectorInput): number;
+declare function periodogram(x: NumericVectorInput, opts?: PeriodogramOptions): Tensor;
+
+type ConvMode = 'full' | 'same' | 'valid';
+type ModeOptions = {
+    mode?: ConvMode;
+};
+type RollingOptions = {
+    ddof?: number;
+};
+declare function convolve(a: NumericVectorInput, b: NumericVectorInput, opts?: ModeOptions): Tensor;
+declare function correlate(a: NumericVectorInput, b: NumericVectorInput, opts?: ModeOptions): Tensor;
+declare function rollingSum(x: NumericVectorInput, window: number): Tensor;
+declare function rollingMean(x: NumericVectorInput, window: number): Tensor;
+declare function rollingStd(x: NumericVectorInput, window: number, opts?: RollingOptions): Tensor;
+declare function rollingMin(x: NumericVectorInput, window: number): Tensor;
+declare function rollingMax(x: NumericVectorInput, window: number): Tensor;
+declare function polyfit(x: NumericVectorInput, y: NumericVectorInput, deg: number): Tensor;
+declare function polyval(coeffs: NumericVectorInput, x: number): number;
+declare function polyval(coeffs: NumericVectorInput, x: NumericArrayInput): Tensor;
+declare function polyroots(coeffs: NumericVectorInput): Tensor;
+
+type RandomOptions = TensorDataOptions & {
+    low?: number;
+    high?: number;
+    loc?: number;
+    scale?: number;
+    df?: number;
+};
+declare class Generator$1 {
+    private readonly _next;
+    constructor(seed?: number);
+    _uniformPositive(): number;
+    _normalDraw(): number;
+    _gammaDraw(a: number): number;
+    _fill(shape: NumericShape, opts: TensorDataOptions, draw: () => number): Tensor;
+    uniform(shape: NumericShape, opts?: RandomOptions): Tensor;
+    normal(shape: NumericShape, opts?: RandomOptions): Tensor;
+    standardT(shape: NumericShape, opts?: RandomOptions): Tensor;
+    chi2(shape: NumericShape, opts?: RandomOptions): Tensor;
+    exponential(shape: NumericShape, opts?: RandomOptions): Tensor;
+    multivariateNormal(mean: NumericVectorInput, cov: NumericMatrixInput, n?: number, opts?: TensorDataOptions): Tensor;
+}
+
+declare const index_acf: typeof acf;
+declare const index_andersonDarling: typeof andersonDarling;
+declare const index_betaRegularized: typeof betaRegularized;
+declare const index_bisect: typeof bisect;
+declare const index_brentq: typeof brentq;
+declare const index_chi2: typeof chi2;
+declare const index_chi2Gof: typeof chi2Gof;
+declare const index_chi2Independence: typeof chi2Independence;
+declare const index_constrainedMinimize: typeof constrainedMinimize;
+declare const index_convolve: typeof convolve;
+declare const index_correlate: typeof correlate;
+declare const index_cubicSpline: typeof cubicSpline;
+declare const index_dagostinoK2: typeof dagostinoK2;
+declare const index_differentialEvolution: typeof differentialEvolution;
+declare const index_digammaScalar: typeof digammaScalar;
+declare const index_durbinWatson: typeof durbinWatson;
+declare const index_erfScalar: typeof erfScalar;
+declare const index_erfcScalar: typeof erfcScalar;
+declare const index_fft: typeof fft;
+declare const index_fisherF: typeof fisherF;
+declare const index_gammaScalar: typeof gammaScalar;
+declare const index_ifft: typeof ifft;
+declare const index_jarqueBera: typeof jarqueBera;
+declare const index_ksTest1Samp: typeof ksTest1Samp;
+declare const index_ksTest2Samp: typeof ksTest2Samp;
+declare const index_lbfgs: typeof lbfgs;
+declare const index_lbfgsB: typeof lbfgsB;
+declare const index_levenbergMarquardt: typeof levenbergMarquardt;
+declare const index_lgammaScalar: typeof lgammaScalar;
+declare const index_linearInterp: typeof linearInterp;
+declare const index_ljungBox: typeof ljungBox;
+declare const index_lowerGammaRegularized: typeof lowerGammaRegularized;
+declare const index_mannWhitneyU: typeof mannWhitneyU;
+declare const index_nelderMead: typeof nelderMead;
+declare const index_newton: typeof newton;
+declare const index_normal: typeof normal;
+declare const index_normalCdfScalar: typeof normalCdfScalar;
+declare const index_normalPdfScalar: typeof normalPdfScalar;
+declare const index_normalPpfScalar: typeof normalPpfScalar;
+declare const index_pacf: typeof pacf;
+declare const index_periodogram: typeof periodogram;
+declare const index_polyfit: typeof polyfit;
+declare const index_polyroots: typeof polyroots;
+declare const index_polyval: typeof polyval;
+declare const index_qr: typeof qr;
+declare const index_quadrature: typeof quadrature;
+declare const index_rollingMax: typeof rollingMax;
+declare const index_rollingMean: typeof rollingMean;
+declare const index_rollingMin: typeof rollingMin;
+declare const index_rollingStd: typeof rollingStd;
+declare const index_rollingSum: typeof rollingSum;
+declare const index_simpson: typeof simpson;
+declare const index_studentT: typeof studentT;
+declare const index_tTest1Samp: typeof tTest1Samp;
+declare const index_tTestInd: typeof tTestInd;
+declare const index_tTestPaired: typeof tTestPaired;
+declare const index_trapezoid: typeof trapezoid;
+declare namespace index {
+  export { Generator$1 as Generator, index_acf as acf, index_andersonDarling as andersonDarling, index_betaRegularized as betaRegularized, index_bisect as bisect, index_brentq as brentq, index_chi2 as chi2, index_chi2Gof as chi2Gof, index_chi2Independence as chi2Independence, index_constrainedMinimize as constrainedMinimize, index_convolve as convolve, index_correlate as correlate, index_cubicSpline as cubicSpline, index_dagostinoK2 as dagostinoK2, index_differentialEvolution as differentialEvolution, index_digammaScalar as digammaScalar, index_durbinWatson as durbinWatson, index_erfScalar as erfScalar, index_erfcScalar as erfcScalar, index_fft as fft, index_fisherF as fisherF, index_gammaScalar as gammaScalar, index_ifft as ifft, index_jarqueBera as jarqueBera, index_ksTest1Samp as ksTest1Samp, index_ksTest2Samp as ksTest2Samp, index_lbfgs as lbfgs, index_lbfgsB as lbfgsB, index_levenbergMarquardt as levenbergMarquardt, index_lgammaScalar as lgammaScalar, index_linearInterp as linearInterp, index_ljungBox as ljungBox, index_lowerGammaRegularized as lowerGammaRegularized, index_mannWhitneyU as mannWhitneyU, index_nelderMead as nelderMead, index_newton as newton, index_normal as normal, index_normalCdfScalar as normalCdfScalar, index_normalPdfScalar as normalPdfScalar, index_normalPpfScalar as normalPpfScalar, index_pacf as pacf, index_periodogram as periodogram, index_polyfit as polyfit, index_polyroots as polyroots, index_polyval as polyval, index_qr as qr, index_quadrature as quadrature, index_rollingMax as rollingMax, index_rollingMean as rollingMean, index_rollingMin as rollingMin, index_rollingStd as rollingStd, index_rollingSum as rollingSum, index_simpson as simpson, index_studentT as studentT, index_tTest1Samp as tTest1Samp, index_tTestInd as tTestInd, index_tTestPaired as tTestPaired, index_trapezoid as trapezoid };
+}
+
+export { Accuracy, Adam, AdamW, AdaptiveAvgPool2d, AvgPool2d, BCELoss, BatchNorm1d, BatchNorm2d, BatchSampler, CPUTarget, CPU_DEVICE, CSVLogger, CUDATarget, Callback, ConfusionMatrix, ConsoleLogger, Conv1d, Conv2d, CosineAnnealingLR, CrossEntropyLoss, DataLoader, Dataset, Dropout, ELU, EarlyStopping, Embedding, F, F1Score, Flatten, GELU, GPU_DEVICE, GRU, GRUCell, GradMode, GradientAccumulationScheduler, LRScheduler, LSTM, LSTMCell, LayerNorm, LeakyReLU, LearningRateMonitor, LightningModule, Linear, LogSoftmax, Logger, MSELoss, MapDataset, MaxPool2d, MeanMetric, Metric, MetricCollection, ModelCheckpoint, Module, ModuleDict, ModuleList, MultiheadAttention, NLLLoss, Optimizer, Parameter, PositionalEncoding, Precision, ProgressCallback, RandomSampler, ReLU, Recall, ReduceLROnPlateau, SGD, Sampler, Sequential, SequentialSampler, SiLU, Sigmoid, Softmax, StepLR, SumMetric, SymbolicTensor, Tanh, Tensor, TensorDataset, Timer, Tokenizer, TraceLevel, Trainer, Transformer, TransformerDecoder, TransformerDecoderLayer, TransformerEncoder, TransformerEncoderLayer, Vocab, WASM_DEVICE, WEBGPU_DEVICE, WasmTarget, WebGPUTarget, abs, add, applyCheckpoint, arange, argmax, argmin, argsort, broadcast_in_dim, cat, ceil, chunk, clamp, clipGradNorm_, clipGradValue_, clone, compile, compileWithBackward, contiguous, cos, cumsum, index$5 as data, defaultCollate, dispatcher, div, dot, empty, emptyLike, enableGrad, eq, erf, erfc, exp, expand, eye, flip, floor, flushWebGPUEager, fromBuffer, full, fullLike, gamma, gather, ge, gelu$1 as gelu, getDefaultDevice, gt, index_select, init, le, lgamma, index$2 as lightning, linalg, linspace, loadCheckpoint, log, log_softmax$1 as log_softmax, lt, matmul, max, maximum, mean, fs as memfs, min, minimum, index$1 as ml, mul, narrow, ne, neg, index$6 as nn, noGrad, index as numeric, one_hot, ones, onesLike, ops, index$3 as optim, pad, permute, pow, preloadCudaRuntime, preloadWebGPU, printModule, prod, randn, randnLike, randperm, relu$1 as relu, repeat, reshape, roll, rsqrt, scalar, scan, scatter, scatter_add, select, serializeCheckpoint, setDefaultDevice, sigmoid$1 as sigmoid, sign, silu$1 as silu, sin, slice, softmax$1 as softmax, sort, split, sqrt, squeeze, stack, sub, sum, tanh$1 as tanh, tensor, tile, index$4 as tokenizer, topk, trace, transpose, unsqueeze, where, zeros, zerosLike };