declare abstract class Buffer {
    constructor(size: number, offset: number);
    setSize(s: number): void;
    setOffset(o: number): void;
    getSize(): number;
    getOffset(): number;
    size_: number;
    offset_: number;
}

interface OpNode {
    props: OpProps;
    attrs: OpAttrs;
    inputs: OpEdge[];
    outputs: OpEdge[];
    hostDataOffset: number;
    data: OpData;
}
interface OpEdge {
    name: string;
    tensorInfo: tensorInfo;
}
interface OpAttrs {
    [key: string]: any;
}
interface OpProps {
    type: string;
    name: string;
}
interface OpData {
    [key: string]: opDataInfo;
}
interface tensorInfo {
    name: string;
    shape: number[];
    precision: number;
    hostData?: number[] | Float32Array;
    deviceData?: Buffer;
}
interface opDataInfo {
    size: number;
    precision: number;
    hostData?: number[] | Float32Array;
    deviceData?: Buffer;
}
interface Model {
    ops: OpNode[];
}
interface ModelConfig {
    modelPath: string;
    modelName?: string;
    binaryDataName?: string;
}
declare enum backend {
    Backend_WebGPU = 0
}
interface backend_config {
    backend_: backend;
    precision_: number;
    modelData_: Model;
    debug?: boolean;
}

type _interface_OpNode = OpNode;
type _interface_OpEdge = OpEdge;
type _interface_OpAttrs = OpAttrs;
type _interface_OpProps = OpProps;
type _interface_OpData = OpData;
type _interface_tensorInfo = tensorInfo;
type _interface_opDataInfo = opDataInfo;
type _interface_Model = Model;
type _interface_ModelConfig = ModelConfig;
type _interface_backend = backend;
declare const _interface_backend: typeof backend;
type _interface_backend_config = backend_config;
declare namespace _interface {
  export {
    _interface_OpNode as OpNode,
    _interface_OpEdge as OpEdge,
    _interface_OpAttrs as OpAttrs,
    _interface_OpProps as OpProps,
    _interface_OpData as OpData,
    _interface_tensorInfo as tensorInfo,
    _interface_opDataInfo as opDataInfo,
    _interface_Model as Model,
    _interface_ModelConfig as ModelConfig,
    _interface_backend as backend,
    _interface_backend_config as backend_config,
  };
}

declare class Executer {
    protected modeConfig_: backend_config;
    ret: number;
    constructor(config: backend_config);
    prepare(): Promise<any>;
    forward(ifGetOutput?: boolean): any | Promise<ArrayBuffer[]>;
    release(): void;
    setInputByArrayBuffer(data: ArrayBuffer[]): number;
    setInputByArray(data: any[] | Array<any>): number;
    setInputByPath(firstName: string, ...restName: string[]): number;
    getArrayBufferOutput(): Promise<ArrayBuffer[]>;
    getInputShapeByIndex(idx: number): any;
    getOutputShapeByIndex(idx: number): any;
    getInputCount(): number;
    getOutputCount(): number;
    finishWork(): Promise<undefined[]>;
}

declare function get_row(): number;
declare function numToString(data: number[]): string;
declare function ppl_res_check(res: number, info: string): void;
declare function ppl_debug(ifDebug: boolean, ...optionalParams: any[]): void;
declare function check_if_undefined(obj: any, info: string): number;
declare function ppl_diff(src: ArrayBuffer, dst: ArrayBuffer, shape: number[]): boolean;

declare const log_get_row: typeof get_row;
declare const log_numToString: typeof numToString;
declare const log_ppl_res_check: typeof ppl_res_check;
declare const log_ppl_debug: typeof ppl_debug;
declare const log_check_if_undefined: typeof check_if_undefined;
declare const log_ppl_diff: typeof ppl_diff;
declare namespace log {
  export {
    log_get_row as get_row,
    log_numToString as numToString,
    log_ppl_res_check as ppl_res_check,
    log_ppl_debug as ppl_debug,
    log_check_if_undefined as check_if_undefined,
    log_ppl_diff as ppl_diff,
  };
}

