zrald1/dist/types/graph.d.ts

Advanced Graph RAG MCP Server with file location identification, graph processing, and result summarization capabilities

import { z } from 'zod';
export declare const NodeSchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodEnum<["entity", "concept", "document", "chunk", "summary", "file"]>;
    label: z.ZodString;
    properties: z.ZodRecord<z.ZodString, z.ZodAny>;
    embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    created_at: z.ZodDefault<z.ZodDate>;
    updated_at: z.ZodDefault<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    id: string;
    type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
    label: string;
    properties: Record<string, any>;
    created_at: Date;
    updated_at: Date;
    embedding?: number[] | undefined;
    metadata?: Record<string, any> | undefined;
}, {
    id: string;
    type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
    label: string;
    properties: Record<string, any>;
    embedding?: number[] | undefined;
    metadata?: Record<string, any> | undefined;
    created_at?: Date | undefined;
    updated_at?: Date | undefined;
}>;
export declare const RelationshipSchema: z.ZodObject<{
    id: z.ZodString;
    source_id: z.ZodString;
    target_id: z.ZodString;
    type: z.ZodString;
    properties: z.ZodRecord<z.ZodString, z.ZodAny>;
    weight: z.ZodDefault<z.ZodNumber>;
    confidence: z.ZodDefault<z.ZodNumber>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    created_at: z.ZodDefault<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    id: string;
    type: string;
    properties: Record<string, any>;
    created_at: Date;
    source_id: string;
    target_id: string;
    weight: number;
    confidence: number;
    metadata?: Record<string, any> | undefined;
}, {
    id: string;
    type: string;
    properties: Record<string, any>;
    source_id: string;
    target_id: string;
    metadata?: Record<string, any> | undefined;
    created_at?: Date | undefined;
    weight?: number | undefined;
    confidence?: number | undefined;
}>;
export declare const ChunkSchema: z.ZodObject<{
    id: z.ZodString;
    content: z.ZodString;
    document_id: z.ZodString;
    position: z.ZodNumber;
    embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
    entities: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    id: string;
    content: string;
    document_id: string;
    position: number;
    entities: string[];
    embedding?: number[] | undefined;
    metadata?: Record<string, any> | undefined;
}, {
    id: string;
    content: string;
    document_id: string;
    position: number;
    embedding?: number[] | undefined;
    metadata?: Record<string, any> | undefined;
    entities?: string[] | undefined;
}>;
export declare const FileSchema: z.ZodObject<{
    id: z.ZodString;
    path: z.ZodString;
    name: z.ZodString;
    extension: z.ZodString;
    size: z.ZodNumber;
    content: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    created_at: z.ZodDefault<z.ZodDate>;
    updated_at: z.ZodDefault<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    id: string;
    path: string;
    created_at: Date;
    updated_at: Date;
    name: string;
    extension: string;
    size: number;
    metadata?: Record<string, any> | undefined;
    content?: string | undefined;
}, {
    id: string;
    path: string;
    name: string;
    extension: string;
    size: number;
    metadata?: Record<string, any> | undefined;
    created_at?: Date | undefined;
    updated_at?: Date | undefined;
    content?: string | undefined;
}>;
export declare const PassageGraphSchema: z.ZodObject<{
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["entity", "concept", "document", "chunk", "summary", "file"]>;
        label: z.ZodString;
        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
        embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
        updated_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        created_at: Date;
        updated_at: Date;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
    }>, "many">;
    relationships: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        source_id: z.ZodString;
        target_id: z.ZodString;
        type: z.ZodString;
        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
        weight: z.ZodDefault<z.ZodNumber>;
        confidence: z.ZodDefault<z.ZodNumber>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: string;
        properties: Record<string, any>;
        created_at: Date;
        source_id: string;
        target_id: string;
        weight: number;
        confidence: number;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        type: string;
        properties: Record<string, any>;
        source_id: string;
        target_id: string;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        weight?: number | undefined;
        confidence?: number | undefined;
    }>, "many">;
    type: z.ZodLiteral<"passage">;
}, "strip", z.ZodTypeAny, {
    type: "passage";
    nodes: {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        created_at: Date;
        updated_at: Date;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }[];
    relationships: {
        id: string;
        type: string;
        properties: Record<string, any>;
        created_at: Date;
        source_id: string;
        target_id: string;
        weight: number;
        confidence: number;
        metadata?: Record<string, any> | undefined;
    }[];
}, {
    type: "passage";
    nodes: {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
    }[];
    relationships: {
        id: string;
        type: string;
        properties: Record<string, any>;
        source_id: string;
        target_id: string;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        weight?: number | undefined;
        confidence?: number | undefined;
    }[];
}>;
export declare const TreesGraphSchema: z.ZodObject<{
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["entity", "concept", "document", "chunk", "summary", "file"]>;
        label: z.ZodString;
        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
        embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
        updated_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        created_at: Date;
        updated_at: Date;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
    }>, "many">;
    relationships: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        source_id: z.ZodString;
        target_id: z.ZodString;
        type: z.ZodString;
        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
        weight: z.ZodDefault<z.ZodNumber>;
        confidence: z.ZodDefault<z.ZodNumber>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: string;
        properties: Record<string, any>;
        created_at: Date;
        source_id: string;
        target_id: string;
        weight: number;
        confidence: number;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        type: string;
        properties: Record<string, any>;
        source_id: string;
        target_id: string;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        weight?: number | undefined;
        confidence?: number | undefined;
    }>, "many">;
    root_nodes: z.ZodArray<z.ZodString, "many">;
    levels: z.ZodNumber;
    type: z.ZodLiteral<"trees">;
}, "strip", z.ZodTypeAny, {
    type: "trees";
    nodes: {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        created_at: Date;
        updated_at: Date;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }[];
    relationships: {
        id: string;
        type: string;
        properties: Record<string, any>;
        created_at: Date;
        source_id: string;
        target_id: string;
        weight: number;
        confidence: number;
        metadata?: Record<string, any> | undefined;
    }[];
    root_nodes: string[];
    levels: number;
}, {
    type: "trees";
    nodes: {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
    }[];
    relationships: {
        id: string;
        type: string;
        properties: Record<string, any>;
        source_id: string;
        target_id: string;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        weight?: number | undefined;
        confidence?: number | undefined;
    }[];
    root_nodes: string[];
    levels: number;
}>;
export declare const KnowledgeGraphSchema: z.ZodObject<{
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["entity", "concept", "document", "chunk", "summary", "file"]>;
        label: z.ZodString;
        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
        embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
        updated_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        created_at: Date;
        updated_at: Date;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
    }>, "many">;
    relationships: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        source_id: z.ZodString;
        target_id: z.ZodString;
        type: z.ZodString;
        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
        weight: z.ZodDefault<z.ZodNumber>;
        confidence: z.ZodDefault<z.ZodNumber>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: string;
        properties: Record<string, any>;
        created_at: Date;
        source_id: string;
        target_id: string;
        weight: number;
        confidence: number;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        type: string;
        properties: Record<string, any>;
        source_id: string;
        target_id: string;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        weight?: number | undefined;
        confidence?: number | undefined;
    }>, "many">;
    entities: z.ZodArray<z.ZodString, "many">;
    concepts: z.ZodArray<z.ZodString, "many">;
    type: z.ZodLiteral<"knowledge">;
}, "strip", z.ZodTypeAny, {
    type: "knowledge";
    entities: string[];
    nodes: {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        created_at: Date;
        updated_at: Date;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }[];
    relationships: {
        id: string;
        type: string;
        properties: Record<string, any>;
        created_at: Date;
        source_id: string;
        target_id: string;
        weight: number;
        confidence: number;
        metadata?: Record<string, any> | undefined;
    }[];
    concepts: string[];
}, {
    type: "knowledge";
    entities: string[];
    nodes: {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
    }[];
    relationships: {
        id: string;
        type: string;
        properties: Record<string, any>;
        source_id: string;
        target_id: string;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        weight?: number | undefined;
        confidence?: number | undefined;
    }[];
    concepts: string[];
}>;
export declare const DAGSchema: z.ZodObject<{
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["entity", "concept", "document", "chunk", "summary", "file"]>;
        label: z.ZodString;
        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
        embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
        updated_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        created_at: Date;
        updated_at: Date;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
    }>, "many">;
    relationships: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        source_id: z.ZodString;
        target_id: z.ZodString;
        type: z.ZodString;
        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
        weight: z.ZodDefault<z.ZodNumber>;
        confidence: z.ZodDefault<z.ZodNumber>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: string;
        properties: Record<string, any>;
        created_at: Date;
        source_id: string;
        target_id: string;
        weight: number;
        confidence: number;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        type: string;
        properties: Record<string, any>;
        source_id: string;
        target_id: string;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        weight?: number | undefined;
        confidence?: number | undefined;
    }>, "many">;
    entry_points: z.ZodArray<z.ZodString, "many">;
    exit_points: z.ZodArray<z.ZodString, "many">;
    type: z.ZodLiteral<"dag">;
}, "strip", z.ZodTypeAny, {
    type: "dag";
    nodes: {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        created_at: Date;
        updated_at: Date;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }[];
    relationships: {
        id: string;
        type: string;
        properties: Record<string, any>;
        created_at: Date;
        source_id: string;
        target_id: string;
        weight: number;
        confidence: number;
        metadata?: Record<string, any> | undefined;
    }[];
    entry_points: string[];
    exit_points: string[];
}, {
    type: "dag";
    nodes: {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
    }[];
    relationships: {
        id: string;
        type: string;
        properties: Record<string, any>;
        source_id: string;
        target_id: string;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        weight?: number | undefined;
        confidence?: number | undefined;
    }[];
    entry_points: string[];
    exit_points: string[];
}>;
export declare const OperatorResultSchema: z.ZodObject<{
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["entity", "concept", "document", "chunk", "summary", "file"]>;
        label: z.ZodString;
        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
        embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
        updated_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        created_at: Date;
        updated_at: Date;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
    }>, "many">;
    relationships: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        source_id: z.ZodString;
        target_id: z.ZodString;
        type: z.ZodString;
        properties: z.ZodRecord<z.ZodString, z.ZodAny>;
        weight: z.ZodDefault<z.ZodNumber>;
        confidence: z.ZodDefault<z.ZodNumber>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: string;
        properties: Record<string, any>;
        created_at: Date;
        source_id: string;
        target_id: string;
        weight: number;
        confidence: number;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        type: string;
        properties: Record<string, any>;
        source_id: string;
        target_id: string;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        weight?: number | undefined;
        confidence?: number | undefined;
    }>, "many">;
    chunks: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        content: z.ZodString;
        document_id: z.ZodString;
        position: z.ZodNumber;
        embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
        entities: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        content: string;
        document_id: string;
        position: number;
        entities: string[];
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }, {
        id: string;
        content: string;
        document_id: string;
        position: number;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        entities?: string[] | undefined;
    }>, "many">>;
    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        path: z.ZodString;
        name: z.ZodString;
        extension: z.ZodString;
        size: z.ZodNumber;
        content: z.ZodOptional<z.ZodString>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        created_at: z.ZodDefault<z.ZodDate>;
        updated_at: z.ZodDefault<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        path: string;
        created_at: Date;
        updated_at: Date;
        name: string;
        extension: string;
        size: number;
        metadata?: Record<string, any> | undefined;
        content?: string | undefined;
    }, {
        id: string;
        path: string;
        name: string;
        extension: string;
        size: number;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
        content?: string | undefined;
    }>, "many">>;
    scores: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    nodes: {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        created_at: Date;
        updated_at: Date;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }[];
    relationships: {
        id: string;
        type: string;
        properties: Record<string, any>;
        created_at: Date;
        source_id: string;
        target_id: string;
        weight: number;
        confidence: number;
        metadata?: Record<string, any> | undefined;
    }[];
    metadata?: Record<string, any> | undefined;
    chunks?: {
        id: string;
        content: string;
        document_id: string;
        position: number;
        entities: string[];
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
    }[] | undefined;
    files?: {
        id: string;
        path: string;
        created_at: Date;
        updated_at: Date;
        name: string;
        extension: string;
        size: number;
        metadata?: Record<string, any> | undefined;
        content?: string | undefined;
    }[] | undefined;
    scores?: Record<string, number> | undefined;
}, {
    nodes: {
        id: string;
        type: "entity" | "concept" | "document" | "chunk" | "summary" | "file";
        label: string;
        properties: Record<string, any>;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
    }[];
    relationships: {
        id: string;
        type: string;
        properties: Record<string, any>;
        source_id: string;
        target_id: string;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        weight?: number | undefined;
        confidence?: number | undefined;
    }[];
    metadata?: Record<string, any> | undefined;
    chunks?: {
        id: string;
        content: string;
        document_id: string;
        position: number;
        embedding?: number[] | undefined;
        metadata?: Record<string, any> | undefined;
        entities?: string[] | undefined;
    }[] | undefined;
    files?: {
        id: string;
        path: string;
        name: string;
        extension: string;
        size: number;
        metadata?: Record<string, any> | undefined;
        created_at?: Date | undefined;
        updated_at?: Date | undefined;
        content?: string | undefined;
    }[] | undefined;
    scores?: Record<string, number> | undefined;
}>;
export declare const VDBOperatorConfigSchema: z.ZodObject<{
    query_embedding: z.ZodArray<z.ZodNumber, "many">;
    top_k: z.ZodDefault<z.ZodNumber>;
    similarity_threshold: z.ZodDefault<z.ZodNumber>;
    node_types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    query_embedding: number[];
    top_k: number;
    similarity_threshold: number;
    node_types?: string[] | undefined;
}, {
    query_embedding: number[];
    top_k?: number | undefined;
    similarity_threshold?: number | undefined;
    node_types?: string[] | undefined;
}>;
export declare const PPROperatorConfigSchema: z.ZodObject<{
    seed_nodes: z.ZodArray<z.ZodString, "many">;
    damping_factor: z.ZodDefault<z.ZodNumber>;
    max_iterations: z.ZodDefault<z.ZodNumber>;
    tolerance: z.ZodDefault<z.ZodNumber>;
    personalization: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    seed_nodes: string[];
    damping_factor: number;
    max_iterations: number;
    tolerance: number;
    personalization?: Record<string, number> | undefined;
}, {
    seed_nodes: string[];
    damping_factor?: number | undefined;
    max_iterations?: number | undefined;
    tolerance?: number | undefined;
    personalization?: Record<string, number> | undefined;
}>;
export declare const OneHopOperatorConfigSchema: z.ZodObject<{
    source_nodes: z.ZodArray<z.ZodString, "many">;
    relationship_types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    direction: z.ZodDefault<z.ZodEnum<["incoming", "outgoing", "both"]>>;
    max_depth: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    source_nodes: string[];
    direction: "incoming" | "outgoing" | "both";
    max_depth: number;
    relationship_types?: string[] | undefined;
}, {
    source_nodes: string[];
    relationship_types?: string[] | undefined;
    direction?: "incoming" | "outgoing" | "both" | undefined;
    max_depth?: number | undefined;
}>;
export declare const KHopPathOperatorConfigSchema: z.ZodObject<{
    source_nodes: z.ZodArray<z.ZodString, "many">;
    target_nodes: z.ZodArray<z.ZodString, "many">;
    max_hops: z.ZodDefault<z.ZodNumber>;
    relationship_types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    path_limit: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    source_nodes: string[];
    target_nodes: string[];
    max_hops: number;
    path_limit: number;
    relationship_types?: string[] | undefined;
}, {
    source_nodes: string[];
    target_nodes: string[];
    relationship_types?: string[] | undefined;
    max_hops?: number | undefined;
    path_limit?: number | undefined;
}>;
export declare const AggregatorOperatorConfigSchema: z.ZodObject<{
    source_nodes: z.ZodArray<z.ZodString, "many">;
    aggregation_method: z.ZodDefault<z.ZodEnum<["sum", "average", "max", "weighted"]>>;
    relationship_weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    normalize_scores: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    source_nodes: string[];
    aggregation_method: "sum" | "average" | "max" | "weighted";
    normalize_scores: boolean;
    relationship_weights?: Record<string, number> | undefined;
}, {
    source_nodes: string[];
    aggregation_method?: "sum" | "average" | "max" | "weighted" | undefined;
    relationship_weights?: Record<string, number> | undefined;
    normalize_scores?: boolean | undefined;
}>;
export declare const FromRelOperatorConfigSchema: z.ZodObject<{
    relationship_ids: z.ZodArray<z.ZodString, "many">;
    include_context: z.ZodDefault<z.ZodBoolean>;
    context_window: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    relationship_ids: string[];
    include_context: boolean;
    context_window: number;
}, {
    relationship_ids: string[];
    include_context?: boolean | undefined;
    context_window?: number | undefined;
}>;
export declare const OccurrenceOperatorConfigSchema: z.ZodObject<{
    entities: z.ZodArray<z.ZodString, "many">;
    co_occurrence_window: z.ZodDefault<z.ZodNumber>;
    min_frequency: z.ZodDefault<z.ZodNumber>;
    include_positions: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    entities: string[];
    co_occurrence_window: number;
    min_frequency: number;
    include_positions: boolean;
}, {
    entities: string[];
    co_occurrence_window?: number | undefined;
    min_frequency?: number | undefined;
    include_positions?: boolean | undefined;
}>;
export declare const SteinerOperatorConfigSchema: z.ZodObject<{
    terminal_nodes: z.ZodArray<z.ZodString, "many">;
    edge_weights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    algorithm: z.ZodDefault<z.ZodEnum<["approximation", "exact"]>>;
    max_tree_size: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    terminal_nodes: string[];
    algorithm: "exact" | "approximation";
    max_tree_size: number;
    edge_weights?: Record<string, number> | undefined;
}, {
    terminal_nodes: string[];
    edge_weights?: Record<string, number> | undefined;
    algorithm?: "exact" | "approximation" | undefined;
    max_tree_size?: number | undefined;
}>;
export declare const FileLocationOperatorConfigSchema: z.ZodObject<{
    query: z.ZodString;
    file_types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    search_paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    recursive: z.ZodDefault<z.ZodBoolean>;
    max_results: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    query: string;
    recursive: boolean;
    max_results: number;
    file_types?: string[] | undefined;
    search_paths?: string[] | undefined;
}, {
    query: string;
    file_types?: string[] | undefined;
    search_paths?: string[] | undefined;
    recursive?: boolean | undefined;
    max_results?: number | undefined;
}>;
export declare const ExecutionPatternSchema: z.ZodEnum<["sequential", "parallel", "adaptive"]>;
export declare const OperatorChainSchema: z.ZodObject<{
    operators: z.ZodArray<z.ZodObject<{
        type: z.ZodString;
        config: z.ZodRecord<z.ZodString, z.ZodAny>;
        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        type: string;
        config: Record<string, any>;
        dependencies: string[];
    }, {
        type: string;
        config: Record<string, any>;
        dependencies?: string[] | undefined;
    }>, "many">;
    execution_pattern: z.ZodEnum<["sequential", "parallel", "adaptive"]>;
    fusion_strategy: z.ZodDefault<z.ZodEnum<["union", "intersection", "weighted_average"]>>;
}, "strip", z.ZodTypeAny, {
    operators: {
        type: string;
        config: Record<string, any>;
        dependencies: string[];
    }[];
    execution_pattern: "sequential" | "parallel" | "adaptive";
    fusion_strategy: "union" | "intersection" | "weighted_average";
}, {
    operators: {
        type: string;
        config: Record<string, any>;
        dependencies?: string[] | undefined;
    }[];
    execution_pattern: "sequential" | "parallel" | "adaptive";
    fusion_strategy?: "union" | "intersection" | "weighted_average" | undefined;
}>;
export declare const QueryPlanSchema: z.ZodObject<{
    id: z.ZodString;
    query: z.ZodString;
    intent: z.ZodEnum<["factual", "analytical", "exploratory", "comparative", "file_search"]>;
    operator_chain: z.ZodObject<{
        operators: z.ZodArray<z.ZodObject<{
            type: z.ZodString;
            config: z.ZodRecord<z.ZodString, z.ZodAny>;
            dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        }, "strip", z.ZodTypeAny, {
            type: string;
            config: Record<string, any>;
            dependencies: string[];
        }, {
            type: string;
            config: Record<string, any>;
            dependencies?: string[] | undefined;
        }>, "many">;
        execution_pattern: z.ZodEnum<["sequential", "parallel", "adaptive"]>;
        fusion_strategy: z.ZodDefault<z.ZodEnum<["union", "intersection", "weighted_average"]>>;
    }, "strip", z.ZodTypeAny, {
        operators: {
            type: string;
            config: Record<string, any>;
            dependencies: string[];
        }[];
        execution_pattern: "sequential" | "parallel" | "adaptive";
        fusion_strategy: "union" | "intersection" | "weighted_average";
    }, {
        operators: {
            type: string;
            config: Record<string, any>;
            dependencies?: string[] | undefined;
        }[];
        execution_pattern: "sequential" | "parallel" | "adaptive";
        fusion_strategy?: "union" | "intersection" | "weighted_average" | undefined;
    }>;
    estimated_cost: z.ZodOptional<z.ZodNumber>;
    priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
}, "strip", z.ZodTypeAny, {
    id: string;
    query: string;
    intent: "factual" | "analytical" | "exploratory" | "comparative" | "file_search";
    operator_chain: {
        operators: {
            type: string;
            config: Record<string, any>;
            dependencies: string[];
        }[];
        execution_pattern: "sequential" | "parallel" | "adaptive";
        fusion_strategy: "union" | "intersection" | "weighted_average";
    };
    priority: "low" | "medium" | "high" | "critical";
    estimated_cost?: number | undefined;
}, {
    id: string;
    query: string;
    intent: "factual" | "analytical" | "exploratory" | "comparative" | "file_search";
    operator_chain: {
        operators: {
            type: string;
            config: Record<string, any>;
            dependencies?: string[] | undefined;
        }[];
        execution_pattern: "sequential" | "parallel" | "adaptive";
        fusion_strategy?: "union" | "intersection" | "weighted_average" | undefined;
    };
    estimated_cost?: number | undefined;
    priority?: "low" | "medium" | "high" | "critical" | undefined;
}>;
export type Node = z.infer<typeof NodeSchema>;
export type Relationship = z.infer<typeof RelationshipSchema>;
export type Chunk = z.infer<typeof ChunkSchema>;
export type File = z.infer<typeof FileSchema>;
export type PassageGraph = z.infer<typeof PassageGraphSchema>;
export type TreesGraph = z.infer<typeof TreesGraphSchema>;
export type KnowledgeGraph = z.infer<typeof KnowledgeGraphSchema>;
export type DAG = z.infer<typeof DAGSchema>;
export type OperatorResult = z.infer<typeof OperatorResultSchema>;
export type VDBOperatorConfig = z.infer<typeof VDBOperatorConfigSchema>;
export type PPROperatorConfig = z.infer<typeof PPROperatorConfigSchema>;
export type OneHopOperatorConfig = z.infer<typeof OneHopOperatorConfigSchema>;
export type KHopPathOperatorConfig = z.infer<typeof KHopPathOperatorConfigSchema>;
export type AggregatorOperatorConfig = z.infer<typeof AggregatorOperatorConfigSchema>;
export type FromRelOperatorConfig = z.infer<typeof FromRelOperatorConfigSchema>;
export type OccurrenceOperatorConfig = z.infer<typeof OccurrenceOperatorConfigSchema>;
export type SteinerOperatorConfig = z.infer<typeof SteinerOperatorConfigSchema>;
export type FileLocationOperatorConfig = z.infer<typeof FileLocationOperatorConfigSchema>;
export type ExecutionPattern = z.infer<typeof ExecutionPatternSchema>;
export type OperatorChain = z.infer<typeof OperatorChainSchema>;
export type QueryPlan = z.infer<typeof QueryPlanSchema>;
export type Graph = PassageGraph | TreesGraph | KnowledgeGraph | DAG;
//# sourceMappingURL=graph.d.ts.map