import { BufferView } from 'utilium/buffer';
import { Pointer } from './pointer.js';
import { Void, type Type } from './types.js';
export interface MemoryUsage {
    total: number;
    used: number;
    free: number;
}
/**
 * A generic memory allocator interface.
 */
export interface Memory<T extends ArrayBufferLike, U extends MemoryUsage = MemoryUsage> extends ArrayBufferView<T> {
    /**
     * The total size in bytes of this memory.
     */
    readonly size: number;
    /**
     * Returns the usage of this memory.
     */
    usage(): U;
    /**
     * Allocates `size` bytes of memory.
     */
    alloc(size: number): Pointer<any>;
    /**
     * Frees a section of memory.
     */
    free(addr: number | Pointer<any>): void;
    /**
     * Reallocates a section of memory.
     */
    realloc<T extends Type = Void>(addr: number | Pointer<T>, size: number): Pointer<T>;
    /**
     * Useful for memory that supports multiple buffers.
     * This returns the buffer, offset in the buffer, and remaining length at a given address.
     */
    at(addr: number): ArrayBufferView<T>;
}
/**
 * Keeps track of the last `Memory` instance created.
 * This is used as defaults for various interfaces.
 * @internal
 */
export declare let _lastMemory: Memory<any> | undefined;
export interface Section {
    size: number;
    isFree: boolean;
}
/**
 * A memory manager that works with a single array buffer.
 * It is not designed for use-cases involving multiple realms or serialization.
 */
export declare class ArrayBufferMemory<T extends ArrayBufferLike> extends BufferView<T> implements Memory<T> {
    get size(): number;
    /**
     * A map of offsets to sections.
     * Spare arrays are used for auto-sort and other "magic".
     */
    protected map: Section[];
    constructor(buffer?: T | ArrayBufferView<T> | ArrayLike<number> | number, byteOffset?: number, byteLength?: number);
    /**
     * Collects all free sections that are adjacent to the section at the given address.
     *
     * @remarks
     * This function assumes the provided section exists in the map.
     */
    protected collectFreeSections(at: number | Pointer<any>): void;
    alloc(size: number): Pointer<Void>;
    free(addr: number | Pointer<any>): void;
    realloc<T extends Type = Void>(at: number | Pointer<T>, size: number): Pointer<T>;
    usage(): MemoryUsage;
    at(addr: number): Uint8Array<T>;
}