nodepyx 1.0.0

package/src/types/stubs/torch.d.ts

@@ -0,0 +1,694 @@
+// =============================================================
+// nodepyx — Pre-built TypeScript stub for PyTorch (torch)
+// Version: 2.x
+// Source: https://pytorch.org
+// =============================================================
+
+import type { PyProxy } from 'nodepyx';
+
+declare module 'nodepyx/torch' {
+
+  export type Tensor = Float32Array | Float64Array | Int32Array | BigInt64Array | Uint8Array;
+  export type Device = 'cpu' | 'cuda' | 'mps' | string;
+  export type DType = 'float32' | 'float64' | 'int32' | 'int64' | 'bool' | 'uint8' | string;
+
+  // ── torch.Tensor class ────────────────────────────────────────────────────
+
+  export class PyTorchTensor {
+    // Shape
+    readonly shape: Promise<number[]>;
+    readonly size: Promise<number[]>;
+    readonly ndim: Promise<number>;
+    readonly numel: Promise<number>;
+    readonly dtype: Promise<string>;
+    readonly device: Promise<string>;
+    readonly requires_grad: Promise<boolean>;
+    readonly grad: Promise<PyTorchTensor | null>;
+    readonly data: Promise<PyTorchTensor>;
+    readonly T: Promise<PyTorchTensor>;
+    readonly is_leaf: Promise<boolean>;
+
+    // Conversion
+    numpy(): Promise<Tensor>;
+    tolist(): Promise<number | number[] | boolean[]>;
+    item(): Promise<number | boolean>;
+    cpu(): Promise<PyTorchTensor>;
+    cuda(device?: string | number): Promise<PyTorchTensor>;
+    to(device: Device | Record<string, unknown>, dtype?: string): Promise<PyTorchTensor>;
+    float(): Promise<PyTorchTensor>;
+    double(): Promise<PyTorchTensor>;
+    int(): Promise<PyTorchTensor>;
+    long(): Promise<PyTorchTensor>;
+    bool(): Promise<PyTorchTensor>;
+    half(): Promise<PyTorchTensor>;
+    clone(): Promise<PyTorchTensor>;
+    detach(): Promise<PyTorchTensor>;
+    contiguous(memory_format?: PyProxy): Promise<PyTorchTensor>;
+
+    // Shape operations
+    view(...shape: number[]): Promise<PyTorchTensor>;
+    reshape(shape: number[]): Promise<PyTorchTensor>;
+    squeeze(dim?: number): Promise<PyTorchTensor>;
+    unsqueeze(dim: number): Promise<PyTorchTensor>;
+    expand(sizes: number[]): Promise<PyTorchTensor>;
+    expand_as(other: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+    transpose(dim0: number, dim1: number): Promise<PyTorchTensor>;
+    permute(...dims: number[]): Promise<PyTorchTensor>;
+    flatten(start_dim?: number, end_dim?: number): Promise<PyTorchTensor>;
+    repeat(repeats: number[]): Promise<PyTorchTensor>;
+    t(): Promise<PyTorchTensor>;
+    unbind(dim?: number): Promise<PyTorchTensor[]>;
+    chunk(chunks: number, dim?: number): Promise<PyTorchTensor[]>;
+    split(split_size: number | number[], dim?: number): Promise<PyTorchTensor[]>;
+    select(dim: number, index: number): Promise<PyTorchTensor>;
+    narrow(dim: number, start: number, length: number): Promise<PyTorchTensor>;
+    index_select(dim: number, index: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+    gather(dim: number, index: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+    scatter_(dim: number, index: PyTorchTensor | PyProxy, src: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+    masked_select(mask: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+    masked_fill_(mask: PyTorchTensor | PyProxy, value: number): Promise<PyTorchTensor>;
+    roll(shifts: number | number[], dims?: number | number[]): Promise<PyTorchTensor>;
+    flip(dims: number | number[]): Promise<PyTorchTensor>;
+
+    // Arithmetic
+    add(other: PyTorchTensor | PyProxy | number, alpha?: number): Promise<PyTorchTensor>;
+    sub(other: PyTorchTensor | PyProxy | number, alpha?: number): Promise<PyTorchTensor>;
+    mul(other: PyTorchTensor | PyProxy | number): Promise<PyTorchTensor>;
+    div(other: PyTorchTensor | PyProxy | number, rounding_mode?: string | null): Promise<PyTorchTensor>;
+    pow(exponent: PyTorchTensor | PyProxy | number): Promise<PyTorchTensor>;
+    matmul(other: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+    mm(other: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+    bmm(other: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+    dot(other: PyTorchTensor | PyProxy): Promise<number | PyTorchTensor>;
+    neg(): Promise<PyTorchTensor>;
+    abs(): Promise<PyTorchTensor>;
+    sign(): Promise<PyTorchTensor>;
+    sqrt(): Promise<PyTorchTensor>;
+    rsqrt(): Promise<PyTorchTensor>;
+    exp(): Promise<PyTorchTensor>;
+    log(): Promise<PyTorchTensor>;
+    log2(): Promise<PyTorchTensor>;
+    log10(): Promise<PyTorchTensor>;
+    log1p(): Promise<PyTorchTensor>;
+    floor(): Promise<PyTorchTensor>;
+    ceil(): Promise<PyTorchTensor>;
+    round(): Promise<PyTorchTensor>;
+    trunc(): Promise<PyTorchTensor>;
+    frac(): Promise<PyTorchTensor>;
+    sigmoid(): Promise<PyTorchTensor>;
+    tanh(): Promise<PyTorchTensor>;
+    sin(): Promise<PyTorchTensor>;
+    cos(): Promise<PyTorchTensor>;
+    tan(): Promise<PyTorchTensor>;
+    asin(): Promise<PyTorchTensor>;
+    acos(): Promise<PyTorchTensor>;
+    atan(): Promise<PyTorchTensor>;
+    atan2(other: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+
+    // Reduction
+    sum(dim?: number | number[], keepdim?: boolean): Promise<PyTorchTensor | number>;
+    mean(dim?: number | number[], keepdim?: boolean): Promise<PyTorchTensor | number>;
+    var(dim?: number | number[], unbiased?: boolean, keepdim?: boolean): Promise<PyTorchTensor | number>;
+    std(dim?: number | number[], unbiased?: boolean, keepdim?: boolean): Promise<PyTorchTensor | number>;
+    min(dim?: number, keepdim?: boolean): Promise<PyTorchTensor | number | [PyTorchTensor, PyTorchTensor]>;
+    max(dim?: number, keepdim?: boolean): Promise<PyTorchTensor | number | [PyTorchTensor, PyTorchTensor]>;
+    argmin(dim?: number, keepdim?: boolean): Promise<PyTorchTensor | number>;
+    argmax(dim?: number, keepdim?: boolean): Promise<PyTorchTensor | number>;
+    cumsum(dim: number, dtype?: string): Promise<PyTorchTensor>;
+    cumprod(dim: number, dtype?: string): Promise<PyTorchTensor>;
+    prod(dim?: number, keepdim?: boolean): Promise<PyTorchTensor | number>;
+    norm(p?: number | string, dim?: number, keepdim?: boolean): Promise<PyTorchTensor | number>;
+    any(dim?: number, keepdim?: boolean): Promise<boolean | PyTorchTensor>;
+    all(dim?: number, keepdim?: boolean): Promise<boolean | PyTorchTensor>;
+    median(dim?: number, keepdim?: boolean): Promise<PyTorchTensor | number | [PyTorchTensor, PyTorchTensor]>;
+    mode(dim?: number, keepdim?: boolean): Promise<[PyTorchTensor, PyTorchTensor]>;
+    sort(dim?: number, descending?: boolean): Promise<[PyTorchTensor, PyTorchTensor]>;
+    topk(k: number, dim?: number, largest?: boolean, sorted?: boolean): Promise<[PyTorchTensor, PyTorchTensor]>;
+    unique(sorted?: boolean, return_inverse?: boolean, return_counts?: boolean, dim?: number): Promise<PyTorchTensor | [PyTorchTensor, PyTorchTensor, PyTorchTensor]>;
+
+    // Comparison
+    eq(other: PyTorchTensor | PyProxy | number): Promise<PyTorchTensor>;
+    ne(other: PyTorchTensor | PyProxy | number): Promise<PyTorchTensor>;
+    lt(other: PyTorchTensor | PyProxy | number): Promise<PyTorchTensor>;
+    le(other: PyTorchTensor | PyProxy | number): Promise<PyTorchTensor>;
+    gt(other: PyTorchTensor | PyProxy | number): Promise<PyTorchTensor>;
+    ge(other: PyTorchTensor | PyProxy | number): Promise<PyTorchTensor>;
+    equal(other: PyTorchTensor | PyProxy): Promise<boolean>;
+    isnan(): Promise<PyTorchTensor>;
+    isinf(): Promise<PyTorchTensor>;
+    isfinite(): Promise<PyTorchTensor>;
+    allclose(other: PyTorchTensor | PyProxy, rtol?: number, atol?: number): Promise<boolean>;
+
+    // Gradient
+    backward(gradient?: PyTorchTensor | PyProxy | null, retain_graph?: boolean, create_graph?: boolean): Promise<void>;
+    zero_(): Promise<PyTorchTensor>;
+    fill_(value: number): Promise<PyTorchTensor>;
+    copy_(src: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+    requires_grad_(requires_grad?: boolean): Promise<PyTorchTensor>;
+    retain_grad(): Promise<void>;
+
+    __len__(): Promise<number>;
+    __str__(): Promise<string>;
+    [key: string]: unknown;
+  }
+
+  // ── Tensor creation ────────────────────────────────────────────────────────
+
+  export function tensor(data: unknown, dtype?: string, device?: Device, requires_grad?: boolean): Promise<PyTorchTensor>;
+  export function zeros(size: number[], dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function zeros_like(input: PyTorchTensor | PyProxy, dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function ones(size: number[], dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function ones_like(input: PyTorchTensor | PyProxy, dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function empty(size: number[], dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function empty_like(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function full(size: number[], fill_value: number, dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function full_like(input: PyTorchTensor | PyProxy, fill_value: number): Promise<PyTorchTensor>;
+  export function eye(n: number, m?: number, dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function arange(start: number, end?: number, step?: number, dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function linspace(start: number, end: number, steps: number, dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function logspace(start: number, end: number, steps: number, base?: number, dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function rand(size: number[], dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function rand_like(input: PyTorchTensor | PyProxy, dtype?: string): Promise<PyTorchTensor>;
+  export function randn(size: number[], dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function randn_like(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function randint(low: number, high: number, size: number[], dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function randperm(n: number, dtype?: string, device?: Device): Promise<PyTorchTensor>;
+  export function from_numpy(ndarray: PyProxy): Promise<PyTorchTensor>;
+  export function frombuffer(buffer: ArrayBuffer, dtype?: string): Promise<PyTorchTensor>;
+  export function as_tensor(data: unknown, dtype?: string, device?: Device): Promise<PyTorchTensor>;
+
+  // ── Tensor operations ─────────────────────────────────────────────────────
+
+  export function cat(tensors: (PyTorchTensor | PyProxy)[], dim?: number): Promise<PyTorchTensor>;
+  export function stack(tensors: (PyTorchTensor | PyProxy)[], dim?: number): Promise<PyTorchTensor>;
+  export function chunk(input: PyTorchTensor | PyProxy, chunks: number, dim?: number): Promise<PyTorchTensor[]>;
+  export function split(tensor: PyTorchTensor | PyProxy, split_size: number | number[], dim?: number): Promise<PyTorchTensor[]>;
+  export function unbind(input: PyTorchTensor | PyProxy, dim?: number): Promise<PyTorchTensor[]>;
+  export function squeeze(input: PyTorchTensor | PyProxy, dim?: number): Promise<PyTorchTensor>;
+  export function unsqueeze(input: PyTorchTensor | PyProxy, dim: number): Promise<PyTorchTensor>;
+  export function reshape(input: PyTorchTensor | PyProxy, shape: number[]): Promise<PyTorchTensor>;
+  export function flatten(input: PyTorchTensor | PyProxy, start_dim?: number, end_dim?: number): Promise<PyTorchTensor>;
+  export function transpose(input: PyTorchTensor | PyProxy, dim0: number, dim1: number): Promise<PyTorchTensor>;
+  export function permute(input: PyTorchTensor | PyProxy, dims: number[]): Promise<PyTorchTensor>;
+  export function matmul(input: PyTorchTensor | PyProxy, other: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function mm(input: PyTorchTensor | PyProxy, mat2: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function bmm(input: PyTorchTensor | PyProxy, mat2: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function einsum(equation: string, ...operands: (PyTorchTensor | PyProxy)[]): Promise<PyTorchTensor>;
+  export function dot(input: PyTorchTensor | PyProxy, other: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function mv(input: PyTorchTensor | PyProxy, vec: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function outer(input: PyTorchTensor | PyProxy, vec2: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function cross(input: PyTorchTensor | PyProxy, other: PyTorchTensor | PyProxy, dim?: number): Promise<PyTorchTensor>;
+
+  // Math
+  export function abs(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function sqrt(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function exp(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function log(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function sin(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function cos(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function tanh(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function sigmoid(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function relu(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function clamp(input: PyTorchTensor | PyProxy, min?: number, max?: number): Promise<PyTorchTensor>;
+  export function round(input: PyTorchTensor | PyProxy, decimals?: number): Promise<PyTorchTensor>;
+  export function ceil(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function floor(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function sign(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+
+  // Reduction
+  export function sum(input: PyTorchTensor | PyProxy, dim?: number | number[], keepdim?: boolean): Promise<PyTorchTensor | number>;
+  export function mean(input: PyTorchTensor | PyProxy, dim?: number | number[], keepdim?: boolean): Promise<PyTorchTensor | number>;
+  export function std(input: PyTorchTensor | PyProxy, dim?: number, unbiased?: boolean): Promise<PyTorchTensor | number>;
+  export function var_(input: PyTorchTensor | PyProxy, dim?: number, unbiased?: boolean): Promise<PyTorchTensor | number>;
+  export function min(input: PyTorchTensor | PyProxy, dim?: number, keepdim?: boolean): Promise<PyTorchTensor | number | [PyTorchTensor, PyTorchTensor]>;
+  export function max(input: PyTorchTensor | PyProxy, dim?: number, keepdim?: boolean): Promise<PyTorchTensor | number | [PyTorchTensor, PyTorchTensor]>;
+  export function argmin(input: PyTorchTensor | PyProxy, dim?: number): Promise<PyTorchTensor | number>;
+  export function argmax(input: PyTorchTensor | PyProxy, dim?: number): Promise<PyTorchTensor | number>;
+  export function norm(input: PyTorchTensor | PyProxy, p?: number | string, dim?: number, keepdim?: boolean): Promise<PyTorchTensor | number>;
+  export function sort(input: PyTorchTensor | PyProxy, dim?: number, descending?: boolean): Promise<[PyTorchTensor, PyTorchTensor]>;
+  export function topk(input: PyTorchTensor | PyProxy, k: number, dim?: number, largest?: boolean, sorted?: boolean): Promise<[PyTorchTensor, PyTorchTensor]>;
+  export function unique(input: PyTorchTensor | PyProxy, sorted?: boolean, return_inverse?: boolean): Promise<PyTorchTensor | [PyTorchTensor, PyTorchTensor]>;
+  export function where(condition: PyTorchTensor | PyProxy, x?: PyTorchTensor | PyProxy, y?: PyTorchTensor | PyProxy): Promise<PyTorchTensor | PyTorchTensor[]>;
+  export function nonzero(input: PyTorchTensor | PyProxy, as_tuple?: boolean): Promise<PyTorchTensor | PyTorchTensor[]>;
+
+  // Comparison
+  export function equal(input: PyTorchTensor | PyProxy, other: PyTorchTensor | PyProxy): Promise<boolean>;
+  export function allclose(input: PyTorchTensor | PyProxy, other: PyTorchTensor | PyProxy, rtol?: number, atol?: number): Promise<boolean>;
+  export function isnan(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function isinf(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+  export function isfinite(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+
+  // ── torch.nn ─────────────────────────────────────────────────────────────
+
+  export namespace nn {
+    export class Module {
+      constructor();
+      forward(...args: unknown[]): Promise<PyTorchTensor>;
+      parameters(recurse?: boolean): PyProxy;
+      named_parameters(recurse?: boolean): PyProxy;
+      state_dict(): Promise<Record<string, PyTorchTensor>>;
+      load_state_dict(state_dict: Record<string, PyTorchTensor | PyProxy>, strict?: boolean): Promise<PyProxy>;
+      train(mode?: boolean): Promise<Module>;
+      eval(): Promise<Module>;
+      to(device: Device | Record<string, unknown>): Promise<Module>;
+      cuda(device?: string | number): Promise<Module>;
+      cpu(): Promise<Module>;
+      zero_grad(set_to_none?: boolean): Promise<void>;
+      apply(fn: PyProxy | ((...args: unknown[]) => unknown)): Promise<Module>;
+      children(): PyProxy;
+      modules(): PyProxy;
+      named_children(): PyProxy;
+      named_modules(): PyProxy;
+      register_buffer(name: string, tensor: PyTorchTensor | PyProxy | null): Promise<void>;
+      register_parameter(name: string, param: PyProxy | null): Promise<void>;
+      add_module(name: string, module: PyProxy | null): Promise<void>;
+      requires_grad_(requires_grad?: boolean): Promise<Module>;
+      readonly training: Promise<boolean>;
+      [key: string]: unknown;
+    }
+
+    export class Linear {
+      constructor(in_features: number, out_features: number, bias?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      readonly weight: PyProxy;
+      readonly bias: PyProxy;
+      [key: string]: unknown;
+    }
+
+    export class Conv1d {
+      constructor(in_channels: number, out_channels: number, kernel_size: number | [number], stride?: number | [number], padding?: number | [number], dilation?: number, groups?: number, bias?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class Conv2d {
+      constructor(in_channels: number, out_channels: number, kernel_size: number | [number, number], stride?: number | [number, number], padding?: number | [number, number], dilation?: number | [number, number], groups?: number, bias?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class Conv3d {
+      constructor(in_channels: number, out_channels: number, kernel_size: number | [number, number, number], stride?: number | [number, number, number], padding?: number | [number, number, number], dilation?: number, groups?: number, bias?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class ConvTranspose2d {
+      constructor(in_channels: number, out_channels: number, kernel_size: number | [number, number], stride?: number | [number, number], padding?: number, output_padding?: number, groups?: number, bias?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class BatchNorm1d {
+      constructor(num_features: number, eps?: number, momentum?: number, affine?: boolean, track_running_stats?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class BatchNorm2d {
+      constructor(num_features: number, eps?: number, momentum?: number, affine?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class LayerNorm {
+      constructor(normalized_shape: number | number[], eps?: number, elementwise_affine?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class Dropout {
+      constructor(p?: number, inplace?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class Dropout2d {
+      constructor(p?: number, inplace?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class LSTM {
+      constructor(input_size: number, hidden_size: number, num_layers?: number, bias?: boolean, batch_first?: boolean, dropout?: number, bidirectional?: boolean);
+      forward(input: PyTorchTensor | PyProxy, hx?: [PyTorchTensor, PyTorchTensor] | null): Promise<[PyTorchTensor, [PyTorchTensor, PyTorchTensor]]>;
+      [key: string]: unknown;
+    }
+
+    export class GRU {
+      constructor(input_size: number, hidden_size: number, num_layers?: number, bias?: boolean, batch_first?: boolean, dropout?: number, bidirectional?: boolean);
+      forward(input: PyTorchTensor | PyProxy, hx?: PyTorchTensor | null): Promise<[PyTorchTensor, PyTorchTensor]>;
+      [key: string]: unknown;
+    }
+
+    export class RNN {
+      constructor(input_size: number, hidden_size: number, num_layers?: number, nonlinearity?: 'tanh' | 'relu', batch_first?: boolean, dropout?: number, bidirectional?: boolean);
+      forward(input: PyTorchTensor | PyProxy, hx?: PyTorchTensor | null): Promise<[PyTorchTensor, PyTorchTensor]>;
+      [key: string]: unknown;
+    }
+
+    export class Transformer {
+      constructor(d_model?: number, nhead?: number, num_encoder_layers?: number, num_decoder_layers?: number, dim_feedforward?: number, dropout?: number, activation?: string);
+      forward(src: PyTorchTensor | PyProxy, tgt: PyTorchTensor | PyProxy, ...kwargs: unknown[]): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class TransformerEncoder {
+      constructor(encoder_layer: PyProxy, num_layers: number, norm?: PyProxy | null);
+      forward(src: PyTorchTensor | PyProxy, mask?: PyTorchTensor | PyProxy | null, src_key_padding_mask?: PyTorchTensor | PyProxy | null): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class TransformerDecoder {
+      constructor(decoder_layer: PyProxy, num_layers: number, norm?: PyProxy | null);
+      forward(tgt: PyTorchTensor | PyProxy, memory: PyTorchTensor | PyProxy, ...kwargs: unknown[]): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class MultiheadAttention {
+      constructor(embed_dim: number, num_heads: number, dropout?: number, bias?: boolean, kdim?: number | null, vdim?: number | null, batch_first?: boolean);
+      forward(query: PyTorchTensor | PyProxy, key: PyTorchTensor | PyProxy, value: PyTorchTensor | PyProxy, ...kwargs: unknown[]): Promise<[PyTorchTensor, PyTorchTensor | null]>;
+      [key: string]: unknown;
+    }
+
+    export class Embedding {
+      constructor(num_embeddings: number, embedding_dim: number, padding_idx?: number | null, max_norm?: number | null, scale_grad_by_freq?: boolean, sparse?: boolean);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      readonly weight: PyProxy;
+      [key: string]: unknown;
+    }
+
+    export class EmbeddingBag {
+      constructor(num_embeddings: number, embedding_dim: number, mode?: 'mean' | 'sum' | 'max', include_last_offset?: boolean);
+      forward(input: PyTorchTensor | PyProxy, offsets?: PyTorchTensor | PyProxy | null): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class Sequential {
+      constructor(...modules: PyProxy[]);
+      forward(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      append(module: PyProxy): Promise<Sequential>;
+      [key: string]: unknown;
+    }
+
+    export class ModuleList {
+      constructor(modules?: PyProxy[]);
+      append(module: PyProxy): Promise<ModuleList>;
+      __len__(): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class ModuleDict {
+      constructor(modules?: Record<string, PyProxy>);
+      [key: string]: unknown;
+    }
+
+    export class ParameterList {
+      constructor(parameters?: PyProxy[]);
+      append(value: PyProxy): Promise<ParameterList>;
+      [key: string]: unknown;
+    }
+
+    // Loss functions
+    export class CrossEntropyLoss {
+      constructor(weight?: PyTorchTensor | PyProxy | null, reduction?: 'mean' | 'sum' | 'none', label_smoothing?: number);
+      forward(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class MSELoss {
+      constructor(reduction?: 'mean' | 'sum' | 'none');
+      forward(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class BCELoss {
+      constructor(weight?: PyTorchTensor | PyProxy | null, reduction?: 'mean' | 'sum' | 'none');
+      forward(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class BCEWithLogitsLoss {
+      constructor(weight?: PyTorchTensor | PyProxy | null, reduction?: 'mean' | 'sum' | 'none', pos_weight?: PyTorchTensor | PyProxy | null);
+      forward(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class NLLLoss {
+      constructor(weight?: PyTorchTensor | PyProxy | null, reduction?: 'mean' | 'sum' | 'none');
+      forward(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class KLDivLoss {
+      constructor(reduction?: 'mean' | 'sum' | 'none' | 'batchmean', log_target?: boolean);
+      forward(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    export class L1Loss {
+      constructor(reduction?: 'mean' | 'sum' | 'none');
+      forward(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+
+    // Functional
+    export namespace functional {
+      export function relu(input: PyTorchTensor | PyProxy, inplace?: boolean): Promise<PyTorchTensor>;
+      export function relu6(input: PyTorchTensor | PyProxy, inplace?: boolean): Promise<PyTorchTensor>;
+      export function sigmoid(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      export function tanh(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      export function softmax(input: PyTorchTensor | PyProxy, dim?: number, dtype?: string): Promise<PyTorchTensor>;
+      export function log_softmax(input: PyTorchTensor | PyProxy, dim?: number): Promise<PyTorchTensor>;
+      export function softplus(input: PyTorchTensor | PyProxy, beta?: number, threshold?: number): Promise<PyTorchTensor>;
+      export function selu(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      export function elu(input: PyTorchTensor | PyProxy, alpha?: number): Promise<PyTorchTensor>;
+      export function leaky_relu(input: PyTorchTensor | PyProxy, negative_slope?: number): Promise<PyTorchTensor>;
+      export function gelu(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      export function swish(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      export function mish(input: PyTorchTensor | PyProxy): Promise<PyTorchTensor>;
+      export function dropout(input: PyTorchTensor | PyProxy, p?: number, training?: boolean): Promise<PyTorchTensor>;
+      export function dropout2d(input: PyTorchTensor | PyProxy, p?: number, training?: boolean): Promise<PyTorchTensor>;
+      export function batch_norm(input: PyTorchTensor | PyProxy, running_mean: PyTorchTensor | PyProxy | null, running_var: PyTorchTensor | PyProxy | null, weight?: PyTorchTensor | PyProxy | null, bias?: PyTorchTensor | PyProxy | null, training?: boolean, momentum?: number, eps?: number): Promise<PyTorchTensor>;
+      export function layer_norm(input: PyTorchTensor | PyProxy, normalized_shape: number[], weight?: PyTorchTensor | PyProxy | null, bias?: PyTorchTensor | PyProxy | null, eps?: number): Promise<PyTorchTensor>;
+      export function cross_entropy(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy, weight?: PyTorchTensor | PyProxy | null, reduction?: string, label_smoothing?: number): Promise<PyTorchTensor>;
+      export function mse_loss(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy, reduction?: 'mean' | 'sum' | 'none'): Promise<PyTorchTensor>;
+      export function binary_cross_entropy(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy, weight?: PyTorchTensor | PyProxy | null, reduction?: string): Promise<PyTorchTensor>;
+      export function binary_cross_entropy_with_logits(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy, weight?: PyTorchTensor | PyProxy | null, reduction?: string): Promise<PyTorchTensor>;
+      export function l1_loss(input: PyTorchTensor | PyProxy, target: PyTorchTensor | PyProxy, reduction?: string): Promise<PyTorchTensor>;
+      export function linear(input: PyTorchTensor | PyProxy, weight: PyTorchTensor | PyProxy, bias?: PyTorchTensor | PyProxy | null): Promise<PyTorchTensor>;
+      export function conv2d(input: PyTorchTensor | PyProxy, weight: PyTorchTensor | PyProxy, bias?: PyTorchTensor | PyProxy | null, stride?: number | [number, number], padding?: number | [number, number]): Promise<PyTorchTensor>;
+      export function max_pool2d(input: PyTorchTensor | PyProxy, kernel_size: number | [number, number], stride?: number | [number, number], padding?: number): Promise<PyTorchTensor>;
+      export function avg_pool2d(input: PyTorchTensor | PyProxy, kernel_size: number | [number, number], stride?: number | [number, number], padding?: number): Promise<PyTorchTensor>;
+      export function adaptive_avg_pool2d(input: PyTorchTensor | PyProxy, output_size: number | [number, number]): Promise<PyTorchTensor>;
+      export function interpolate(input: PyTorchTensor | PyProxy, size?: number | [number] | [number, number], scale_factor?: number | [number, number], mode?: string, align_corners?: boolean | null): Promise<PyTorchTensor>;
+      export function embedding(input: PyTorchTensor | PyProxy, weight: PyTorchTensor | PyProxy, padding_idx?: number | null): Promise<PyTorchTensor>;
+      export function one_hot(tensor: PyTorchTensor | PyProxy, num_classes?: number): Promise<PyTorchTensor>;
+      export function normalize(input: PyTorchTensor | PyProxy, p?: number, dim?: number, eps?: number): Promise<PyTorchTensor>;
+      export function pad(input: PyTorchTensor | PyProxy, pad: number[], mode?: string, value?: number): Promise<PyTorchTensor>;
+      export function pixel_shuffle(input: PyTorchTensor | PyProxy, upscale_factor: number): Promise<PyTorchTensor>;
+      export function unfold(input: PyTorchTensor | PyProxy, dimension: number, size: number, step?: number): Promise<PyTorchTensor>;
+      export function fold(input: PyTorchTensor | PyProxy, output_size: [number, number], kernel_size: number | [number, number], dilation?: number, padding?: number, stride?: number): Promise<PyTorchTensor>;
+    }
+  }
+
+  // ── torch.optim ───────────────────────────────────────────────────────────
+
+  export namespace optim {
+    export class Optimizer {
+      zero_grad(set_to_none?: boolean): Promise<void>;
+      step(closure?: PyProxy | null): Promise<PyTorchTensor | null>;
+      state_dict(): Promise<Record<string, unknown>>;
+      load_state_dict(state_dict: Record<string, unknown>): Promise<void>;
+      add_param_group(param_group: Record<string, unknown>): Promise<void>;
+      [key: string]: unknown;
+    }
+
+    export class SGD extends Optimizer {
+      constructor(params: PyProxy, lr: number, momentum?: number, dampening?: number, weight_decay?: number, nesterov?: boolean);
+      [key: string]: unknown;
+    }
+
+    export class Adam extends Optimizer {
+      constructor(params: PyProxy, lr?: number, betas?: [number, number], eps?: number, weight_decay?: number, amsgrad?: boolean);
+      [key: string]: unknown;
+    }
+
+    export class AdamW extends Optimizer {
+      constructor(params: PyProxy, lr?: number, betas?: [number, number], eps?: number, weight_decay?: number, amsgrad?: boolean);
+      [key: string]: unknown;
+    }
+
+    export class RMSprop extends Optimizer {
+      constructor(params: PyProxy, lr?: number, alpha?: number, eps?: number, weight_decay?: number, momentum?: number, centered?: boolean);
+      [key: string]: unknown;
+    }
+
+    export class Adagrad extends Optimizer {
+      constructor(params: PyProxy, lr?: number, lr_decay?: number, weight_decay?: number, eps?: number);
+      [key: string]: unknown;
+    }
+
+    export class Adadelta extends Optimizer {
+      constructor(params: PyProxy, lr?: number, rho?: number, eps?: number, weight_decay?: number);
+      [key: string]: unknown;
+    }
+
+    export namespace lr_scheduler {
+      export class LRScheduler {
+        step(epoch?: number): Promise<void>;
+        get_last_lr(): Promise<number[]>;
+        state_dict(): Promise<Record<string, unknown>>;
+        load_state_dict(state_dict: Record<string, unknown>): Promise<void>;
+        [key: string]: unknown;
+      }
+      export class StepLR extends LRScheduler {
+        constructor(optimizer: PyProxy, step_size: number, gamma?: number, last_epoch?: number);
+      }
+      export class MultiStepLR extends LRScheduler {
+        constructor(optimizer: PyProxy, milestones: number[], gamma?: number);
+      }
+      export class ExponentialLR extends LRScheduler {
+        constructor(optimizer: PyProxy, gamma: number);
+      }
+      export class CosineAnnealingLR extends LRScheduler {
+        constructor(optimizer: PyProxy, T_max: number, eta_min?: number);
+      }
+      export class ReduceLROnPlateau {
+        constructor(optimizer: PyProxy, mode?: 'min' | 'max', factor?: number, patience?: number, verbose?: boolean);
+        step(metrics: number): Promise<void>;
+        [key: string]: unknown;
+      }
+      export class OneCycleLR extends LRScheduler {
+        constructor(optimizer: PyProxy, max_lr: number | number[], total_steps?: number, epochs?: number, steps_per_epoch?: number);
+      }
+      export class CyclicLR extends LRScheduler {
+        constructor(optimizer: PyProxy, base_lr: number | number[], max_lr: number | number[], step_size_up?: number, mode?: string);
+      }
+    }
+  }
+
+  // ── torch.utils.data ─────────────────────────────────────────────────────
+
+  export namespace utils {
+    export namespace data {
+      export class Dataset {
+        __len__(): Promise<number>;
+        __getitem__(idx: number): Promise<unknown>;
+        [key: string]: unknown;
+      }
+
+      export class TensorDataset extends Dataset {
+        constructor(...tensors: (PyTorchTensor | PyProxy)[]);
+        [key: string]: unknown;
+      }
+
+      export class DataLoader {
+        constructor(
+          dataset: PyProxy,
+          batch_size?: number,
+          shuffle?: boolean,
+          num_workers?: number,
+          pin_memory?: boolean,
+          drop_last?: boolean,
+          collate_fn?: PyProxy | null,
+        );
+        __len__(): Promise<number>;
+        [key: string]: unknown;
+      }
+
+      export function random_split(dataset: PyProxy, lengths: number[]): Promise<PyProxy[]>;
+      export function Subset(dataset: PyProxy, indices: number[]): Promise<PyProxy>;
+      export function ConcatDataset(datasets: PyProxy[]): Promise<PyProxy>;
+    }
+  }
+
+  // ── torch.save / load ─────────────────────────────────────────────────────
+
+  export function save(obj: PyProxy | PyTorchTensor, f: string): Promise<void>;
+  export function load(f: string, map_location?: Device | PyProxy | null): Promise<PyProxy | PyTorchTensor | Record<string, PyTorchTensor>>;
+
+  // ── torch.autograd ────────────────────────────────────────────────────────
+
+  export namespace autograd {
+    export function grad(outputs: PyTorchTensor | PyProxy | (PyTorchTensor | PyProxy)[], inputs: PyTorchTensor | PyProxy | (PyTorchTensor | PyProxy)[], grad_outputs?: (PyTorchTensor | PyProxy | null)[] | null, retain_graph?: boolean, create_graph?: boolean): Promise<PyTorchTensor[]>;
+    export function backward(tensors: (PyTorchTensor | PyProxy)[], grad_tensors?: (PyTorchTensor | PyProxy | null)[] | null, retain_graph?: boolean, create_graph?: boolean): Promise<void>;
+    export class Function {
+      static forward(ctx: PyProxy, ...args: unknown[]): Promise<PyTorchTensor>;
+      static backward(ctx: PyProxy, ...grad_outputs: (PyTorchTensor | null)[]): Promise<(PyTorchTensor | null)[]>;
+      static apply(...args: unknown[]): Promise<PyTorchTensor>;
+      [key: string]: unknown;
+    }
+    export class no_grad {
+      constructor();
+      __enter__(): Promise<void>;
+      __exit__(...args: unknown[]): Promise<void>;
+      [key: string]: unknown;
+    }
+    export function set_grad_enabled(mode: boolean): Promise<PyProxy>;
+  }
+
+  // ── torch.jit ────────────────────────────────────────────────────────────
+
+  export namespace jit {
+    export function script(obj: PyProxy): Promise<PyProxy>;
+    export function trace(func: PyProxy, example_inputs: unknown): Promise<PyProxy>;
+    export function load(f: string, map_location?: Device | null): Promise<PyProxy>;
+    export function save(m: PyProxy, f: string): Promise<void>;
+    export function export_opnames(m: PyProxy): Promise<string[]>;
+  }
+
+  // ── torch.cuda ────────────────────────────────────────────────────────────
+
+  export namespace cuda {
+    export function is_available(): Promise<boolean>;
+    export function device_count(): Promise<number>;
+    export function current_device(): Promise<number>;
+    export function set_device(device: number | string): Promise<void>;
+    export function get_device_name(device?: number | string): Promise<string>;
+    export function get_device_properties(device: number | string): Promise<PyProxy>;
+    export function memory_allocated(device?: number | string): Promise<number>;
+    export function memory_reserved(device?: number | string): Promise<number>;
+    export function empty_cache(): Promise<void>;
+    export function synchronize(device?: number | string): Promise<void>;
+    export const OutOfMemoryError: PyProxy;
+  }
+
+  // ── torch.distributed ─────────────────────────────────────────────────────
+
+  export namespace distributed {
+    export function init_process_group(backend?: string, rank?: number, world_size?: number): Promise<void>;
+    export function is_initialized(): Promise<boolean>;
+    export function get_rank(): Promise<number>;
+    export function get_world_size(): Promise<number>;
+    export function all_reduce(tensor: PyTorchTensor | PyProxy, op?: PyProxy): Promise<void>;
+    export function broadcast(tensor: PyTorchTensor | PyProxy, src: number): Promise<void>;
+    export function all_gather(tensor_list: (PyTorchTensor | PyProxy)[], tensor: PyTorchTensor | PyProxy): Promise<void>;
+    export function destroy_process_group(): Promise<void>;
+  }
+
+  // ── Constants ─────────────────────────────────────────────────────────────
+
+  export const __version__: string;
+  export const float32: PyProxy;
+  export const float64: PyProxy;
+  export const double: PyProxy;
+  export const float16: PyProxy;
+  export const half: PyProxy;
+  export const bfloat16: PyProxy;
+  export const int8: PyProxy;
+  export const int16: PyProxy;
+  export const int32: PyProxy;
+  export const int64: PyProxy;
+  export const bool: PyProxy;
+  export const uint8: PyProxy;
+  export const complex64: PyProxy;
+  export const complex128: PyProxy;
+  export const device: PyProxy;
+  export const Tensor: typeof PyTorchTensor;
+  export const pi: number;
+  export const inf: number;
+  export const nan: number;
+  export const no_grad: typeof autograd.no_grad;
+}
+