declare function registerBackend(backend: string, backendInstance: any): void;

declare abstract class Tensor {
    private tensorInfo_;
    private producerCount_;
    private consumerCount_;
    constructor(t: tensorInfo);
    dimCount(): number;
    dim(index: number): number;
    shape(): number[];
    byteLength(): number;
    abstract mallocTensorBuffer(): number;
    abstract releaseTensorBuffer(): number;
    abstract data(): any;
    precision(): number;
    get name(): string;
    set name(name_: string);
    get buffer(): Buffer;
    set buffer(buffer_: Buffer);
    getname(): string;
    setname(name_: string): void;
    getbuffer(): Buffer;
    setbuffer(buffer_: Buffer): void;
    producerCount(): number;
    consumerCount(): number;
    incProducerCount(): void;
    incConsumerCount(): void;
}

declare abstract class Kernel {
    protected name_: string;
    protected type_: string;
    data_: OpData;
    protected param_: OpAttrs;
    protected inTensors_: Tensor[];
    protected outTensors_: Tensor[];
    protected tmpTensor_: Tensor;
    protected inShape_: number[][];
    protected outShape_: number[][];
    constructor(opNode: OpNode);
    abstract releaseKernelResource(): number;
    abstract initKernelParam(): number;
    abstract forward(): number;
    abstract tempBufferSize(): number;
    setTmpTensor(data: Tensor): number;
    set name(name: string);
    set kernelType(kernelType: string);
    get name(): string;
    get kernelType(): string;
    addInTensor(t: Tensor): number;
    addInShape(t: number[]): number;
    addOutTensor(t: Tensor): number;
    addOutShape(t: number[]): number;
    getInTensorCount(): number;
    getOutTensorCount(): number;
    getInTensor(index: number): Tensor;
    getInShape(index: number): number[];
    getOutTensor(index: number): Tensor;
    getOutShape(index: number): number[];
}

declare abstract class Graph {
    protected totalOpNode_: OpNode[];
    protected totalKernel_: Kernel[];
    protected inputTensor_: Tensor[];
    protected outputTensor_: Tensor[];
    protected tmpBufferTensor_: Tensor;
    protected inputData: ArrayBuffer[];
    protected ifDebug: boolean;
    protected inputChanged_: boolean;
    constructor(model: Model);
    abstract buildGraph(): number;
    abstract prepareGraph(): number;
    abstract runGraph(): number;
    abstract finish(): Promise<undefined[]>;
    abstract getArrayBufferOutput(): Promise<ArrayBuffer[]>;
    setIfDebug(ifDebug: boolean): void;
    getIfDebug(): boolean;
    abstract createTensor(info: tensorInfo, isInput: boolean, isOutput: boolean): any;
    assignTensorToKernel(): number;
    assignMemoryToTensor(): number;
    setInputFromArrayBuffer(inData: ArrayBuffer[]): number;
    getInputTensorCount(): number;
    getInputTensor(i: number): Tensor;
    getOutputTensorCount(): number;
    getOutputTensor(i: number): Tensor;
    getKernelCount(): number;
    getKernel(i: number): Kernel;
    getInputTensorShape(idx: number): any;
    getOutputTensorShape(idx: number): any;
    releaseResources(): number;
}

declare abstract class Runtime {
    protected graph_: Graph;
    constructor();
    abstract createGraph(config: backend_config): any;
    abstract prepare(): Promise<number>;
    abstract forward(ifGetOutput?: boolean): any | Promise<ArrayBuffer[]>;
    abstract release(): any;
    setInputByArrayBuffer(data: ArrayBuffer[]): number;
    getArrayBufferOutput(): Promise<ArrayBuffer[]>;
    getInputShapeByIndex(idx: number): any;
    getOutputShapeByIndex(idx: number): any;
    getInputCount(): number;
    getOutputCount(): number;
    finishWork(): Promise<undefined[]>;
}

