/** Lower and upper 64-bit words used to represent DuckDB HUGEINT values. */
export interface HugeIntParts {
    /** Low 64 bits, interpreted as unsigned. */
    lower: bigint;
    /** High 64 bits, interpreted as signed or unsigned depending on context. */
    upper: bigint;
}
/** HUGEINT input accepted by binary encoders. */
export type HugeIntLike = bigint | HugeIntParts;
/** Writer for DuckDB BinarySerializer-compatible primitive values. */
export declare class BinaryWriter {
    private buffer;
    private offset;
    /** Create a binary writer with an optional initial buffer capacity. */
    constructor(initialCapacity?: number);
    /** Return the written bytes. */
    toUint8Array(): Uint8Array;
    /** Write an object body and its end-of-object marker. */
    writeObject(write: (writer: BinaryWriter) => void): void;
    /** Write a field id followed by its encoded payload. */
    writeField(fieldId: number, write: (writer: BinaryWriter) => void): void;
    /** Write a raw 16-bit BinarySerializer field id. */
    writeFieldId(fieldId: number): void;
    /** Write one unsigned byte. */
    writeByte(value: number): void;
    /** Write raw bytes without a length prefix. */
    writeBytes(value: Uint8Array): void;
    /** Write a DuckDB boolean byte. */
    writeBool(value: boolean): void;
    /** Write an unsigned LEB128 integer. */
    writeUleb(value: number | bigint): void;
    /** Write a signed LEB128 integer. */
    writeSleb(value: number | bigint): void;
    /** Write a UTF-8 string with a length prefix. */
    writeString(value: string): void;
    /** Write already-encoded string bytes with a length prefix. */
    writeStringBytes(value: Uint8Array): void;
    /** Write a binary blob with a length prefix. */
    writeBlob(value: Uint8Array): void;
    /** Write a length-prefixed list. */
    writeList<T>(items: readonly T[], writeElement: (item: T, index: number) => void): void;
    /** Write a nullable pointer-style value. */
    writeNullable<T>(value: T | null | undefined, writeValue: (value: T) => void): void;
    /** Write a DuckDB HugeInt using signed upper and unsigned lower parts. */
    writeHugeInt(value: HugeIntLike): void;
    /** Write a fixed-width signed 8-bit integer. */
    writeFixedInt8(value: number): void;
    /** Write a fixed-width unsigned 8-bit integer. */
    writeFixedUint8(value: number): void;
    /** Write a fixed-width signed 16-bit little-endian integer. */
    writeFixedInt16(value: number): void;
    /** Write a fixed-width unsigned 16-bit little-endian integer. */
    writeFixedUint16(value: number): void;
    /** Write a fixed-width signed 32-bit little-endian integer. */
    writeFixedInt32(value: number): void;
    /** Write a fixed-width unsigned 32-bit little-endian integer. */
    writeFixedUint32(value: number): void;
    /** Write a fixed-width 32-bit little-endian float. */
    writeFixedFloat32(value: number): void;
    /** Write a fixed-width 64-bit little-endian float. */
    writeFixedFloat64(value: number): void;
    /** Write a fixed-width signed 64-bit little-endian integer. */
    writeFixedInt64(value: number | bigint): void;
    /** Write a fixed-width unsigned 64-bit little-endian integer. */
    writeFixedUint64(value: number | bigint): void;
    private ensure;
}
/** Reader for DuckDB BinarySerializer-compatible primitive values. */
export declare class BinaryReader {
    private readonly bytes;
    private readonly view;
    private offset;
    /** Create a reader over binary input bytes. */
    constructor(bytes: Uint8Array);
    /** Current byte offset in the input. */
    get position(): number;
    /** Number of unread bytes remaining. */
    get remaining(): number;
    /** Whether the reader has consumed all input bytes. */
    eof(): boolean;
    /** Throw if any bytes remain unread. */
    assertEof(): void;
    /** Read an object body and require the end-of-object marker. */
    readObject<T>(read: (reader: BinaryReader) => T): T;
    /** Read and validate an end-of-object marker. */
    readEndObject(): void;
    /** Read a raw 16-bit BinarySerializer field id. */
    readFieldId(): number;
    /** Peek at the next field id without advancing the reader. */
    peekFieldId(): number;
    /** Read a required field with the expected field id. */
    readRequiredField<T>(fieldId: number, read: () => T): T;
    /** Read an optional field when the next field id matches. */
    readOptionalField<T>(fieldId: number, read: () => T, defaultValue: T): T;
    /** Read one unsigned byte. */
    readByte(): number;
    /** Read raw bytes without interpreting a length prefix. */
    readBytes(length: number): Uint8Array;
    /** Read a DuckDB boolean byte. */
    readBool(): boolean;
    /** Read an unsigned LEB128 integer as bigint. */
    readUlebBigInt(): bigint;
    /** Read an unsigned LEB128 integer as a safe JavaScript number. */
    readUlebNumber(): number;
    /** Read a signed LEB128 integer as bigint. */
    readSlebBigInt(): bigint;
    /** Read a signed LEB128 integer as a safe JavaScript number. */
    readSlebNumber(): number;
    /** Read a UTF-8 string with a length prefix. */
    readString(): string;
    /** Read length-prefixed bytes for a string-like value. */
    readStringBytes(): Uint8Array;
    /** Read a length-prefixed binary blob. */
    readBlob(): Uint8Array;
    /** Read a length-prefixed list. */
    readList<T>(readElement: (index: number) => T): T[];
    /** Read a nullable pointer-style value. */
    readNullable<T>(readValue: () => T): T | undefined;
    /** Read a DuckDB HugeInt into upper/lower parts. */
    readHugeInt(): HugeIntParts;
    /** Read a fixed-width signed 8-bit integer. */
    readFixedInt8(): number;
    /** Read a fixed-width unsigned 8-bit integer. */
    readFixedUint8(): number;
    /** Read a fixed-width signed 16-bit little-endian integer. */
    readFixedInt16(): number;
    /** Read a fixed-width unsigned 16-bit little-endian integer. */
    readFixedUint16(): number;
    /** Read a fixed-width signed 32-bit little-endian integer. */
    readFixedInt32(): number;
    /** Read a fixed-width unsigned 32-bit little-endian integer. */
    readFixedUint32(): number;
    /** Read a fixed-width 32-bit little-endian float. */
    readFixedFloat32(): number;
    /** Read a fixed-width 64-bit little-endian float. */
    readFixedFloat64(): number;
    /** Read a fixed-width signed 64-bit little-endian integer. */
    readFixedInt64(): bigint;
    /** Read a fixed-width unsigned 64-bit little-endian integer. */
    readFixedUint64(): bigint;
    private ensure;
}
/** Concatenate byte arrays into one Uint8Array. */
export declare function concatBytes(chunks: readonly Uint8Array[]): Uint8Array;
/** Convert a bigint to number, rejecting values outside the safe integer range. */
export declare function bigIntToSafeNumber(value: bigint, label: string): number;
/** Split a signed 128-bit integer into DuckDB HugeInt upper/lower words. */
export declare function splitSignedHugeInt(value: bigint): HugeIntParts;
/** Combine DuckDB HugeInt parts into a signed bigint. */
export declare function combineSignedHugeInt(parts: HugeIntParts): bigint;
/** Combine DuckDB HugeInt parts into an unsigned bigint. */
export declare function combineUnsignedHugeInt(parts: HugeIntParts): bigint;