import { z } from 'zod';
export declare const NodeSchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodEnum<["entity", "concept", "document", "chunk", "summary"]>;
    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";
    label?: string;
    properties?: Record<string, any>;
    embedding?: number[];
    metadata?: Record<string, any>;
    created_at?: Date;
    updated_at?: Date;
}, {
    id?: string;
    type?: "entity" | "concept" | "document" | "chunk" | "summary";
    label?: string;
    properties?: Record<string, any>;
    embedding?: number[];
    metadata?: Record<string, any>;
    created_at?: Date;
    updated_at?: Date;
}>;
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>;
    metadata?: Record<string, any>;
    created_at?: Date;
    source_id?: string;
    target_id?: string;
    weight?: number;
    confidence?: number;
}, {
    id?: string;
    type?: string;
    properties?: Record<string, any>;
    metadata?: Record<string, any>;
    created_at?: Date;
    source_id?: string;
    target_id?: string;
    weight?: number;
    confidence?: number;
}>;
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;
    embedding?: number[];
    metadata?: Record<string, any>;
    content?: string;
    document_id?: string;
    position?: number;
    entities?: string[];
}, {
    id?: string;
    embedding?: number[];
    metadata?: Record<string, any>;
    content?: string;
    document_id?: string;
    position?: number;
    entities?: string[];
}>;
export declare const PassageGraphSchema: z.ZodObject<{
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["entity", "concept", "document", "chunk", "summary"]>;
        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";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }, {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }>, "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>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }, {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }>, "many">;
    type: z.ZodLiteral<"passage">;
}, "strip", z.ZodTypeAny, {
    type?: "passage";
    nodes?: {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }[];
    relationships?: {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }[];
}, {
    type?: "passage";
    nodes?: {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }[];
    relationships?: {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }[];
}>;
export declare const TreesGraphSchema: z.ZodObject<{
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["entity", "concept", "document", "chunk", "summary"]>;
        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";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }, {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }>, "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>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }, {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }>, "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";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }[];
    relationships?: {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }[];
    root_nodes?: string[];
    levels?: number;
}, {
    type?: "trees";
    nodes?: {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }[];
    relationships?: {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }[];
    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"]>;
        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";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }, {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }>, "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>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }, {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }>, "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";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }[];
    relationships?: {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }[];
    concepts?: string[];
}, {
    type?: "knowledge";
    entities?: string[];
    nodes?: {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }[];
    relationships?: {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }[];
    concepts?: string[];
}>;
export declare const DAGSchema: z.ZodObject<{
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["entity", "concept", "document", "chunk", "summary"]>;
        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";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }, {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }>, "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>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }, {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }>, "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";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }[];
    relationships?: {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }[];
    entry_points?: string[];
    exit_points?: string[];
}, {
    type?: "dag";
    nodes?: {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }[];
    relationships?: {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }[];
    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"]>;
        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";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }, {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }>, "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>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }, {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }>, "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;
        embedding?: number[];
        metadata?: Record<string, any>;
        content?: string;
        document_id?: string;
        position?: number;
        entities?: string[];
    }, {
        id?: string;
        embedding?: number[];
        metadata?: Record<string, any>;
        content?: string;
        document_id?: string;
        position?: number;
        entities?: string[];
    }>, "many">>;
    scores: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    metadata?: Record<string, any>;
    nodes?: {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }[];
    relationships?: {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }[];
    chunks?: {
        id?: string;
        embedding?: number[];
        metadata?: Record<string, any>;
        content?: string;
        document_id?: string;
        position?: number;
        entities?: string[];
    }[];
    scores?: Record<string, number>;
}, {
    metadata?: Record<string, any>;
    nodes?: {
        id?: string;
        type?: "entity" | "concept" | "document" | "chunk" | "summary";
        label?: string;
        properties?: Record<string, any>;
        embedding?: number[];
        metadata?: Record<string, any>;
        created_at?: Date;
        updated_at?: Date;
    }[];
    relationships?: {
        id?: string;
        type?: string;
        properties?: Record<string, any>;
        metadata?: Record<string, any>;
        created_at?: Date;
        source_id?: string;
        target_id?: string;
        weight?: number;
        confidence?: number;
    }[];
    chunks?: {
        id?: string;
        embedding?: number[];
        metadata?: Record<string, any>;
        content?: string;
        document_id?: string;
        position?: number;
        entities?: string[];
    }[];
    scores?: Record<string, number>;
}>;
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[];
}, {
    query_embedding?: number[];
    top_k?: number;
    similarity_threshold?: number;
    node_types?: string[];
}>;
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>;
}, {
    seed_nodes?: string[];
    damping_factor?: number;
    max_iterations?: number;
    tolerance?: number;
    personalization?: Record<string, number>;
}>;
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[];
    relationship_types?: string[];
    direction?: "incoming" | "outgoing" | "both";
    max_depth?: number;
}, {
    source_nodes?: string[];
    relationship_types?: string[];
    direction?: "incoming" | "outgoing" | "both";
    max_depth?: number;
}>;
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[];
    relationship_types?: string[];
    target_nodes?: string[];
    max_hops?: number;
    path_limit?: number;
}, {
    source_nodes?: string[];
    relationship_types?: string[];
    target_nodes?: string[];
    max_hops?: number;
    path_limit?: number;
}>;
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[];
    }>, "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[];
    }[];
    execution_pattern?: "sequential" | "parallel" | "adaptive";
    fusion_strategy?: "union" | "intersection" | "weighted_average";
}>;
export type Node = z.infer<typeof NodeSchema>;
export type Relationship = z.infer<typeof RelationshipSchema>;
export type Chunk = z.infer<typeof ChunkSchema>;
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 ExecutionPattern = z.infer<typeof ExecutionPatternSchema>;
export type OperatorChain = z.infer<typeof OperatorChainSchema>;
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";
    relationship_weights?: Record<string, number>;
    normalize_scores?: boolean;
}, {
    source_nodes?: string[];
    aggregation_method?: "sum" | "average" | "max" | "weighted";
    relationship_weights?: Record<string, number>;
    normalize_scores?: boolean;
}>;
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;
    context_window?: number;
}>;
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;
    min_frequency?: number;
    include_positions?: boolean;
}>;
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[];
    edge_weights?: Record<string, number>;
    algorithm?: "exact" | "approximation";
    max_tree_size?: number;
}, {
    terminal_nodes?: string[];
    edge_weights?: Record<string, number>;
    algorithm?: "exact" | "approximation";
    max_tree_size?: number;
}>;
export declare const QueryPlanSchema: z.ZodObject<{
    id: z.ZodString;
    query: z.ZodString;
    intent: z.ZodEnum<["factual", "analytical", "exploratory", "comparative"]>;
    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[];
        }>, "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[];
        }[];
        execution_pattern?: "sequential" | "parallel" | "adaptive";
        fusion_strategy?: "union" | "intersection" | "weighted_average";
    }>;
    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";
    operator_chain?: {
        operators?: {
            type?: string;
            config?: Record<string, any>;
            dependencies?: string[];
        }[];
        execution_pattern?: "sequential" | "parallel" | "adaptive";
        fusion_strategy?: "union" | "intersection" | "weighted_average";
    };
    estimated_cost?: number;
    priority?: "low" | "medium" | "high" | "critical";
}, {
    id?: string;
    query?: string;
    intent?: "factual" | "analytical" | "exploratory" | "comparative";
    operator_chain?: {
        operators?: {
            type?: string;
            config?: Record<string, any>;
            dependencies?: string[];
        }[];
        execution_pattern?: "sequential" | "parallel" | "adaptive";
        fusion_strategy?: "union" | "intersection" | "weighted_average";
    };
    estimated_cost?: number;
    priority?: "low" | "medium" | "high" | "critical";
}>;
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 QueryPlan = z.infer<typeof QueryPlanSchema>;
export type Graph = PassageGraph | TreesGraph | KnowledgeGraph | DAG;
//# sourceMappingURL=graph.d.ts.map