/**
*/
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 {Uint32Array} pads
    * @param {number} mode
    * @param {number} value
    * @returns {TensorI32}
    */
    pad(pads: Uint32Array, mode: number, value: number): TensorI32;
    /**
    * @param {Float32Array} scales
    * @returns {TensorI32}
    */
    upsample(scales: Float32Array): TensorI32;
    /**
    * @param {TensorI32} other
    * @returns {TensorI32}
    */
    matmul(other: TensorI32): TensorI32;
    /**
    * @param {TensorI32} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @returns {TensorI32}
    */
    gemm(other: TensorI32, a_transpose: boolean, b_transpose: boolean, alpha: number): TensorI32;
    /**
    * @param {TensorI32} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @param {TensorI32} c
    * @param {number} beta
    * @returns {TensorI32}
    */
    gemm_with_c(other: TensorI32, a_transpose: boolean, b_transpose: boolean, alpha: number, c: TensorI32, beta: number): TensorI32;
    /**
    * @param {TensorI32} values
    * @param {Uint32Array} starts
    * @returns {TensorI32}
    */
    set_values(values: TensorI32, starts: Uint32Array): TensorI32;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorI32}
    */
    reshape(shape: Uint32Array): TensorI32;
    /**
    * @param {TensorI32} other
    * @param {number} axes
    * @returns {TensorI32}
    */
    concat(other: TensorI32, axes: number): TensorI32;
    /**
    * @param {Uint32Array} permutation
    * @returns {TensorI32}
    */
    transpose(permutation: Uint32Array): TensorI32;
    /**
    * @param {Uint32Array} repeats
    * @returns {TensorI32}
    */
    repeat(repeats: Uint32Array): TensorI32;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorI32}
    */
    expand(shape: Uint32Array): TensorI32;
    /**
    * @returns {TensorI32}
    */
    copy(): TensorI32;
    /**
    * @param {number} axis
    * @param {Uint32Array} indices
    * @param {Uint32Array} indice_shape
    * @returns {TensorI32}
    */
    gather(axis: number, indices: Uint32Array, indice_shape: Uint32Array): TensorI32;
    /**
    * @param {Uint32Array} starts
    * @param {Uint32Array} ends
    * @param {Uint32Array} axis
    * @param {Int32Array} steps
    * @returns {TensorI32}
    */
    slice(starts: Uint32Array, ends: Uint32Array, axis: Uint32Array, steps: Int32Array): TensorI32;
    /**
    * @param {TensorU32} indices
    * @param {TensorI32} b
    * @param {number} m
    * @returns {TensorI32}
    */
    matmul_sparse_dense(indices: TensorU32, b: TensorI32, m: number): TensorI32;
    /**
    * @param {TensorU32} indices
    * @param {TensorI32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI32}
    */
    add_sparse_dense(indices: TensorU32, b: TensorI32, result_shape: Uint32Array, alpha: number, beta: number): TensorI32;
    /**
    * @param {TensorU32} indices
    * @param {TensorI32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI32}
    */
    subtract_sparse_dense(indices: TensorU32, b: TensorI32, result_shape: Uint32Array, alpha: number, beta: number): TensorI32;
    /**
    * @param {TensorU32} indices
    * @param {TensorI32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI32}
    */
    multiply_sparse_dense(indices: TensorU32, b: TensorI32, result_shape: Uint32Array, alpha: number): TensorI32;
    /**
    * @param {TensorU32} indices
    * @param {TensorI32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI32}
    */
    divide_sparse_dense(indices: TensorU32, b: TensorI32, result_shape: Uint32Array, alpha: number): TensorI32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI32}
    */
    add_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI32, result_shape: Uint32Array, alpha: number, beta: number): TensorI32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI32}
    */
    subtract_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI32, result_shape: Uint32Array, alpha: number, beta: number): TensorI32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI32}
    */
    divide_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI32, result_shape: Uint32Array, alpha: number): TensorI32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI32}
    */
    multiply_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI32, result_shape: Uint32Array, alpha: number): TensorI32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    sum_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    sum_square_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    reduce_mean_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    product_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    max_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    min_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI32}
    */
    reduce_mean_squared_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI32;
}
/**
*/
export class TensorI8 {
    static __wrap(ptr: any): any;
    /**
    * @param {Uint32Array} shape
    * @param {Int8Array} values
    * @returns {TensorI8}
    */
    static create(shape: Uint32Array, values: Int8Array): TensorI8;
    /**
    * @param {Uint32Array} shape
    * @param {number} value
    * @returns {TensorI8}
    */
    static create_constant(shape: Uint32Array, value: number): TensorI8;
    __destroy_into_raw(): number | undefined;
    ptr: number | undefined;
    free(): void;
    /**
    * @returns {Int8Array}
    */
    get_vals(): Int8Array;
    /**
    * @returns {Uint32Array}
    */
    get_shape(): Uint32Array;
    /**
    * @param {number} power
    * @param {number} factor
    * @returns {TensorI8}
    */
    power_scalar(power: number, factor: number): TensorI8;
    /**
    * @returns {TensorI8}
    */
    abs(): TensorI8;
    /**
    * @returns {TensorI8}
    */
    sign(): TensorI8;
    /**
    * @returns {TensorI8}
    */
    negate(): TensorI8;
    /**
    * @param {number} factor
    * @param {number} add
    * @returns {TensorI8}
    */
    add_multiply_scalar(factor: number, add: number): TensorI8;
    /**
    * @param {number} min
    * @param {number} max
    * @returns {TensorI8}
    */
    clip(min: number, max: number): TensorI8;
    /**
    * @param {number} min
    * @returns {TensorI8}
    */
    clip_min(min: number): TensorI8;
    /**
    * @param {number} max
    * @returns {TensorI8}
    */
    clip_max(max: number): TensorI8;
    /**
    * @param {TensorI8} other
    * @returns {TensorI8}
    */
    power(other: TensorI8): TensorI8;
    /**
    * @param {TensorI8} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI8}
    */
    addition(other: TensorI8, alpha: number, beta: number): TensorI8;
    /**
    * @param {TensorI8} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI8}
    */
    subtraction(other: TensorI8, alpha: number, beta: number): TensorI8;
    /**
    * @param {TensorI8} other
    * @param {number} alpha
    * @returns {TensorI8}
    */
    multiply(other: TensorI8, alpha: number): TensorI8;
    /**
    * @param {TensorI8} other
    * @param {number} alpha
    * @returns {TensorI8}
    */
    divide(other: TensorI8, alpha: number): TensorI8;
    /**
    * @param {number} min
    * @param {number} max
    * @param {TensorI8} grad
    * @returns {TensorI8}
    */
    clip_backward(min: number, max: number, grad: TensorI8): TensorI8;
    /**
    * @param {number} min
    * @param {TensorI8} grad
    * @returns {TensorI8}
    */
    clip_min_backward(min: number, grad: TensorI8): TensorI8;
    /**
    * @param {number} max
    * @param {TensorI8} grad
    * @returns {TensorI8}
    */
    clip_max_backward(max: number, grad: TensorI8): TensorI8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    sum(axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    sum_square(axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    product(axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    max(axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    min(axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    reduce_mean(axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    reduce_mean_square(axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {TensorI8} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorI8}
    */
    conv(kernel: TensorI8, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorI8;
    /**
    * @param {TensorI8} kernel
    * @param {TensorI8} bias
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorI8}
    */
    conv_with_bias(kernel: TensorI8, bias: TensorI8, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorI8;
    /**
    * @param {TensorI8} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @returns {TensorI8}
    */
    conv_transpose(kernel: TensorI8, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array): TensorI8;
    /**
    * @param {Uint32Array} kernel_shape
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {boolean} include_pad
    * @returns {TensorI8}
    */
    average_pool(kernel_shape: Uint32Array, pads: Uint32Array, strides: Uint32Array, include_pad: boolean): TensorI8;
    /**
    * @param {Uint32Array} pads
    * @param {number} mode
    * @param {number} value
    * @returns {TensorI8}
    */
    pad(pads: Uint32Array, mode: number, value: number): TensorI8;
    /**
    * @param {Float32Array} scales
    * @returns {TensorI8}
    */
    upsample(scales: Float32Array): TensorI8;
    /**
    * @param {TensorI8} other
    * @returns {TensorI8}
    */
    matmul(other: TensorI8): TensorI8;
    /**
    * @param {TensorI8} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @returns {TensorI8}
    */
    gemm(other: TensorI8, a_transpose: boolean, b_transpose: boolean, alpha: number): TensorI8;
    /**
    * @param {TensorI8} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @param {TensorI8} c
    * @param {number} beta
    * @returns {TensorI8}
    */
    gemm_with_c(other: TensorI8, a_transpose: boolean, b_transpose: boolean, alpha: number, c: TensorI8, beta: number): TensorI8;
    /**
    * @param {TensorI8} values
    * @param {Uint32Array} starts
    * @returns {TensorI8}
    */
    set_values(values: TensorI8, starts: Uint32Array): TensorI8;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorI8}
    */
    reshape(shape: Uint32Array): TensorI8;
    /**
    * @param {TensorI8} other
    * @param {number} axes
    * @returns {TensorI8}
    */
    concat(other: TensorI8, axes: number): TensorI8;
    /**
    * @param {Uint32Array} permutation
    * @returns {TensorI8}
    */
    transpose(permutation: Uint32Array): TensorI8;
    /**
    * @param {Uint32Array} repeats
    * @returns {TensorI8}
    */
    repeat(repeats: Uint32Array): TensorI8;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorI8}
    */
    expand(shape: Uint32Array): TensorI8;
    /**
    * @returns {TensorI8}
    */
    copy(): TensorI8;
    /**
    * @param {number} axis
    * @param {Uint32Array} indices
    * @param {Uint32Array} indice_shape
    * @returns {TensorI8}
    */
    gather(axis: number, indices: Uint32Array, indice_shape: Uint32Array): TensorI8;
    /**
    * @param {Uint32Array} starts
    * @param {Uint32Array} ends
    * @param {Uint32Array} axis
    * @param {Int32Array} steps
    * @returns {TensorI8}
    */
    slice(starts: Uint32Array, ends: Uint32Array, axis: Uint32Array, steps: Int32Array): TensorI8;
    /**
    * @param {TensorU32} indices
    * @param {TensorI8} b
    * @param {number} m
    * @returns {TensorI8}
    */
    matmul_sparse_dense(indices: TensorU32, b: TensorI8, m: number): TensorI8;
    /**
    * @param {TensorU32} indices
    * @param {TensorI8} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI8}
    */
    add_sparse_dense(indices: TensorU32, b: TensorI8, result_shape: Uint32Array, alpha: number, beta: number): TensorI8;
    /**
    * @param {TensorU32} indices
    * @param {TensorI8} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI8}
    */
    subtract_sparse_dense(indices: TensorU32, b: TensorI8, result_shape: Uint32Array, alpha: number, beta: number): TensorI8;
    /**
    * @param {TensorU32} indices
    * @param {TensorI8} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI8}
    */
    multiply_sparse_dense(indices: TensorU32, b: TensorI8, result_shape: Uint32Array, alpha: number): TensorI8;
    /**
    * @param {TensorU32} indices
    * @param {TensorI8} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI8}
    */
    divide_sparse_dense(indices: TensorU32, b: TensorI8, result_shape: Uint32Array, alpha: number): TensorI8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI8} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI8}
    */
    add_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI8, result_shape: Uint32Array, alpha: number, beta: number): TensorI8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI8} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorI8}
    */
    subtract_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI8, result_shape: Uint32Array, alpha: number, beta: number): TensorI8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI8} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI8}
    */
    divide_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI8, result_shape: Uint32Array, alpha: number): TensorI8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorI8} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorI8}
    */
    multiply_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorI8, result_shape: Uint32Array, alpha: number): TensorI8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    sum_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    sum_square_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    reduce_mean_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    product_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    max_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    min_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorI8}
    */
    reduce_mean_squared_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorI8;
}
/**
*/
export class TensorU16 {
    static __wrap(ptr: any): any;
    /**
    * @param {Uint32Array} shape
    * @param {Uint16Array} values
    * @returns {TensorU16}
    */
    static create(shape: Uint32Array, values: Uint16Array): TensorU16;
    /**
    * @param {Uint32Array} shape
    * @param {number} value
    * @returns {TensorU16}
    */
    static create_constant(shape: Uint32Array, value: number): TensorU16;
    __destroy_into_raw(): number | undefined;
    ptr: number | undefined;
    free(): void;
    /**
    * @returns {Uint16Array}
    */
    get_vals(): Uint16Array;
    /**
    * @returns {Uint32Array}
    */
    get_shape(): Uint32Array;
    /**
    * @param {number} power
    * @param {number} factor
    * @returns {TensorU16}
    */
    power_scalar(power: number, factor: number): TensorU16;
    /**
    * @param {number} factor
    * @param {number} add
    * @returns {TensorU16}
    */
    add_multiply_scalar(factor: number, add: number): TensorU16;
    /**
    * @param {number} min
    * @param {number} max
    * @returns {TensorU16}
    */
    clip(min: number, max: number): TensorU16;
    /**
    * @param {number} min
    * @returns {TensorU16}
    */
    clip_min(min: number): TensorU16;
    /**
    * @param {number} max
    * @returns {TensorU16}
    */
    clip_max(max: number): TensorU16;
    /**
    * @param {TensorU16} other
    * @returns {TensorU16}
    */
    power(other: TensorU16): TensorU16;
    /**
    * @param {TensorU16} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU16}
    */
    addition(other: TensorU16, alpha: number, beta: number): TensorU16;
    /**
    * @param {TensorU16} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU16}
    */
    subtraction(other: TensorU16, alpha: number, beta: number): TensorU16;
    /**
    * @param {TensorU16} other
    * @param {number} alpha
    * @returns {TensorU16}
    */
    multiply(other: TensorU16, alpha: number): TensorU16;
    /**
    * @param {TensorU16} other
    * @param {number} alpha
    * @returns {TensorU16}
    */
    divide(other: TensorU16, alpha: number): TensorU16;
    /**
    * @param {number} min
    * @param {number} max
    * @param {TensorU16} grad
    * @returns {TensorU16}
    */
    clip_backward(min: number, max: number, grad: TensorU16): TensorU16;
    /**
    * @param {number} min
    * @param {TensorU16} grad
    * @returns {TensorU16}
    */
    clip_min_backward(min: number, grad: TensorU16): TensorU16;
    /**
    * @param {number} max
    * @param {TensorU16} grad
    * @returns {TensorU16}
    */
    clip_max_backward(max: number, grad: TensorU16): TensorU16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    sum(axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    sum_square(axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    product(axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    max(axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    min(axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    reduce_mean(axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    reduce_mean_square(axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {TensorU16} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorU16}
    */
    conv(kernel: TensorU16, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorU16;
    /**
    * @param {TensorU16} kernel
    * @param {TensorU16} bias
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorU16}
    */
    conv_with_bias(kernel: TensorU16, bias: TensorU16, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorU16;
    /**
    * @param {TensorU16} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @returns {TensorU16}
    */
    conv_transpose(kernel: TensorU16, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array): TensorU16;
    /**
    * @param {Uint32Array} kernel_shape
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {boolean} include_pad
    * @returns {TensorU16}
    */
    average_pool(kernel_shape: Uint32Array, pads: Uint32Array, strides: Uint32Array, include_pad: boolean): TensorU16;
    /**
    * @param {Uint32Array} pads
    * @param {number} mode
    * @param {number} value
    * @returns {TensorU16}
    */
    pad(pads: Uint32Array, mode: number, value: number): TensorU16;
    /**
    * @param {Float32Array} scales
    * @returns {TensorU16}
    */
    upsample(scales: Float32Array): TensorU16;
    /**
    * @param {TensorU16} other
    * @returns {TensorU16}
    */
    matmul(other: TensorU16): TensorU16;
    /**
    * @param {TensorU16} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @returns {TensorU16}
    */
    gemm(other: TensorU16, a_transpose: boolean, b_transpose: boolean, alpha: number): TensorU16;
    /**
    * @param {TensorU16} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @param {TensorU16} c
    * @param {number} beta
    * @returns {TensorU16}
    */
    gemm_with_c(other: TensorU16, a_transpose: boolean, b_transpose: boolean, alpha: number, c: TensorU16, beta: number): TensorU16;
    /**
    * @param {TensorU16} values
    * @param {Uint32Array} starts
    * @returns {TensorU16}
    */
    set_values(values: TensorU16, starts: Uint32Array): TensorU16;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorU16}
    */
    reshape(shape: Uint32Array): TensorU16;
    /**
    * @param {TensorU16} other
    * @param {number} axes
    * @returns {TensorU16}
    */
    concat(other: TensorU16, axes: number): TensorU16;
    /**
    * @param {Uint32Array} permutation
    * @returns {TensorU16}
    */
    transpose(permutation: Uint32Array): TensorU16;
    /**
    * @param {Uint32Array} repeats
    * @returns {TensorU16}
    */
    repeat(repeats: Uint32Array): TensorU16;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorU16}
    */
    expand(shape: Uint32Array): TensorU16;
    /**
    * @returns {TensorU16}
    */
    copy(): TensorU16;
    /**
    * @param {number} axis
    * @param {Uint32Array} indices
    * @param {Uint32Array} indice_shape
    * @returns {TensorU16}
    */
    gather(axis: number, indices: Uint32Array, indice_shape: Uint32Array): TensorU16;
    /**
    * @param {Uint32Array} starts
    * @param {Uint32Array} ends
    * @param {Uint32Array} axis
    * @param {Int32Array} steps
    * @returns {TensorU16}
    */
    slice(starts: Uint32Array, ends: Uint32Array, axis: Uint32Array, steps: Int32Array): TensorU16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU16} b
    * @param {number} m
    * @returns {TensorU16}
    */
    matmul_sparse_dense(indices: TensorU32, b: TensorU16, m: number): TensorU16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU16} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU16}
    */
    add_sparse_dense(indices: TensorU32, b: TensorU16, result_shape: Uint32Array, alpha: number, beta: number): TensorU16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU16} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU16}
    */
    subtract_sparse_dense(indices: TensorU32, b: TensorU16, result_shape: Uint32Array, alpha: number, beta: number): TensorU16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU16} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU16}
    */
    multiply_sparse_dense(indices: TensorU32, b: TensorU16, result_shape: Uint32Array, alpha: number): TensorU16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU16} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU16}
    */
    divide_sparse_dense(indices: TensorU32, b: TensorU16, result_shape: Uint32Array, alpha: number): TensorU16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU16} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU16}
    */
    add_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU16, result_shape: Uint32Array, alpha: number, beta: number): TensorU16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU16} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU16}
    */
    subtract_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU16, result_shape: Uint32Array, alpha: number, beta: number): TensorU16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU16} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU16}
    */
    divide_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU16, result_shape: Uint32Array, alpha: number): TensorU16;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU16} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU16}
    */
    multiply_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU16, result_shape: Uint32Array, alpha: number): TensorU16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    sum_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    sum_square_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    reduce_mean_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    product_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    max_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    min_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU16;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU16}
    */
    reduce_mean_squared_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU16;
}
/**
*/
export class TensorU32 {
    static __wrap(ptr: any): any;
    /**
    * @param {Uint32Array} shape
    * @param {Uint32Array} values
    * @returns {TensorU32}
    */
    static create(shape: Uint32Array, values: Uint32Array): TensorU32;
    /**
    * @param {Uint32Array} shape
    * @param {number} value
    * @returns {TensorU32}
    */
    static create_constant(shape: Uint32Array, value: number): TensorU32;
    __destroy_into_raw(): number | undefined;
    ptr: number | undefined;
    free(): void;
    /**
    * @returns {Uint32Array}
    */
    get_vals(): Uint32Array;
    /**
    * @returns {Uint32Array}
    */
    get_shape(): Uint32Array;
    /**
    * @param {number} power
    * @param {number} factor
    * @returns {TensorU32}
    */
    power_scalar(power: number, factor: number): TensorU32;
    /**
    * @param {number} factor
    * @param {number} add
    * @returns {TensorU32}
    */
    add_multiply_scalar(factor: number, add: number): TensorU32;
    /**
    * @param {number} min
    * @param {number} max
    * @returns {TensorU32}
    */
    clip(min: number, max: number): TensorU32;
    /**
    * @param {number} min
    * @returns {TensorU32}
    */
    clip_min(min: number): TensorU32;
    /**
    * @param {number} max
    * @returns {TensorU32}
    */
    clip_max(max: number): TensorU32;
    /**
    * @param {TensorU32} other
    * @returns {TensorU32}
    */
    power(other: TensorU32): TensorU32;
    /**
    * @param {TensorU32} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU32}
    */
    addition(other: TensorU32, alpha: number, beta: number): TensorU32;
    /**
    * @param {TensorU32} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU32}
    */
    subtraction(other: TensorU32, alpha: number, beta: number): TensorU32;
    /**
    * @param {TensorU32} other
    * @param {number} alpha
    * @returns {TensorU32}
    */
    multiply(other: TensorU32, alpha: number): TensorU32;
    /**
    * @param {TensorU32} other
    * @param {number} alpha
    * @returns {TensorU32}
    */
    divide(other: TensorU32, alpha: number): TensorU32;
    /**
    * @param {number} min
    * @param {number} max
    * @param {TensorU32} grad
    * @returns {TensorU32}
    */
    clip_backward(min: number, max: number, grad: TensorU32): TensorU32;
    /**
    * @param {number} min
    * @param {TensorU32} grad
    * @returns {TensorU32}
    */
    clip_min_backward(min: number, grad: TensorU32): TensorU32;
    /**
    * @param {number} max
    * @param {TensorU32} grad
    * @returns {TensorU32}
    */
    clip_max_backward(max: number, grad: TensorU32): TensorU32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    sum(axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    sum_square(axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    product(axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    max(axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    min(axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    reduce_mean(axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    reduce_mean_square(axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {TensorU32} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorU32}
    */
    conv(kernel: TensorU32, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorU32;
    /**
    * @param {TensorU32} kernel
    * @param {TensorU32} bias
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorU32}
    */
    conv_with_bias(kernel: TensorU32, bias: TensorU32, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorU32;
    /**
    * @param {TensorU32} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @returns {TensorU32}
    */
    conv_transpose(kernel: TensorU32, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array): TensorU32;
    /**
    * @param {Uint32Array} kernel_shape
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {boolean} include_pad
    * @returns {TensorU32}
    */
    average_pool(kernel_shape: Uint32Array, pads: Uint32Array, strides: Uint32Array, include_pad: boolean): TensorU32;
    /**
    * @param {Uint32Array} pads
    * @param {number} mode
    * @param {number} value
    * @returns {TensorU32}
    */
    pad(pads: Uint32Array, mode: number, value: number): TensorU32;
    /**
    * @param {Float32Array} scales
    * @returns {TensorU32}
    */
    upsample(scales: Float32Array): TensorU32;
    /**
    * @param {TensorU32} other
    * @returns {TensorU32}
    */
    matmul(other: TensorU32): TensorU32;
    /**
    * @param {TensorU32} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @returns {TensorU32}
    */
    gemm(other: TensorU32, a_transpose: boolean, b_transpose: boolean, alpha: number): TensorU32;
    /**
    * @param {TensorU32} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @param {TensorU32} c
    * @param {number} beta
    * @returns {TensorU32}
    */
    gemm_with_c(other: TensorU32, a_transpose: boolean, b_transpose: boolean, alpha: number, c: TensorU32, beta: number): TensorU32;
    /**
    * @param {TensorU32} values
    * @param {Uint32Array} starts
    * @returns {TensorU32}
    */
    set_values(values: TensorU32, starts: Uint32Array): TensorU32;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorU32}
    */
    reshape(shape: Uint32Array): TensorU32;
    /**
    * @param {TensorU32} other
    * @param {number} axes
    * @returns {TensorU32}
    */
    concat(other: TensorU32, axes: number): TensorU32;
    /**
    * @param {Uint32Array} permutation
    * @returns {TensorU32}
    */
    transpose(permutation: Uint32Array): TensorU32;
    /**
    * @param {Uint32Array} repeats
    * @returns {TensorU32}
    */
    repeat(repeats: Uint32Array): TensorU32;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorU32}
    */
    expand(shape: Uint32Array): TensorU32;
    /**
    * @returns {TensorU32}
    */
    copy(): TensorU32;
    /**
    * @param {number} axis
    * @param {Uint32Array} indices
    * @param {Uint32Array} indice_shape
    * @returns {TensorU32}
    */
    gather(axis: number, indices: Uint32Array, indice_shape: Uint32Array): TensorU32;
    /**
    * @param {Uint32Array} starts
    * @param {Uint32Array} ends
    * @param {Uint32Array} axis
    * @param {Int32Array} steps
    * @returns {TensorU32}
    */
    slice(starts: Uint32Array, ends: Uint32Array, axis: Uint32Array, steps: Int32Array): TensorU32;
    /**
    * @param {Uint32Array} old_sparse_shape
    * @param {Uint32Array} new_shape
    * @returns {TensorU32}
    */
    reshape_sparse_indices(old_sparse_shape: Uint32Array, new_shape: Uint32Array): TensorU32;
    /**
    * @param {number} axis
    * @param {number} count
    * @returns {TensorU32}
    */
    add_index(axis: number, count: number): TensorU32;
    /**
    * @param {Uint32Array} repeats
    * @param {Uint32Array} shape
    * @param {number} repeats_prod
    * @returns {TensorU32}
    */
    repeat_sparse_indices(repeats: Uint32Array, shape: Uint32Array, repeats_prod: number): TensorU32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b
    * @param {number} m
    * @returns {TensorU32}
    */
    matmul_sparse_dense(indices: TensorU32, b: TensorU32, m: number): TensorU32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU32}
    */
    add_sparse_dense(indices: TensorU32, b: TensorU32, result_shape: Uint32Array, alpha: number, beta: number): TensorU32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU32}
    */
    subtract_sparse_dense(indices: TensorU32, b: TensorU32, result_shape: Uint32Array, alpha: number, beta: number): TensorU32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU32}
    */
    multiply_sparse_dense(indices: TensorU32, b: TensorU32, result_shape: Uint32Array, alpha: number): TensorU32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU32}
    */
    divide_sparse_dense(indices: TensorU32, b: TensorU32, result_shape: Uint32Array, alpha: number): TensorU32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU32}
    */
    add_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU32, result_shape: Uint32Array, alpha: number, beta: number): TensorU32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU32}
    */
    subtract_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU32, result_shape: Uint32Array, alpha: number, beta: number): TensorU32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU32}
    */
    divide_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU32, result_shape: Uint32Array, alpha: number): TensorU32;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU32} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU32}
    */
    multiply_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU32, result_shape: Uint32Array, alpha: number): TensorU32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    sum_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    sum_square_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    reduce_mean_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    product_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    max_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    min_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU32;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU32}
    */
    reduce_mean_squared_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU32;
}
/**
*/
export class TensorU8 {
    static __wrap(ptr: any): any;
    /**
    * @param {Uint32Array} shape
    * @param {Uint8Array} values
    * @returns {TensorU8}
    */
    static create(shape: Uint32Array, values: Uint8Array): TensorU8;
    /**
    * @param {Uint32Array} shape
    * @param {number} value
    * @returns {TensorU8}
    */
    static create_constant(shape: Uint32Array, value: number): TensorU8;
    __destroy_into_raw(): number | undefined;
    ptr: number | undefined;
    free(): void;
    /**
    * @returns {Uint8Array}
    */
    get_vals(): Uint8Array;
    /**
    * @returns {Uint32Array}
    */
    get_shape(): Uint32Array;
    /**
    * @param {number} power
    * @param {number} factor
    * @returns {TensorU8}
    */
    power_scalar(power: number, factor: number): TensorU8;
    /**
    * @param {number} factor
    * @param {number} add
    * @returns {TensorU8}
    */
    add_multiply_scalar(factor: number, add: number): TensorU8;
    /**
    * @param {number} min
    * @param {number} max
    * @returns {TensorU8}
    */
    clip(min: number, max: number): TensorU8;
    /**
    * @param {number} min
    * @returns {TensorU8}
    */
    clip_min(min: number): TensorU8;
    /**
    * @param {number} max
    * @returns {TensorU8}
    */
    clip_max(max: number): TensorU8;
    /**
    * @param {TensorU8} other
    * @returns {TensorU8}
    */
    power(other: TensorU8): TensorU8;
    /**
    * @param {TensorU8} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU8}
    */
    addition(other: TensorU8, alpha: number, beta: number): TensorU8;
    /**
    * @param {TensorU8} other
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU8}
    */
    subtraction(other: TensorU8, alpha: number, beta: number): TensorU8;
    /**
    * @param {TensorU8} other
    * @param {number} alpha
    * @returns {TensorU8}
    */
    multiply(other: TensorU8, alpha: number): TensorU8;
    /**
    * @param {TensorU8} other
    * @param {number} alpha
    * @returns {TensorU8}
    */
    divide(other: TensorU8, alpha: number): TensorU8;
    /**
    * @param {number} min
    * @param {number} max
    * @param {TensorU8} grad
    * @returns {TensorU8}
    */
    clip_backward(min: number, max: number, grad: TensorU8): TensorU8;
    /**
    * @param {number} min
    * @param {TensorU8} grad
    * @returns {TensorU8}
    */
    clip_min_backward(min: number, grad: TensorU8): TensorU8;
    /**
    * @param {number} max
    * @param {TensorU8} grad
    * @returns {TensorU8}
    */
    clip_max_backward(max: number, grad: TensorU8): TensorU8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    sum(axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    sum_square(axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    product(axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    max(axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    min(axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    reduce_mean(axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    reduce_mean_square(axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {TensorU8} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorU8}
    */
    conv(kernel: TensorU8, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorU8;
    /**
    * @param {TensorU8} kernel
    * @param {TensorU8} bias
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {number} activation
    * @returns {TensorU8}
    */
    conv_with_bias(kernel: TensorU8, bias: TensorU8, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array, activation: number): TensorU8;
    /**
    * @param {TensorU8} kernel
    * @param {Uint32Array} dilations
    * @param {number} group
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @returns {TensorU8}
    */
    conv_transpose(kernel: TensorU8, dilations: Uint32Array, group: number, pads: Uint32Array, strides: Uint32Array): TensorU8;
    /**
    * @param {Uint32Array} kernel_shape
    * @param {Uint32Array} pads
    * @param {Uint32Array} strides
    * @param {boolean} include_pad
    * @returns {TensorU8}
    */
    average_pool(kernel_shape: Uint32Array, pads: Uint32Array, strides: Uint32Array, include_pad: boolean): TensorU8;
    /**
    * @param {Uint32Array} pads
    * @param {number} mode
    * @param {number} value
    * @returns {TensorU8}
    */
    pad(pads: Uint32Array, mode: number, value: number): TensorU8;
    /**
    * @param {Float32Array} scales
    * @returns {TensorU8}
    */
    upsample(scales: Float32Array): TensorU8;
    /**
    * @param {TensorU8} other
    * @returns {TensorU8}
    */
    matmul(other: TensorU8): TensorU8;
    /**
    * @param {TensorU8} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @returns {TensorU8}
    */
    gemm(other: TensorU8, a_transpose: boolean, b_transpose: boolean, alpha: number): TensorU8;
    /**
    * @param {TensorU8} other
    * @param {boolean} a_transpose
    * @param {boolean} b_transpose
    * @param {number} alpha
    * @param {TensorU8} c
    * @param {number} beta
    * @returns {TensorU8}
    */
    gemm_with_c(other: TensorU8, a_transpose: boolean, b_transpose: boolean, alpha: number, c: TensorU8, beta: number): TensorU8;
    /**
    * @param {TensorU8} values
    * @param {Uint32Array} starts
    * @returns {TensorU8}
    */
    set_values(values: TensorU8, starts: Uint32Array): TensorU8;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorU8}
    */
    reshape(shape: Uint32Array): TensorU8;
    /**
    * @param {TensorU8} other
    * @param {number} axes
    * @returns {TensorU8}
    */
    concat(other: TensorU8, axes: number): TensorU8;
    /**
    * @param {Uint32Array} permutation
    * @returns {TensorU8}
    */
    transpose(permutation: Uint32Array): TensorU8;
    /**
    * @param {Uint32Array} repeats
    * @returns {TensorU8}
    */
    repeat(repeats: Uint32Array): TensorU8;
    /**
    * @param {Uint32Array} shape
    * @returns {TensorU8}
    */
    expand(shape: Uint32Array): TensorU8;
    /**
    * @returns {TensorU8}
    */
    copy(): TensorU8;
    /**
    * @param {number} axis
    * @param {Uint32Array} indices
    * @param {Uint32Array} indice_shape
    * @returns {TensorU8}
    */
    gather(axis: number, indices: Uint32Array, indice_shape: Uint32Array): TensorU8;
    /**
    * @param {Uint32Array} starts
    * @param {Uint32Array} ends
    * @param {Uint32Array} axis
    * @param {Int32Array} steps
    * @returns {TensorU8}
    */
    slice(starts: Uint32Array, ends: Uint32Array, axis: Uint32Array, steps: Int32Array): TensorU8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU8} b
    * @param {number} m
    * @returns {TensorU8}
    */
    matmul_sparse_dense(indices: TensorU32, b: TensorU8, m: number): TensorU8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU8} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU8}
    */
    add_sparse_dense(indices: TensorU32, b: TensorU8, result_shape: Uint32Array, alpha: number, beta: number): TensorU8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU8} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU8}
    */
    subtract_sparse_dense(indices: TensorU32, b: TensorU8, result_shape: Uint32Array, alpha: number, beta: number): TensorU8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU8} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU8}
    */
    multiply_sparse_dense(indices: TensorU32, b: TensorU8, result_shape: Uint32Array, alpha: number): TensorU8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU8} b
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU8}
    */
    divide_sparse_dense(indices: TensorU32, b: TensorU8, result_shape: Uint32Array, alpha: number): TensorU8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU8} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU8}
    */
    add_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU8, result_shape: Uint32Array, alpha: number, beta: number): TensorU8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU8} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @param {number} beta
    * @returns {TensorU8}
    */
    subtract_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU8, result_shape: Uint32Array, alpha: number, beta: number): TensorU8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU8} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU8}
    */
    divide_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU8, result_shape: Uint32Array, alpha: number): TensorU8;
    /**
    * @param {TensorU32} indices
    * @param {TensorU32} b_indices
    * @param {TensorU8} b_values
    * @param {Uint32Array} result_shape
    * @param {number} alpha
    * @returns {TensorU8}
    */
    multiply_sparse_sparse(indices: TensorU32, b_indices: TensorU32, b_values: TensorU8, result_shape: Uint32Array, alpha: number): TensorU8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    sum_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    sum_square_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    reduce_mean_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    product_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    max_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    min_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU8;
    /**
    * @param {Uint32Array} shape
    * @param {TensorU32} indices
    * @param {Uint32Array} axes
    * @param {boolean} keep_dims
    * @returns {TensorU8}
    */
    reduce_mean_squared_sparse(shape: Uint32Array, indices: TensorU32, axes: Uint32Array, keep_dims: boolean): TensorU8;
}
export function __wbindgen_object_drop_ref(arg0: any): void;
export function __wbg_length_2db20e5652f1eb59(arg0: any): any;
export function __wbg_length_2a79df4e680048d5(arg0: any): any;
export function __wbg_length_e77849dd07b0e4b5(arg0: any): any;
export function __wbg_length_3a5138f465b971ad(arg0: any): any;
export function __wbg_length_59a5d4644faa0c8c(arg0: any): any;
export function __wbg_length_5e510700137b465e(arg0: any): any;
export function __wbg_length_c190c5ddaeb6db96(arg0: any): any;
export function __wbg_length_ad7b05b022ac71bd(arg0: any): any;
export function __wbg_newwithlength_d117d423ff97cefd(arg0: any): number;
export function __wbg_getindex_69c7c7394025c68f(arg0: any, arg1: any): any;
export function __wbg_setindex_9c30de03e0b63fdc(arg0: any, arg1: any, arg2: any): void;
export function __wbg_newwithlength_c34ef880a456cd52(arg0: any): number;
export function __wbg_getindex_6ef64e03d06e1433(arg0: any, arg1: any): any;
export function __wbg_setindex_85a180ecd90fa77d(arg0: any, arg1: any, arg2: any): void;
export function __wbg_newwithlength_f0f91f2b998757ae(arg0: any): number;
export function __wbg_getindex_6d504eac07f5787d(arg0: any, arg1: any): any;
export function __wbg_setindex_770ea561df838dfe(arg0: any, arg1: any, arg2: any): void;
export function __wbg_newwithlength_19241666d161c55f(arg0: any): number;
export function __wbg_getindex_1605a359263ce318(arg0: any, arg1: any): any;
export function __wbg_setindex_f68392bef584e583(arg0: any, arg1: any, arg2: any): void;
export function __wbg_newwithlength_2ea208e350120be9(arg0: any): number;
export function __wbg_getindex_f868a054f8e08cd0(arg0: any, arg1: any): any;
export function __wbg_setindex_da0bc122908c83e4(arg0: any, arg1: any, arg2: any): void;
export function __wbg_newwithlength_03e1fd5aaabeaa27(arg0: any): number;
export function __wbg_getindex_6ecb10d23c5ae363(arg0: any, arg1: any): any;
export function __wbg_setindex_a0672c0ab2aa3b1c(arg0: any, arg1: any, arg2: any): void;
export function __wbg_newwithlength_b7a8efa36e1aa3c3(arg0: any): number;
export function __wbg_getindex_8ea1aa1211e70399(arg0: any, arg1: any): any;
export function __wbg_setindex_b2937886c6ce1d95(arg0: any, arg1: any, arg2: any): void;
export function __wbg_newwithlength_b7182b9981406137(arg0: any): number;
export function __wbg_getindex_b144d325ab1e7a8e(arg0: any, arg1: any): any;
export function __wbg_setindex_928183e1dc113d65(arg0: any, arg1: any, arg2: any): void;
export function __wbindgen_throw(arg0: any, arg1: any): never;