declare class ModelLoader {
    modelConfig_: ModelConfig;
    isLocalPath: boolean;
    constructor(modelConfig: ModelConfig);
    LoadModel(): Promise<Model>;
    readData(modelPath: string): Promise<unknown>;
    ParseJsonModel(): Promise<Model>;
    ReadModelData(): Promise<Float32Array>;
    AssignData(opModel_: Model, dataArray: Float32Array): void;
}

interface BatchnormParam {
    use_global: boolean;
    moving_average_fraction: number;
    eps: number;
}
interface ConvolutionParam {
    bias_term: boolean;
    dilations: number[];
    kernel_shape: number[];
    pads: number[];
    strides: number[];
    group: number;
    reluFuseType: number;
}
interface ScaleParam {
    axis: number;
    num_axis: number;
    bias: boolean;
}
interface SoftmaxParam {
    axis: number;
}
interface ElewiseParam {
    coeff: number[];
    mode: number;
}
interface PoolingParam {
    window: number[];
    pads: number[];
    stride: number[];
    global_pooling: boolean;
    pooling_mode: number;
    ceil_mode: boolean;
}
interface FcParam {
    num_output: number;
    axis: number;
    bias_term: boolean;
}
interface ChannelShuffleParam {
    group: number;
}
interface SliceParam {
    slice_point: number[];
    axis: number;
}
interface ConcatParam {
    axis: number;
    concat_dim: number;
}
interface PReLUParam {
    channel_shared: boolean;
}
interface SubpixelUpParam {
    upsample: number;
    backend: number;
}
interface SubpixelDownParam {
    downsample: number;
    backend: number;
}
interface TileParam {
    axis: number;
    tiles: number;
}
interface ReflectionPadParam {
    pad_h: number;
    pad_w: number;
}
interface InterpParam {
    interp_width: number;
    interp_height: number;
    zoom_factor: number;
    shrink_factor: number;
    pad_beg: number;
    pad_end: number;
    align_corners: number;
    mode: number;
    backend: number;
}
interface LogParam {
    base: number;
    scale: number;
    shift: number;
}
interface ClipParam {
    max: number;
    min: number;
}

type opParam_BatchnormParam = BatchnormParam;
type opParam_ConvolutionParam = ConvolutionParam;
type opParam_ScaleParam = ScaleParam;
type opParam_SoftmaxParam = SoftmaxParam;
type opParam_ElewiseParam = ElewiseParam;
type opParam_PoolingParam = PoolingParam;
type opParam_FcParam = FcParam;
type opParam_ChannelShuffleParam = ChannelShuffleParam;
type opParam_SliceParam = SliceParam;
type opParam_ConcatParam = ConcatParam;
type opParam_PReLUParam = PReLUParam;
type opParam_SubpixelUpParam = SubpixelUpParam;
type opParam_SubpixelDownParam = SubpixelDownParam;
type opParam_TileParam = TileParam;
type opParam_ReflectionPadParam = ReflectionPadParam;
type opParam_InterpParam = InterpParam;
type opParam_LogParam = LogParam;
type opParam_ClipParam = ClipParam;
declare namespace opParam {
  export {
    opParam_BatchnormParam as BatchnormParam,
    opParam_ConvolutionParam as ConvolutionParam,
    opParam_ScaleParam as ScaleParam,
    opParam_SoftmaxParam as SoftmaxParam,
    opParam_ElewiseParam as ElewiseParam,
    opParam_PoolingParam as PoolingParam,
    opParam_FcParam as FcParam,
    opParam_ChannelShuffleParam as ChannelShuffleParam,
    opParam_SliceParam as SliceParam,
    opParam_ConcatParam as ConcatParam,
    opParam_PReLUParam as PReLUParam,
    opParam_SubpixelUpParam as SubpixelUpParam,
    opParam_SubpixelDownParam as SubpixelDownParam,
    opParam_TileParam as TileParam,
    opParam_ReflectionPadParam as ReflectionPadParam,
    opParam_InterpParam as InterpParam,
    opParam_LogParam as LogParam,
    opParam_ClipParam as ClipParam,
  };
}

export { Buffer, Executer, Graph, Kernel, ModelLoader, Runtime, Tensor, _interface as interfaces, log, opParam as opParams, registerBackend };