@dstanesc/o-o-o-o-o-o-o/dist/serde.d.ts

O-O-O-O-O-O-O is a collection of content addressed persistent data structures

import { Vertex, Edge, Prop, Ref, Type, PropValue, Link, Index, IndexedValue, Status, Version, VersionDetails, ValueRef, PropRef, PropRecord } from './types';
declare class BinaryEncoder {
    buffer: Uint8Array;
    cursor: number;
    constructor(size: number);
    content(): Uint8Array;
    writeByte(byte: number): void;
    writeBytes(bytes: Uint8Array): number;
    writeUInt(value: number): number;
    writeInt(value: number): number;
    writeReserved(flags: number): void;
    writeRefExists(): void;
    writeOffset(offset: number): number;
    writeRef(ref: Ref): number;
    writeTypeExists(): void;
    writeStatus(flag: Status): void;
    writeType(type: Type): number;
    writeLinkExists(): void;
    writeLink(link: Link): void;
    skipBytes(length: number): number;
    skipReserved(): number;
    skipUInt(): number;
    skipRef(): number;
    skipType(): number;
}
declare class BinaryDecoder {
    buffer: Uint8Array;
    cursor: number;
    constructor(buffer: Uint8Array);
    readByte(): number;
    readBytes(length: number): Uint8Array;
    readUInt(): number;
    readInt(): number;
    readOffset(): number;
    readRefExists(): number;
    readTypeExists(): number;
    readLinkExists(): number;
    readStatus(): Status;
    readRef(): number;
    readType(): number;
    readLink(decode: (bytes: Uint8Array) => Link): Link;
    readOptionalLink(decode: (bytes: Uint8Array) => Link): Link | undefined;
    skipBytes(length: number): void;
    skipReserved(): void;
    skipUInt(): void;
    skipRef(): void;
    skipType(): void;
}
declare class VertexEncoder extends BinaryEncoder {
    vertices: Vertex[];
    constructor(vertices: Vertex[]);
    writeVertex(vertex: Vertex): void;
    write(): Uint8Array;
}
declare class VertexDecoder extends BinaryDecoder {
    readVertex(): Vertex;
    read(): Vertex[];
}
declare class EdgeEncoder extends BinaryEncoder {
    edges: Edge[];
    constructor(edges: Edge[]);
    writeEdge(edge: Edge): void;
    write(): Uint8Array;
}
declare class EdgeDecoder extends BinaryDecoder {
    readEdge(): Edge;
    read(): Edge[];
}
declare class PropEncoder extends BinaryEncoder {
    props: Prop[];
    refs: Map<PropRef, ValueRef>;
    constructor(props: Prop[], refs: Map<PropRef, ValueRef>);
    writeValue(propRef: PropRef, value: PropValue): Promise<void>;
    writeProp(prop: Prop): Promise<void>;
    write(): Promise<Uint8Array>;
}
declare class PropRecordDecoder extends BinaryDecoder {
    constructor(buffer: Uint8Array);
    readPropValueRef(): Promise<ValueRef>;
    readProp(): Promise<PropRecord>;
    read(): Promise<PropRecord[]>;
}
declare class PropDecoder extends BinaryDecoder {
    valueGet: (ref: ValueRef) => Promise<PropValue>;
    constructor(buffer: Uint8Array, valueGet: (ref: ValueRef) => Promise<PropValue>);
    readPropValue(): Promise<PropValue>;
    readProp(): Promise<Prop>;
    read(): Promise<Prop[]>;
}
declare class PropValueEncoder extends BinaryEncoder {
    props: Prop[];
    valueEncode: (json: any) => Uint8Array;
    refOffset: number;
    constructor(refOffset: number, props: Prop[], valueEncode: (json: any) => Uint8Array);
    writeValue(propRef: Ref, value: PropValue): ValueRef;
    writeProp(prop: Prop): ValueRef;
    write(): {
        buf: Uint8Array;
        refs: Map<PropRef, ValueRef>;
    };
}
declare class PropValueDecoder extends BinaryDecoder {
    valueDecode: (bytes: Uint8Array) => any;
    constructor(buffer: Uint8Array, valueDecode: (bytes: Uint8Array) => any);
    readValue(valueRef: ValueRef): PropValue;
    read(valueRefs: ValueRef[]): Map<PropRef, PropValue>;
}
declare class IndexEncoder extends BinaryEncoder {
    indices: Index[];
    constructor(indices: Index[]);
    writeIndex(index: Index): Promise<void>;
    write(): Promise<Uint8Array>;
}
declare class IndexDecoder extends BinaryDecoder {
    linkDecode: (linkBytes: Uint8Array) => Link;
    indexDecode: (link: Link, blockGet: (cid: any) => Promise<Uint8Array>, value?: any) => Promise<IndexedValue[]>;
    blockGet: (cid: any) => Promise<Uint8Array>;
    constructor(buffer: Uint8Array, linkDecode: (linkBytes: Uint8Array) => Link);
    readIndex(): Promise<Index>;
    read(): Promise<Index[]>;
}
declare class RootEncoder extends BinaryEncoder {
    vertexRoot: Link;
    vertexOffset: number;
    edgeRoot: Link;
    edgeOffset: number;
    propRoot: Link;
    propOffset: number;
    valueRoot: Link;
    valueOffset: number;
    indexRoot: Link;
    indexOffset: number;
    constructor({ vertexRoot, vertexOffset, edgeRoot, edgeOffset, propRoot, propOffset, valueRoot, valueOffset, indexRoot, indexOffset, }: {
        vertexRoot: Link;
        vertexOffset: number;
        edgeRoot: Link;
        edgeOffset: number;
        propRoot: Link;
        propOffset: number;
        valueRoot: Link;
        valueOffset: number;
        indexRoot: Link;
        indexOffset: number;
    });
    write(): this;
}
declare class RootDecoder extends BinaryDecoder {
    linkDecode: (bytes: Uint8Array) => Link;
    constructor(buffer: Uint8Array, linkDecode: (bytes: Uint8Array) => Link);
    read(): {
        vertexRoot: Link;
        vertexOffset: number;
        edgeRoot: Link;
        edgeOffset: number;
        propRoot: Link;
        propOffset: number;
        valueRoot: Link;
        valueOffset: number;
        indexRoot: Link;
        indexOffset: number;
    };
}
declare class VersionEncoder extends BinaryEncoder {
    id: Link;
    versions: Version[];
    valueEncode: (json: any) => Uint8Array;
    constructor(id: Link, versions: Version[], valueEncode: (json: any) => Uint8Array);
    writeDetails(details: VersionDetails): void;
    writeVersion(version: Version): Promise<void>;
    write(): Uint8Array;
}
declare class VersionDecoder extends BinaryDecoder {
    linkDecode: (linkBytes: Uint8Array) => Link;
    valueDecode: (bytes: Uint8Array) => any;
    constructor(buffer: Uint8Array, linkDecode: (linkBytes: Uint8Array) => Link, valueDecode: (bytes: Uint8Array) => any);
    readVersionDetails(): VersionDetails;
    readVersion(): Version;
    read(): {
        id: Link;
        versions: Version[];
    };
}
declare const OFFSET_INCREMENTS: {
    VERTEX_INCREMENT: number;
    EDGE_INCREMENT: number;
    PROP_INCREMENT: number;
    INDEX_INCREMENT: number;
};
export { BinaryEncoder, BinaryDecoder, VertexEncoder, VertexDecoder, EdgeEncoder, EdgeDecoder, PropRecordDecoder, PropEncoder, PropDecoder, PropValueEncoder, PropValueDecoder, IndexEncoder, IndexDecoder, RootEncoder, RootDecoder, VersionEncoder, VersionDecoder, OFFSET_INCREMENTS, };
//# sourceMappingURL=serde.d.ts.map