@dstanesc/o-o-o-o-o-o-o/dist/api/proto-gremlin.d.ts

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

import { Graph, Tx } from '../graph';
import { LinkCodec, ValueCodec } from '../codecs';
import { BlockStore } from '../block-store';
import { IndexStore } from '../index-store';
import { Edge, EdgeRef, Prop, PropValue, KeyType, Vertex, VertexRef, VertexType, EdgeType, PropType, Link, RootIndex, Block, Part, Ref, IndexType, Tag } from '../types';
import { PathElem, PropPredicate, NavigationThreshold } from '../navigate';
import { VersionStore } from '../version-store';
interface ProtoGremlinFactory {
    g: () => ProtoGremlin;
}
declare const protoGremlinFactory: ({ chunk, linkCodec, valueCodec, blockStore, versionStore, indexStore, }: {
    chunk: (buffer: Uint8Array) => Uint32Array;
    linkCodec: LinkCodec;
    valueCodec: ValueCodec;
    blockStore: BlockStore;
    versionStore: VersionStore;
    indexStore?: IndexStore;
}) => ProtoGremlinFactory;
interface Navigation {
    path: PathElem[];
    request: NavigationThreshold;
    refs: Ref[];
    navigator?: NavigateWrapper;
}
declare abstract class NavigateWrapper {
    graph: Graph;
    navigation: Navigation;
    constructor(graph: Graph, navigation: Navigation);
    abstract merge(previous: PathElem, current: PathElem): PathElem;
    mergePush(pathElem: PathElem): void;
    values(...keys: KeyType[]): NavigateWrapper;
    template(template: any): NavigateWrapper;
    maxResults(value: number): NavigateWrapper;
    exec(): AsyncGenerator<Part, void, void>;
    abstract navigate(refs: Ref[]): AsyncGenerator<any, void, void>;
}
declare class NavigateVertexWrapper extends NavigateWrapper {
    constructor(graph: Graph, navigation: Navigation);
    merge(previous: PathElem, current: PathElem): PathElem;
    hasType(...vertexTypes: VertexType[]): NavigateVertexWrapper;
    has(vertexType: VertexType, propPredicate: PropPredicate): NavigateVertexWrapper;
    outE(...edgeTypes: EdgeType[]): NavigateEdgeWrapper;
    out(...edgeTypes: EdgeType[]): NavigateVertexWrapper;
    navigate(refs: VertexRef[]): AsyncGenerator<any, void, void>;
}
declare class NavigateEdgeWrapper extends NavigateWrapper {
    constructor(graph: Graph, navigation: Navigation);
    merge(previous: PathElem, current: PathElem): PathElem;
    hasType(...edgeTypes: EdgeType[]): NavigateEdgeWrapper;
    has(edgeType: EdgeType, propPredicate: PropPredicate): NavigateEdgeWrapper;
    inV(...vertexTypes: VertexType[]): NavigateVertexWrapper;
    navigate(refs: EdgeRef[]): AsyncGenerator<any, void, void>;
}
declare class CreateWrapper {
    tx: Tx;
    props: {
        keyType: KeyType;
        value: PropValue;
        type?: PropType;
    }[];
    constructor(tx: Tx);
}
declare class VertexCreateWrapper extends CreateWrapper {
    vertex: Vertex;
    vertexType: VertexType;
    constructor(tx: Tx, vertexType: VertexType);
    next(): Promise<VertexCreateWrapper>;
    property(keyType: KeyType, value: PropValue, type?: PropType): VertexCreateWrapper;
    uniqueIndex(keyType: KeyType, indexType?: IndexType): Promise<VertexCreateWrapper>;
    get offset(): import("../types").Offset;
    get type(): number;
}
declare class EdgeCreateWrapper extends CreateWrapper {
    edge: Edge;
    edgeType: EdgeType;
    fromVertex: VertexCreateWrapper;
    toVertex: VertexCreateWrapper;
    constructor(tx: Tx, edgeType: EdgeType);
    from(fromVertex: VertexCreateWrapper): EdgeCreateWrapper;
    to(toVertex: VertexCreateWrapper): EdgeCreateWrapper;
    property(keyType: KeyType, value: PropValue, type?: PropType): EdgeCreateWrapper;
    next(): Promise<EdgeCreateWrapper>;
    get offset(): import("../types").Offset;
    get type(): number;
}
declare class ProtoGremlinTransaction {
    tx: Tx;
    constructor(tx: Tx);
    addV(vertexType?: VertexType): VertexCreateWrapper;
    addE(edgeType?: EdgeType): EdgeCreateWrapper;
    commit({ comment, tags, }: {
        comment?: Comment;
        tags?: Tag[];
    }): Promise<{
        root: Link;
        index: RootIndex;
        blocks: Block[];
    }>;
}
declare class ProtoGremlin {
    graph: Graph;
    constructor(graph: Graph);
    V(refs: VertexRef[]): NavigateVertexWrapper;
    E(refs: EdgeRef[]): NavigateEdgeWrapper;
    tx(): Promise<ProtoGremlinTransaction>;
    allVertices(): Promise<Vertex[]>;
    allEdges(): Promise<Edge[]>;
    allProps(): Promise<Prop[]>;
    /**
     * Pack a complete graph
     * @param versionRoot - the version root
     * @returns - a block containing the packed graph
     */
    pack(versionRoot?: Link): Promise<Block>;
    /**
     * Pack a graph fragment
     *
     * @param vertexOffsetStart - the offset of the first vertex
     * @param vertexCount - the number of vertices, counting from the first vertex
     * @param graphDepth - the depth of the fragment
     * @param versionRoot - the version root
     * @returns - a block containing the packed graph fragment
     */
    packFragment(vertexOffsetStart: number, vertexCount: number, graphDepth: number, versionRoot?: Link): Promise<Block>;
}
export { ProtoGremlinFactory, ProtoGremlin, ProtoGremlinTransaction, NavigateVertexWrapper, NavigateEdgeWrapper, protoGremlinFactory, };
//# sourceMappingURL=proto-gremlin.d.ts.map