export declare class SimpleDataView {
    private _buffer;
    private _view;
    private _offset;
    private _maxSize;
    private _littleEndian;
    private _overflowHandler?;
    constructor(maxSize?: number, littleEndian?: boolean, overflowHandler?: (filledBuffer: ArrayBuffer) => void);
    constructor(buffer: ArrayBuffer, littleEndian?: boolean, overflowHandler?: (filledBuffer: ArrayBuffer) => void);
    get buffer(): ArrayBuffer;
    get fullBuffer(): ArrayBuffer;
    get dataView(): DataView<ArrayBufferLike>;
    get offset(): number;
    /**
     * Zero the write offset so subsequent writes start from the beginning of
     * the underlying buffer. The buffer itself is reused — the `buffer`
     * getter returns a `slice()` (an independent copy), so a previous flush
     * that postMessaged the slice does not affect this buffer's writability.
     *
     * Pre-fix: this method allocated a fresh `ArrayBuffer` of `_maxSize`
     * (10KB on the worker side, 1MB default elsewhere) every time. Combined
     * with the per-flush `slice()` allocation in the getter, that produced
     * two ArrayBuffers per flush — significant GC pressure during a busy
     * UI commit. The underlying buffer never needs reallocation because
     * we never transfer it; only the slice is transferred.
     */
    reset(): void;
    hasSpace(size: number): boolean;
    /**
     * Advance the write offset by `n` bytes without bounds checks. Pairs with
     * direct `dataView` writes after a prior `hasSpace(n)` validated the run.
     * Lets a hot writer skip the per-call `_checkOverflow` + switch dispatch
     * inside `writeXxx` when batching a known, fixed-size record.
     */
    advance(n: number): void;
    shift(size: number): void;
    moveTo(offset: number): void;
    moveBy(delta: number): void;
    readUint8: () => number;
    readUint8At: (offset: number) => number;
    readInt8: () => number;
    readInt8At: (offset: number) => number;
    writeUint8: (value: number) => void;
    writeUint8At: (offset: number, value: number) => void;
    writeInt8: (value: number) => void;
    writeInt8At: (offset: number, value: number) => void;
    readUint16: () => number;
    readUint16At: (offset: number) => number;
    readInt16: () => number;
    readInt16At: (offset: number) => number;
    writeUint16: (value: number) => void;
    writeUint16At: (offset: number, value: number) => void;
    writeInt16: (value: number) => void;
    writeInt16At: (offset: number, value: number) => void;
    readUint32: () => number;
    readUint32At: (offset: number) => number;
    readInt32: () => number;
    readInt32At: (offset: number) => number;
    writeUint32: (value: number) => void;
    writeUint32At: (offset: number, value: number) => void;
    writeInt32: (value: number) => void;
    writeInt32At: (offset: number, value: number) => void;
    readBigUint64: () => bigint;
    readBigUint64At: (offset: number) => bigint;
    readBigInt64: () => bigint;
    readBigInt64At: (offset: number) => bigint;
    writeBigUint64: (value: bigint) => void;
    writeBigUint64At: (offset: number, value: bigint) => void;
    writeBigInt64: (value: bigint) => void;
    writeBigInt64At: (offset: number, value: bigint) => void;
    readFloat32: () => number;
    readFloat32At: (offset: number) => number;
    readFloat64: () => number;
    readFloat64At: (offset: number) => number;
    writeFloat32: (value: number) => void;
    writeFloat32At: (offset: number, value: number) => void;
    writeFloat64: (value: number) => void;
    writeFloat64At: (offset: number, value: number) => void;
    private _checkOverflow;
    private _readIntAt;
    private _readInt;
    private _writeIntAt;
    private _writeInt;
    private _readFloatAt;
    private _readFloat;
    private _writeFloatAt;
    private _writeFloat;
}
//# sourceMappingURL=SimpleDataView.d.ts.map