API @deepkit/bson

export class ObjectId {
    static index: number;
    static generate(time?: number): string;
}

export class ValueWithBSONSerializer {
    constructor(public value: any, public type: Type);
}

export class AutoBuffer {
    _buffer: Uint8Array;
    state;
    constructor(public prepend: number = , private initialSize: number = );
    get buffer();
    get size();
    setOffset(offset: number);
    apply(serializer: AutoBufferSerializer, data: any);
}

export class Writer {
    typeOffset: number;
    constructor(public buffer: Uint8Array, public offset: number = );
    reset();
    /**
     * If typeOffset is defined, the type will be written at this offset.
     * Useful for writing type information for members in array/object literals.
     */
    writeType(v: number);
    resetWriteType();
    prepareWriteType();
    writeUint32(v: number);
    writeInt32(v: number);
    writeDouble(v: number);
    writeDelayedSize(v: number, position: number);
    writeByte(v: number);
    writeBuffer(buffer: Uint8Array, offset: number = );
    writeNull();
    writeAsciiString(str: string | number);
    writeString(str: string);
    getBigIntBSONType(value: bigint): number;
    writeBigIntLong(value: bigint);
    writeBigIntBinary(value: bigint);
    writeSignedBigIntBinary(value: bigint);
    writeLong(value: number);
    writeUUID(value: string);
    writeObjectId(value: string);
    write(value: any): void;
    writeArrayBuffer(value: ArrayBuffer | ArrayBufferView);
}

export class DigitByteRuntimeCode extends RuntimeCode {
    constructor(public code: string);
}

export class BSONBinarySerializer extends Serializer {
    name;
    serializeId: symbol;
    deserializeId: symbol;
    sizerId: symbol;
    sizerRegistry;
    bsonSerializeRegistry;
    bsonDeserializeRegistry;
    bsonTypeGuards;
    constructor(protected options: BSONSerializerOptions = {});
}

export class BsonStreamReader {
    constructor(protected readonly onMessage: (response: Uint8Array) => void);
    emptyBuffer(): boolean;
    feed(data: Uint8Array, bytes?: number);
}

export class BSONError extends CustomError {
}

string[]

9007199254740992

-9007199254740992

BSONBinarySerializer

(buffer: Uint8Array, offset: number): number

(buffer: Uint8Array, offset: number): number

(buffer: Uint8Array, offset: number): number

(parser: BaseParser): any

(parser: BaseParser): any[]

(buffer: Uint8Array, offset?: number): any

<T>(serializer?: BSONBinarySerializer, receiveType?: ReceiveType<T>): BSONDeserializer<T>

<T>(data: Uint8Array, offset?: number, serializer?: BSONBinarySerializer, receiveType?: ReceiveType<T>): T

(hex: string, index?: number, offset?: number): number

(hex: string, index?: number): number

(str: string): number

(value: any): number

<T>(value: any, type?: ReceiveType<T>): ValueWithBSONSerializer

(value: string): ValueWithBSONSerializer

(value: string): ValueWithBSONSerializer

(buffer: Uint8Array, offset: number, value: number): void

(buffer: Uint8Array, offset: number, value: number): void

(buffer: Uint8Array, offset: number, value: number): void

<T>(type?: ReceiveType<T>, serializer?: BSONBinarySerializer, jitStack?: JitStack): (data: object) => number

(data: any): Uint8Array

<T>(serializer?: BSONBinarySerializer, receiveType?: ReceiveType<T>): BSONSerializer

<T>(serializer?: BSONBinarySerializer, receiveType?: ReceiveType<T>): BSONSizer

<T>(data: T, serializer?: BSONBinarySerializer, receiveType?: ReceiveType<T>): Uint8Array

(buffer: Uint8Array, off: number, end: number): string

(buffer: Uint8Array, off: number, end: number): string

(type: Type, options?: Partial<Options>): BsonEncoder

type BSONDeserializer<T> = (bson: Uint8Array, offset?: number) => T;

type AutoBufferSerializerState = { writer?: Writer };

type AutoBufferSerializer = (data: any, state: AutoBufferSerializerState) => void;

type BSONSerializerState = { writer?: Writer };

type BSONSerializer = (data: any, state?: BSONSerializerState) => Uint8Array;

type BSONSizer = (data: any) => number;