import { EventEmitter } from 'events';
import { KnowledgeNode, KnowledgeEdge, NodeType, EdgeType, NodeMetadata, ConversationMessage, ProjectMemory, ConceptRelation, LearningStep } from '../types/memory';
import { MemoryManager } from './memory-manager';
export interface GraphConfig {
    maxNodes: number;
    maxEdges: number;
    clusteringThreshold: number;
    similarityThreshold: number;
    embeddingDimensions: number;
    updateFrequency: number;
    persistanceEnabled: boolean;
    indexingEnabled: boolean;
}
export interface NodeSimilarity {
    nodeId: string;
    similarity: number;
    sharedContexts: string[];
    relationship: EdgeType;
}
export interface GraphQuery {
    nodeTypes?: NodeType[];
    edgeTypes?: EdgeType[];
    concepts?: string[];
    timeRange?: {
        start: Date;
        end: Date;
    };
    maxHops?: number;
    minConfidence?: number;
    includeMetadata?: boolean;
}
export interface GraphAnalytics {
    nodeDistribution: Record<NodeType, number>;
    edgeDistribution: Record<EdgeType, number>;
    centralityScores: Record<string, number>;
    clusterCoherence: number;
    knowledgeGaps: string[];
    expertiseDomains: string[];
    learningPaths: LearningPath[];
}
export interface LearningPath {
    id: string;
    title: string;
    description: string;
    steps: LearningStep[];
    prerequisites: string[];
    difficulty: 'beginner' | 'intermediate' | 'advanced';
    estimatedTime: number;
    completion: number;
}
export interface ConceptMap {
    central_concept: string;
    related_concepts: ConceptRelation[];
    hierarchical_structure: ConceptHierarchy;
    cross_references: string[];
    examples: ConceptExample[];
    misconceptions: string[];
}
export interface ConceptHierarchy {
    parent?: string;
    children: string[];
    siblings: string[];
    dependencies: string[];
}
export interface ConceptExample {
    type: 'code' | 'explanation' | 'use_case' | 'anti_pattern';
    content: string;
    language?: string;
    context: string;
    difficulty: 'beginner' | 'intermediate' | 'advanced';
}
export declare class KnowledgeGraphBuilder extends EventEmitter {
    private logger;
    private memoryManager;
    private config;
    private graph;
    private nodeIndex;
    private edgeIndex;
    private conceptMap;
    private embedding;
    private clustering;
    private analytics;
    private updateTimer?;
    constructor(memoryManager: MemoryManager, config?: GraphConfig);
    buildFromConversations(conversations: ConversationMessage[]): Promise<void>;
    buildFromProjects(projects: ProjectMemory[]): Promise<void>;
    addConceptNode(concept: string, context: string[], metadata?: Partial<NodeMetadata>): Promise<string>;
    addRelationship(sourceId: string, targetId: string, relationshipType: EdgeType, weight?: number, properties?: Record<string, unknown>): Promise<string>;
    queryGraph(query: GraphQuery): Promise<{
        nodes: KnowledgeNode[];
        edges: KnowledgeEdge[];
    }>;
    findSimilarConcepts(concept: string, limit?: number): Promise<NodeSimilarity[]>;
    getConceptMap(concept: string): Promise<ConceptMap | null>;
    generateLearningPath(startConcept: string, targetConcept: string): Promise<LearningPath | null>;
    getGraphAnalytics(): Promise<GraphAnalytics>;
    identifyKnowledgeGaps(): Promise<string[]>;
    suggestConnections(): Promise<{
        source: string;
        target: string;
        reason: string;
    }[]>;
    private processMessage;
    private processProject;
    private addNode;
    private addEdge;
    private addEntityNode;
    private addIntentNode;
    private addProjectNode;
    private addInsightNode;
    private addPatternNode;
    private findNodeByLabel;
    private findEdge;
    private hasDirectConnection;
    private updateClusters;
    private calculateMetrics;
    private persistGraph;
    private startUpdateTimer;
    private performPeriodicUpdate;
    private generateNodeId;
    private generateEdgeId;
    private generateLearningPathId;
    private mapEntityTypeToNodeType;
    private calculateRecency;
    private linkToRelatedConcepts;
    private updateNodeContext;
    private linkCoOccurringEntities;
    private linkProjectToTechnologies;
    private pruneOldNodes;
    private pruneWeakEdges;
    private updateSearchIndex;
    private findSharedContexts;
    private inferRelationshipType;
    private getRelatedConcepts;
    private buildConceptHierarchy;
    private findConceptExamples;
    private findCrossReferences;
    private identifyMisconceptions;
    private findShortestPath;
    private findLearningResources;
    private estimateLearningTime;
    private assessPathDifficulty;
    shutdown(): Promise<void>;
}
//# sourceMappingURL=knowledge-graph.d.ts.map