@hoff97/tensor-js/dist/lib/wasm/rust_wasm_tensor_bg.d.ts

PyTorch like deep learning inferrence library

/**
*/
export class TensorF32 {
    static __wrap(ptr: any): any;
    /**
    * @param {Uint32Array} shape
    * @param {Float32Array} values
    * @returns {TensorF32}
    */
    static create(shape: Uint32Array, values: Float32Array): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @param {number} value
    * @returns {TensorF32}
    */
    static create_constant(shape: Uint32Array, value: number): TensorF32;
    __destroy_into_raw(): number | undefined;
    ptr: number | undefined;
    free(): void;
    /**
    * @returns {Float32Array}
    */
    get_vals(): Float32Array;
    /**
    * @returns {Uint32Array}
    */
    get_shape(): Uint32Array;
    /**
    * @returns {TensorF32}
    */
    exp(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    log(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    sqrt(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    sin(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    cos(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    tan(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    asin(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    acos(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    atan(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    sinh(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    cosh(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    tanh(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    asinh(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    acosh(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    atanh(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    sigmoid(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    floor(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    ceil(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    round(): TensorF32;
    /**
    * @param {number} power
    * @param {number} factor
    * @returns {TensorF32}
    */
    power_scalar(power: number, factor: number): TensorF32;
    /**
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF32}
    */
    hard_sigmoid(alpha: number, beta: number): TensorF32;
    /**
    * @returns {TensorF32}
    */
    abs(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    sign(): TensorF32;
    /**
    * @returns {TensorF32}
    */
    negate(): TensorF32;
    /**
    * @param {number} factor
    * @param {number} add
    * @returns {TensorF32}
    */
    add_multiply_scalar(factor: number, add: number): TensorF32;
    /**
    * @param {number} min
    * @param {number} max
    * @returns {TensorF32}
    */
    clip(min: number, max: number): TensorF32;
    /**
    * @param {number} min
    * @returns {TensorF32}
    */
    clip_min(min: number): TensorF32;
    /**
    * @param {number} max
    * @returns {TensorF32}
    */
    clip_max(max: number): TensorF32;
    /**
    * @param {TensorF32} other
    * @returns {TensorF32}
    */
    power(other: TensorF32): TensorF32;
    /**
    * @param {TensorF32} other
    * @returns {TensorF32}
    */
    bce(other: TensorF32): TensorF32;
    /**
    * @param {TensorF32} other
    * @returns {TensorF32}
    */
    bce_back(other: TensorF32): TensorF32;
    /**
    * @param {TensorF32} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF32}
    */
    addition(other: TensorF32, alpha: number, beta: number): TensorF32;
    /**
    * @param {TensorF32} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF32}
    */
    subtraction(other: TensorF32, alpha: number, beta: number): TensorF32;
    /**
    * @param {TensorF32} other
    * @param {number} alpha
    * @returns {TensorF32}
    */
    multiply(other: TensorF32, alpha: number): TensorF32;
    /**
    * @param {TensorF32} other
    * @param {number} alpha
    * @returns {TensorF32}
    */
    divide(other: TensorF32, alpha: number): TensorF32;
    /**
    * @param {number} min
    * @param {number} max
    * @param {TensorF32} grad
    * @returns {TensorF32}
    */
    clip_backward(min: number, max: number, grad: TensorF32): TensorF32;
    /**
    * @param {number} min
    * @param {TensorF32} grad
    * @returns {TensorF32}
    */
    clip_min_backward(min: number, grad: TensorF32): TensorF32;
    /**
    * @param {number} max
    * @param {TensorF32} grad
    * @returns {TensorF32}
    */
    clip_max_backward(max: number, grad: TensorF32): TensorF32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    sum(axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    sum_square(axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    product(axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    max(axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    min(axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    reduce_mean(axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    reduce_mean_square(axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    reduce_log_sum(axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    reduce_log_sum_exp(axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {TensorF32} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorF32}
    */
    conv(kernel: TensorF32, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorF32;
    /**
    * @param {TensorF32} kernel
    * @param {TensorF32} bias
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorF32}
    */
    conv_with_bias(kernel: TensorF32, bias: TensorF32, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorF32;
    /**
    * @param {TensorF32} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @returns {TensorF32}
    */
    conv_transpose(kernel: TensorF32, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array): TensorF32;
    /**
    * @param {Uint32Array} kernel_shape
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {boolean} include_pad
    * @returns {TensorF32}
    */
    average_pool(kernel_shape: Uint32Array, pads: Uint32Array, strides: Uint32Array, include_pad: boolean): TensorF32;
    /**
    * @param {Uint32Array} pads
    * @param {number} mode
    * @param {number} value
    * @returns {TensorF32}
    */
    pad(pads: Uint32Array, mode: number, value: number): TensorF32;
    /**
    * @param {Float32Array} scales
    * @returns {TensorF32}
    */
    upsample(scales: Float32Array): TensorF32;
    /**
    * @param {TensorF32} mean
    * @param {TensorF32} variance
    * @param {number} epsilon
    * @param {TensorF32} scale
    * @param {TensorF32} bias
    * @returns {TensorF32}
    */
    normalize(mean: TensorF32, variance: TensorF32, epsilon: number, scale: TensorF32, bias: TensorF32): TensorF32;
    /**
    * @param {TensorF32} other
    * @returns {TensorF32}
    */
    matmul(other: TensorF32): TensorF32;
    /**
    * @param {TensorF32} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @returns {TensorF32}
    */
    gemm(other: TensorF32, a_transpose: boolean, b_transpose: boolean, alpha: number): TensorF32;
    /**
    * @param {TensorF32} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @param {TensorF32} c
    * @param {number} beta
    * @returns {TensorF32}
    */
    gemm_with_c(other: TensorF32, a_transpose: boolean, b_transpose: boolean, alpha: number, c: TensorF32, beta: number): TensorF32;
    /**
    * @param {TensorF32} values
    * @param {Uint32Array} starts
    * @returns {TensorF32}
    */
    set_values(values: TensorF32, starts: Uint32Array): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorF32}
    */
    reshape(shape: Uint32Array): TensorF32;
    /**
    * @param {TensorF32} other
    * @param {number} axes
    * @returns {TensorF32}
    */
    concat(other: TensorF32, axes: number): TensorF32;
    /**
    * @param {Uint32Array} permutation
    * @returns {TensorF32}
    */
    transpose(permutation: Uint32Array): TensorF32;
    /**
    * @param {Uint32Array} repeats
    * @returns {TensorF32}
    */
    repeat(repeats: Uint32Array): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorF32}
    */
    expand(shape: Uint32Array): TensorF32;
    /**
    * @returns {TensorF32}
    */
    copy(): TensorF32;
    /**
    * @param {number} axis
    * @param {Uint32Array} indices
    * @param {Uint32Array} indice_shape
    * @returns {TensorF32}
    */
    gather(axis: number, indices: Uint32Array, indice_shape: Uint32Array): TensorF32;
    /**
    * @param {Uint32Array} starts
    * @param {Uint32Array} ends
    * @param {Uint32Array} axis
    * @param {Int32Array} steps
    * @returns {TensorF32}
    */
    slice(starts: Uint32Array, ends: Uint32Array, axis: Uint32Array, steps: Int32Array): TensorF32;
    /**
    * @param {TensorU32} indices
    * @param {TensorF32} b
    * @param {number} m
    * @returns {TensorF32}
    */
    matmul_sparse_dense(indices: TensorU32, b: TensorF32, m: number): TensorF32;
    /**
    * @param {TensorU32} indices
    * @param {TensorF32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF32}
    */
    add_sparse_dense(indices: TensorU32, b: TensorF32, result_shape: Uint32Array, alpha: number, beta: number): TensorF32;
    /**
    * @param {TensorU32} indices
    * @param {TensorF32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF32}
    */
    subtract_sparse_dense(indices: TensorU32, b: TensorF32, result_shape: Uint32Array, alpha: number, beta: number): TensorF32;
    /**
    * @param {TensorU32} indices
    * @param {TensorF32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorF32}
    */
    multiply_sparse_dense(indices: TensorU32, b: TensorF32, result_shape: Uint32Array, alpha: number): TensorF32;
    /**
    * @param {TensorU32} indices
    * @param {TensorF32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorF32}
    */
    divide_sparse_dense(indices: TensorU32, b: TensorF32, result_shape: Uint32Array, alpha: number): TensorF32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorF32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF32}
    */
    add_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorF32, result_shape: Uint32Array, alpha: number, beta: number): TensorF32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorF32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF32}
    */
    subtract_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorF32, result_shape: Uint32Array, alpha: number, beta: number): TensorF32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorF32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorF32}
    */
    divide_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorF32, result_shape: Uint32Array, alpha: number): TensorF32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorF32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorF32}
    */
    multiply_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorF32, result_shape: Uint32Array, alpha: number): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    sum_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    sum_square_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    reduce_mean_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    product_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    max_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    min_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    reduce_mean_squared_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    reduce_log_sum_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF32}
    */
    reduce_log_sum_exp_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF32;
}
/**
*/
export class TensorF64 {
    static __wrap(ptr: any): any;
    /**
    * @param {Uint32Array} shape
    * @param {Float64Array} values
    * @returns {TensorF64}
    */
    static create(shape: Uint32Array, values: Float64Array): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @param {number} value
    * @returns {TensorF64}
    */
    static create_constant(shape: Uint32Array, value: number): TensorF64;
    __destroy_into_raw(): number | undefined;
    ptr: number | undefined;
    free(): void;
    /**
    * @returns {Float64Array}
    */
    get_vals(): Float64Array;
    /**
    * @returns {Uint32Array}
    */
    get_shape(): Uint32Array;
    /**
    * @returns {TensorF64}
    */
    exp(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    log(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    sqrt(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    sin(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    cos(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    tan(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    asin(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    acos(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    atan(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    sinh(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    cosh(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    tanh(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    asinh(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    acosh(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    atanh(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    sigmoid(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    floor(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    ceil(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    round(): TensorF64;
    /**
    * @param {number} power
    * @param {number} factor
    * @returns {TensorF64}
    */
    power_scalar(power: number, factor: number): TensorF64;
    /**
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF64}
    */
    hard_sigmoid(alpha: number, beta: number): TensorF64;
    /**
    * @returns {TensorF64}
    */
    abs(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    sign(): TensorF64;
    /**
    * @returns {TensorF64}
    */
    negate(): TensorF64;
    /**
    * @param {number} factor
    * @param {number} add
    * @returns {TensorF64}
    */
    add_multiply_scalar(factor: number, add: number): TensorF64;
    /**
    * @param {number} min
    * @param {number} max
    * @returns {TensorF64}
    */
    clip(min: number, max: number): TensorF64;
    /**
    * @param {number} min
    * @returns {TensorF64}
    */
    clip_min(min: number): TensorF64;
    /**
    * @param {number} max
    * @returns {TensorF64}
    */
    clip_max(max: number): TensorF64;
    /**
    * @param {TensorF64} other
    * @returns {TensorF64}
    */
    power(other: TensorF64): TensorF64;
    /**
    * @param {TensorF64} other
    * @returns {TensorF64}
    */
    bce(other: TensorF64): TensorF64;
    /**
    * @param {TensorF64} other
    * @returns {TensorF64}
    */
    bce_back(other: TensorF64): TensorF64;
    /**
    * @param {TensorF64} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF64}
    */
    addition(other: TensorF64, alpha: number, beta: number): TensorF64;
    /**
    * @param {TensorF64} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF64}
    */
    subtraction(other: TensorF64, alpha: number, beta: number): TensorF64;
    /**
    * @param {TensorF64} other
    * @param {number} alpha
    * @returns {TensorF64}
    */
    multiply(other: TensorF64, alpha: number): TensorF64;
    /**
    * @param {TensorF64} other
    * @param {number} alpha
    * @returns {TensorF64}
    */
    divide(other: TensorF64, alpha: number): TensorF64;
    /**
    * @param {number} min
    * @param {number} max
    * @param {TensorF64} grad
    * @returns {TensorF64}
    */
    clip_backward(min: number, max: number, grad: TensorF64): TensorF64;
    /**
    * @param {number} min
    * @param {TensorF64} grad
    * @returns {TensorF64}
    */
    clip_min_backward(min: number, grad: TensorF64): TensorF64;
    /**
    * @param {number} max
    * @param {TensorF64} grad
    * @returns {TensorF64}
    */
    clip_max_backward(max: number, grad: TensorF64): TensorF64;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    sum(axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    sum_square(axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    product(axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    max(axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    min(axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    reduce_mean(axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    reduce_mean_square(axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    reduce_log_sum(axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    reduce_log_sum_exp(axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {TensorF64} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorF64}
    */
    conv(kernel: TensorF64, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorF64;
    /**
    * @param {TensorF64} kernel
    * @param {TensorF64} bias
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorF64}
    */
    conv_with_bias(kernel: TensorF64, bias: TensorF64, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorF64;
    /**
    * @param {TensorF64} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @returns {TensorF64}
    */
    conv_transpose(kernel: TensorF64, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array): TensorF64;
    /**
    * @param {Uint32Array} kernel_shape
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {boolean} include_pad
    * @returns {TensorF64}
    */
    average_pool(kernel_shape: Uint32Array, pads: Uint32Array, strides: Uint32Array, include_pad: boolean): TensorF64;
    /**
    * @param {Uint32Array} pads
    * @param {number} mode
    * @param {number} value
    * @returns {TensorF64}
    */
    pad(pads: Uint32Array, mode: number, value: number): TensorF64;
    /**
    * @param {Float32Array} scales
    * @returns {TensorF64}
    */
    upsample(scales: Float32Array): TensorF64;
    /**
    * @param {TensorF64} mean
    * @param {TensorF64} variance
    * @param {number} epsilon
    * @param {TensorF64} scale
    * @param {TensorF64} bias
    * @returns {TensorF64}
    */
    normalize(mean: TensorF64, variance: TensorF64, epsilon: number, scale: TensorF64, bias: TensorF64): TensorF64;
    /**
    * @param {TensorF64} other
    * @returns {TensorF64}
    */
    matmul(other: TensorF64): TensorF64;
    /**
    * @param {TensorF64} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @returns {TensorF64}
    */
    gemm(other: TensorF64, a_transpose: boolean, b_transpose: boolean, alpha: number): TensorF64;
    /**
    * @param {TensorF64} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @param {TensorF64} c
    * @param {number} beta
    * @returns {TensorF64}
    */
    gemm_with_c(other: TensorF64, a_transpose: boolean, b_transpose: boolean, alpha: number, c: TensorF64, beta: number): TensorF64;
    /**
    * @param {TensorF64} values
    * @param {Uint32Array} starts
    * @returns {TensorF64}
    */
    set_values(values: TensorF64, starts: Uint32Array): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorF64}
    */
    reshape(shape: Uint32Array): TensorF64;
    /**
    * @param {TensorF64} other
    * @param {number} axes
    * @returns {TensorF64}
    */
    concat(other: TensorF64, axes: number): TensorF64;
    /**
    * @param {Uint32Array} permutation
    * @returns {TensorF64}
    */
    transpose(permutation: Uint32Array): TensorF64;
    /**
    * @param {Uint32Array} repeats
    * @returns {TensorF64}
    */
    repeat(repeats: Uint32Array): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorF64}
    */
    expand(shape: Uint32Array): TensorF64;
    /**
    * @returns {TensorF64}
    */
    copy(): TensorF64;
    /**
    * @param {number} axis
    * @param {Uint32Array} indices
    * @param {Uint32Array} indice_shape
    * @returns {TensorF64}
    */
    gather(axis: number, indices: Uint32Array, indice_shape: Uint32Array): TensorF64;
    /**
    * @param {Uint32Array} starts
    * @param {Uint32Array} ends
    * @param {Uint32Array} axis
    * @param {Int32Array} steps
    * @returns {TensorF64}
    */
    slice(starts: Uint32Array, ends: Uint32Array, axis: Uint32Array, steps: Int32Array): TensorF64;
    /**
    * @param {TensorU32} indices
    * @param {TensorF64} b
    * @param {number} m
    * @returns {TensorF64}
    */
    matmul_sparse_dense(indices: TensorU32, b: TensorF64, m: number): TensorF64;
    /**
    * @param {TensorU32} indices
    * @param {TensorF64} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF64}
    */
    add_sparse_dense(indices: TensorU32, b: TensorF64, result_shape: Uint32Array, alpha: number, beta: number): TensorF64;
    /**
    * @param {TensorU32} indices
    * @param {TensorF64} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF64}
    */
    subtract_sparse_dense(indices: TensorU32, b: TensorF64, result_shape: Uint32Array, alpha: number, beta: number): TensorF64;
    /**
    * @param {TensorU32} indices
    * @param {TensorF64} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorF64}
    */
    multiply_sparse_dense(indices: TensorU32, b: TensorF64, result_shape: Uint32Array, alpha: number): TensorF64;
    /**
    * @param {TensorU32} indices
    * @param {TensorF64} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorF64}
    */
    divide_sparse_dense(indices: TensorU32, b: TensorF64, result_shape: Uint32Array, alpha: number): TensorF64;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorF64} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF64}
    */
    add_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorF64, result_shape: Uint32Array, alpha: number, beta: number): TensorF64;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorF64} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorF64}
    */
    subtract_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorF64, result_shape: Uint32Array, alpha: number, beta: number): TensorF64;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorF64} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorF64}
    */
    divide_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorF64, result_shape: Uint32Array, alpha: number): TensorF64;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorF64} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorF64}
    */
    multiply_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorF64, result_shape: Uint32Array, alpha: number): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    sum_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    sum_square_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    reduce_mean_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    product_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    max_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    min_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    reduce_mean_squared_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    reduce_log_sum_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF64;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorF64}
    */
    reduce_log_sum_exp_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorF64;
}
/**
*/
export class TensorI16 {
    static __wrap(ptr: any): any;
    /**
    * @param {Uint32Array} shape
    * @param {Int16Array} values
    * @returns {TensorI16}
    */
    static create(shape: Uint32Array, values: Int16Array): TensorI16;
    /**
    * @param {Uint32Array} shape
    * @param {number} value
    * @returns {TensorI16}
    */
    static create_constant(shape: Uint32Array, value: number): TensorI16;
    __destroy_into_raw(): number | undefined;
    ptr: number | undefined;
    free(): void;
    /**
    * @returns {Int16Array}
    */
    get_vals(): Int16Array;
    /**
    * @returns {Uint32Array}
    */
    get_shape(): Uint32Array;
    /**
    * @param {number} power
    * @param {number} factor
    * @returns {TensorI16}
    */
    power_scalar(power: number, factor: number): TensorI16;
    /**
    * @returns {TensorI16}
    */
    abs(): TensorI16;
    /**
    * @returns {TensorI16}
    */
    sign(): TensorI16;
    /**
    * @returns {TensorI16}
    */
    negate(): TensorI16;
    /**
    * @param {number} factor
    * @param {number} add
    * @returns {TensorI16}
    */
    add_multiply_scalar(factor: number, add: number): TensorI16;
    /**
    * @param {number} min
    * @param {number} max
    * @returns {TensorI16}
    */
    clip(min: number, max: number): TensorI16;
    /**
    * @param {number} min
    * @returns {TensorI16}
    */
    clip_min(min: number): TensorI16;
    /**
    * @param {number} max
    * @returns {TensorI16}
    */
    clip_max(max: number): TensorI16;
    /**
    * @param {TensorI16} other
    * @returns {TensorI16}
    */
    power(other: TensorI16): TensorI16;
    /**
    * @param {TensorI16} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI16}
    */
    addition(other: TensorI16, alpha: number, beta: number): TensorI16;
    /**
    * @param {TensorI16} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI16}
    */
    subtraction(other: TensorI16, alpha: number, beta: number): TensorI16;
    /**
    * @param {TensorI16} other
    * @param {number} alpha
    * @returns {TensorI16}
    */
    multiply(other: TensorI16, alpha: number): TensorI16;
    /**
    * @param {TensorI16} other
    * @param {number} alpha
    * @returns {TensorI16}
    */
    divide(other: TensorI16, alpha: number): TensorI16;
    /**
    * @param {number} min
    * @param {number} max
    * @param {TensorI16} grad
    * @returns {TensorI16}
    */
    clip_backward(min: number, max: number, grad: TensorI16): TensorI16;
    /**
    * @param {number} min
    * @param {TensorI16} grad
    * @returns {TensorI16}
    */
    clip_min_backward(min: number, grad: TensorI16): TensorI16;
    /**
    * @param {number} max
    * @param {TensorI16} grad
    * @returns {TensorI16}
    */
    clip_max_backward(max: number, grad: TensorI16): TensorI16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    sum(axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    sum_square(axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    product(axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    max(axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    min(axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    reduce_mean(axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    reduce_mean_square(axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {TensorI16} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorI16}
    */
    conv(kernel: TensorI16, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorI16;
    /**
    * @param {TensorI16} kernel
    * @param {TensorI16} bias
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorI16}
    */
    conv_with_bias(kernel: TensorI16, bias: TensorI16, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorI16;
    /**
    * @param {TensorI16} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @returns {TensorI16}
    */
    conv_transpose(kernel: TensorI16, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array): TensorI16;
    /**
    * @param {Uint32Array} kernel_shape
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {boolean} include_pad
    * @returns {TensorI16}
    */
    average_pool(kernel_shape: Uint32Array, pads: Uint32Array, strides: Uint32Array, include_pad: boolean): TensorI16;
    /**
    * @param {Uint32Array} pads
    * @param {number} mode
    * @param {number} value
    * @returns {TensorI16}
    */
    pad(pads: Uint32Array, mode: number, value: number): TensorI16;
    /**
    * @param {Float32Array} scales
    * @returns {TensorI16}
    */
    upsample(scales: Float32Array): TensorI16;
    /**
    * @param {TensorI16} other
    * @returns {TensorI16}
    */
    matmul(other: TensorI16): TensorI16;
    /**
    * @param {TensorI16} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @returns {TensorI16}
    */
    gemm(other: TensorI16, a_transpose: boolean, b_transpose: boolean, alpha: number): TensorI16;
    /**
    * @param {TensorI16} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @param {TensorI16} c
    * @param {number} beta
    * @returns {TensorI16}
    */
    gemm_with_c(other: TensorI16, a_transpose: boolean, b_transpose: boolean, alpha: number, c: TensorI16, beta: number): TensorI16;
    /**
    * @param {TensorI16} values
    * @param {Uint32Array} starts
    * @returns {TensorI16}
    */
    set_values(values: TensorI16, starts: Uint32Array): TensorI16;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorI16}
    */
    reshape(shape: Uint32Array): TensorI16;
    /**
    * @param {TensorI16} other
    * @param {number} axes
    * @returns {TensorI16}
    */
    concat(other: TensorI16, axes: number): TensorI16;
    /**
    * @param {Uint32Array} permutation
    * @returns {TensorI16}
    */
    transpose(permutation: Uint32Array): TensorI16;
    /**
    * @param {Uint32Array} repeats
    * @returns {TensorI16}
    */
    repeat(repeats: Uint32Array): TensorI16;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorI16}
    */
    expand(shape: Uint32Array): TensorI16;
    /**
    * @returns {TensorI16}
    */
    copy(): TensorI16;
    /**
    * @param {number} axis
    * @param {Uint32Array} indices
    * @param {Uint32Array} indice_shape
    * @returns {TensorI16}
    */
    gather(axis: number, indices: Uint32Array, indice_shape: Uint32Array): TensorI16;
    /**
    * @param {Uint32Array} starts
    * @param {Uint32Array} ends
    * @param {Uint32Array} axis
    * @param {Int32Array} steps
    * @returns {TensorI16}
    */
    slice(starts: Uint32Array, ends: Uint32Array, axis: Uint32Array, steps: Int32Array): TensorI16;
    /**
    * @param {TensorU32} indices
    * @param {TensorI16} b
    * @param {number} m
    * @returns {TensorI16}
    */
    matmul_sparse_dense(indices: TensorU32, b: TensorI16, m: number): TensorI16;
    /**
    * @param {TensorU32} indices
    * @param {TensorI16} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI16}
    */
    add_sparse_dense(indices: TensorU32, b: TensorI16, result_shape: Uint32Array, alpha: number, beta: number): TensorI16;
    /**
    * @param {TensorU32} indices
    * @param {TensorI16} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI16}
    */
    subtract_sparse_dense(indices: TensorU32, b: TensorI16, result_shape: Uint32Array, alpha: number, beta: number): TensorI16;
    /**
    * @param {TensorU32} indices
    * @param {TensorI16} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI16}
    */
    multiply_sparse_dense(indices: TensorU32, b: TensorI16, result_shape: Uint32Array, alpha: number): TensorI16;
    /**
    * @param {TensorU32} indices
    * @param {TensorI16} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI16}
    */
    divide_sparse_dense(indices: TensorU32, b: TensorI16, result_shape: Uint32Array, alpha: number): TensorI16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI16} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI16}
    */
    add_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI16, result_shape: Uint32Array, alpha: number, beta: number): TensorI16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI16} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI16}
    */
    subtract_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI16, result_shape: Uint32Array, alpha: number, beta: number): TensorI16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI16} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI16}
    */
    divide_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI16, result_shape: Uint32Array, alpha: number): TensorI16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI16} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI16}
    */
    multiply_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI16, result_shape: Uint32Array, alpha: number): TensorI16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    sum_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    sum_square_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    reduce_mean_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    product_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    max_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    min_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI16}
    */
    reduce_mean_squared_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI16;
}
/**
*/
export class TensorI32 {
    static __wrap(ptr: any): any;
    /**
    * @param {Uint32Array} shape
    * @param {Int32Array} values
    * @returns {TensorI32}
    */
    static create(shape: Uint32Array, values: Int32Array): TensorI32;
    /**
    * @param {Uint32Array} shape
    * @param {number} value
    * @returns {TensorI32}
    */
    static create_constant(shape: Uint32Array, value: number): TensorI32;
    __destroy_into_raw(): number | undefined;
    ptr: number | undefined;
    free(): void;
    /**
    * @returns {Int32Array}
    */
    get_vals(): Int32Array;
    /**
    * @returns {Uint32Array}
    */
    get_shape(): Uint32Array;
    /**
    * @param {number} power
    * @param {number} factor
    * @returns {TensorI32}
    */
    power_scalar(power: number, factor: number): TensorI32;
    /**
    * @returns {TensorI32}
    */
    abs(): TensorI32;
    /**
    * @returns {TensorI32}
    */
    sign(): TensorI32;
    /**
    * @returns {TensorI32}
    */
    negate(): TensorI32;
    /**
    * @param {number} factor
    * @param {number} add
    * @returns {TensorI32}
    */
    add_multiply_scalar(factor: number, add: number): TensorI32;
    /**
    * @param {number} min
    * @param {number} max
    * @returns {TensorI32}
    */
    clip(min: number, max: number): TensorI32;
    /**
    * @param {number} min
    * @returns {TensorI32}
    */
    clip_min(min: number): TensorI32;
    /**
    * @param {number} max
    * @returns {TensorI32}
    */
    clip_max(max: number): TensorI32;
    /**
    * @param {TensorI32} other
    * @returns {TensorI32}
    */
    power(other: TensorI32): TensorI32;
    /**
    * @param {TensorI32} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI32}
    */
    addition(other: TensorI32, alpha: number, beta: number): TensorI32;
    /**
    * @param {TensorI32} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI32}
    */
    subtraction(other: TensorI32, alpha: number, beta: number): TensorI32;
    /**
    * @param {TensorI32} other
    * @param {number} alpha
    * @returns {TensorI32}
    */
    multiply(other: TensorI32, alpha: number): TensorI32;
    /**
    * @param {TensorI32} other
    * @param {number} alpha
    * @returns {TensorI32}
    */
    divide(other: TensorI32, alpha: number): TensorI32;
    /**
    * @param {number} min
    * @param {number} max
    * @param {TensorI32} grad
    * @returns {TensorI32}
    */
    clip_backward(min: number, max: number, grad: TensorI32): TensorI32;
    /**
    * @param {number} min
    * @param {TensorI32} grad
    * @returns {TensorI32}
    */
    clip_min_backward(min: number, grad: TensorI32): TensorI32;
    /**
    * @param {number} max
    * @param {TensorI32} grad
    * @returns {TensorI32}
    */
    clip_max_backward(max: number, grad: TensorI32): TensorI32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    sum(axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    sum_square(axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    product(axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    max(axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    min(axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    reduce_mean(axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    reduce_mean_square(axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {TensorI32} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorI32}
    */
    conv(kernel: TensorI32, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorI32;
    /**
    * @param {TensorI32} kernel
    * @param {TensorI32} bias
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorI32}
    */
    conv_with_bias(kernel: TensorI32, bias: TensorI32, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorI32;
    /**
    * @param {TensorI32} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @returns {TensorI32}
    */
    conv_transpose(kernel: TensorI32, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array): TensorI32;
    /**
    * @param {Uint32Array} kernel_shape
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {boolean} include_pad
    * @returns {TensorI32}
    */
    average_pool(kernel_shape: Uint32Array, pads: Uint32Array, strides: Uint32Array, include_pad: boolean): TensorI32;
    /**
    * @param {Uint32Arra