import type { ImageDType } from '../dtype.ts';
import { ArrayMap, WeakValueMap } from '../helpers/helpers.ts';
import type { Renderer } from '../renderer/index.ts';
import { MemoryView } from '../helpers/memoryview.ts';
export declare class BufferSpec {
    image?: ImageDType | undefined;
    uncached: boolean;
    cpu_access: boolean;
    host: boolean;
    nolru: boolean;
    external_ptr?: bigint | undefined;
    __name: string;
    _id: bigint;
    static cache: WeakValueMap<bigint, BufferSpec>;
    constructor(image?: ImageDType | undefined, uncached?: boolean, cpu_access?: boolean, host?: boolean, nolru?: boolean, external_ptr?: bigint | undefined);
}
export declare abstract class Allocator<Buf> {
    alloc(size: number, options?: BufferSpec): Buf;
    free(opaque: Buf, size: number, options?: BufferSpec): void;
    abstract _alloc: (size: number, options: BufferSpec) => Buf;
    abstract _free: (opaque: Buf, options: BufferSpec) => void;
    abstract _copyin: (dest: Buf, src: MemoryView) => void;
    abstract _copyout: (dest: MemoryView, src: Buf) => Promise<void> | void;
    _as_buffer: undefined | ((src: Buf) => MemoryView);
    _offset: undefined | ((buf: Buf, size: number, offset: number) => Buf);
    _transfer: undefined | ((dest: any, src: any, sz: number, src_dev: any, dest_dev: any) => void);
}
/**
 * The LRU Allocator is responsible for caching buffers.
 * It ensures that buffers are not freed until it is absolutely necessary, optimizing performance.
 */
export declare abstract class LRUAllocator extends Allocator<MemoryView> {
    cache: ArrayMap<[number, (BufferSpec | undefined)?], MemoryView<"B">[], [[number, (BufferSpec | undefined)?], MemoryView<"B">[]]>;
    alloc: (size: number, options?: BufferSpec) => MemoryView<"B">;
    free_cache: () => void;
    free: (opaque: MemoryView, size: number, options?: BufferSpec) => void;
}
export declare class _MallocAllocator extends LRUAllocator {
    _alloc: (size: number, options: BufferSpec) => MemoryView;
    _as_buffer: (src: MemoryView) => MemoryView<"B">;
    _copyin: (dest: MemoryView, src: MemoryView) => MemoryView<"B">;
    _copyout: (dest: MemoryView, src: MemoryView) => undefined;
    _offset: (buf: MemoryView, size: number, offset: number) => MemoryView<"B">;
    _free: () => never;
}
export declare const MallocAllocator: _MallocAllocator;
export declare const MAP_JIT = 2048;
export type ProgramCallArgs = {
    global_size?: number[];
    local_size?: number[];
    vals?: number[];
};
export declare class Program {
    name: string;
    lib: Uint8Array;
    constructor(name: string, lib: Uint8Array);
    static init: (name: string, lib: Uint8Array) => Promise<Program> | Program;
    call: (bufs: any[], args: ProgramCallArgs, wait: boolean) => Promise<number | undefined> | number | undefined;
}
export declare class CPUProgram extends Program {
    constructor(name: string, lib: Uint8Array);
    call: (bufs: any[], args: ProgramCallArgs, wait?: boolean) => never;
}
export declare class CompileError extends Error {
}
export declare class Compiler {
    cachekey?: string;
    constructor(cachekey?: string);
    compile: (src: string) => Promise<Uint8Array> | Uint8Array;
    compile_cached: (src: string) => Promise<Uint8Array>;
    disassemble: (lib: Uint8Array) => void;
}
export declare class ProfileEvent {
}
export declare class ProfileDeviceEvent extends ProfileEvent {
    device: string;
    comp_tdiff: number;
    copy_tdiff: number;
    constructor(device: string, comp_tdiff?: number, copy_tdiff?: number);
}
export declare class ProfileRangeEvent extends ProfileEvent {
    device: string;
    name: string;
    st: number;
    en: number;
    is_copy: boolean;
    constructor(device: string, name: string, st: number, en: number, is_copy: boolean);
}
export declare class ProfileGraphEntry {
    device: string;
    name: string;
    st_id: number;
    en_id: number;
    is_copy: boolean;
    constructor(device: string, name: string, st_id: number, en_id: number, is_copy: boolean);
}
export declare class ProfileGraphEvent extends ProfileEvent {
    ents: ProfileGraphEntry[];
    deps: number[][];
    sigs: number[];
    constructor(ents: ProfileGraphEntry[], deps: number[][], sigs: number[]);
}
export declare class ProfileResult {
    st?: number | undefined;
    en?: number | undefined;
    constructor(st?: number | undefined, en?: number | undefined);
}
export declare class Compiled {
    device: string;
    allocator?: Allocator<any> | undefined;
    renderer?: Renderer | undefined;
    compiler: Compiler;
    runtime?: typeof Program | undefined;
    graph?: any | undefined;
    static profile_events: ProfileEvent[];
    constructor(device: string, allocator?: Allocator<any> | undefined, renderer?: Renderer | undefined, compiler?: Compiler, runtime?: typeof Program | undefined, graph?: any | undefined);
    init: () => Promise<void>;
    /**
     * Synchronize all pending operations on the device.
     *
     * This method ensures that all previously queued operations on the device have been completed before proceeding.
     */
    synchronize: () => void;
    /**
     * Called at the end of profiling to allow the device to finalize any profiling.
     */
    _at_profile_finalize: () => never;
}