/// <reference types="node" />
declare type uint32 = number;
export interface Writer {
    write(chunk: Buffer): void;
}
export declare class BufferedWriter implements Writer {
    private chunks;
    write(chunk: Buffer): void;
    collect(): Buffer;
}
export declare class BinaryWriter {
    readonly target: Writer;
    constructor(target: Writer);
    uint8(x: number): void;
    uint16(x: number): void;
    uint32(x: number): void;
    boolean(x: boolean): void;
    maybe<A>(x: A | null, f: (_: A) => void): void;
    array<A>(xs: A[], f: (_: A) => void): void;
    map<K, V>(map: Map<K, V>, f: (k: K, v: V) => void): void;
    uint64(x: number): void;
    bigint(x: bigint): void;
    double(x: number): void;
    text(x: string): void;
    string(x: string): void;
    bytes(x: Buffer): void;
}
export declare class BinaryReader {
    readonly source: Buffer;
    offset: uint32;
    constructor(source: Buffer);
    uint8(): number;
    uint16(): number;
    uint32(): number;
    uint64(): number;
    bigint(): bigint;
    boolean(): boolean;
    maybe<A>(f: () => A): A | null;
    array<A>(f: (index: number) => A): A[];
    map<K, V>(f: (index: number) => [K, V]): Map<K, V>;
    double(): number;
    bytes_with_size(size: number): Buffer;
    bytes(): Buffer;
    text(x: string): string;
    string(): string;
}
export {};