/**
 * KiroGraph — Semantic code knowledge graph for Kiro
 *
 * Pure facade. Every method delegates to a focused sub-system.
 * No business logic lives here.
 */
import type { KiroGraphConfig } from './config';
import type { FileTreeNode, FileTree } from './core/file-tree';
import type { Node, NodeKind, IndexResult, IndexProgress, SyncResult, TaskContext, SearchResult, SearchOptions, NodeContext, NodeMetrics } from './types';
import type { ArchitectureResult } from './architecture/types';
export type { FileTreeNode, FileTree };
export default class KiroGraph {
    private readonly db;
    private readonly config;
    private readonly projectRoot;
    private readonly queryManager;
    private readonly resolver;
    private readonly vectors;
    private readonly contextBuilder;
    private readonly arch;
    private readonly lock;
    private readonly pipeline;
    private readonly searcher;
    private constructor();
    static init(projectRoot: string, config?: Partial<KiroGraphConfig>): Promise<KiroGraph>;
    static open(projectRoot: string): Promise<KiroGraph>;
    static isInitialized(projectRoot: string): boolean;
    unlockForce(): void;
    markDirty(): void;
    clearDirty(): void;
    isDirty(): boolean;
    syncIfDirty(): Promise<SyncResult | null>;
    indexAll(opts?: {
        onProgress?: (p: IndexProgress) => void;
        force?: boolean;
        signal?: AbortSignal;
    }): Promise<IndexResult>;
    sync(changedFiles?: string[]): Promise<SyncResult>;
    searchNodes(query: string, kindOrOpts?: NodeKind | SearchOptions, limit?: number): SearchResult[];
    getCallers(nodeId: string, limit?: number): Promise<Node[]>;
    getCallees(nodeId: string, limit?: number): Promise<Node[]>;
    getImpactRadius(nodeId: string, depth?: number): Promise<Node[]>;
    findDeadCode(limit?: number): Node[];
    findCircularDependencies(): string[][];
    findPath(fromId: string, toId: string, maxDepth?: number): Promise<Node[]>;
    getTypeHierarchy(nodeId: string, direction?: 'up' | 'down' | 'both'): Node[];
    getNode(id: string): Node | null;
    getNodeContext(nodeId: string): NodeContext | null;
    getNodeMetrics(nodeId: string): NodeMetrics;
    getNodeSource(node: Node): string | null;
    buildContext(task: string, opts?: {
        maxNodes?: number;
        includeCode?: boolean;
    }): Promise<TaskContext>;
    getFiles(opts?: {
        filterPath?: string;
        pattern?: string;
        maxDepth?: number;
    }): FileTree;
    getAffectedTests(changedFiles: string[], opts?: {
        depth?: number;
        testPattern?: string;
    }): string[];
    getStats(): Promise<{
        architectureStats?: {
            packages: number;
            layers: number;
            packageDeps: number;
        };
        embeddingCount: number;
        embeddableNodeCount: number;
        embeddingsEnabled: boolean;
        embeddingModel: string;
        useVecIndex: boolean;
        semanticEngine: "cosine" | "sqlite-vec" | "orama" | "pglite" | "lancedb" | "qdrant" | "typesense";
        vecIndexCount: number;
        engineFallback: string | null;
        frameworks: string[];
        architectureEnabled: boolean;
        files: number;
        nodes: number;
        edges: number;
        nodesByKind: Record<string, number>;
        filesByLanguage: Record<string, number>;
        dbSizeBytes: number;
    }>;
    getEngineFallback(): string | null;
    getArchitecture(): ArchitectureResult & {
        filePackages: Record<string, string[]>;
        fileLayers: Record<string, Array<{
            layerId: string;
            confidence: number;
            matchedPattern: string;
        }>>;
    };
    isArchitectureEnabled(): boolean;
    getProjectRoot(): string;
    close(): void;
}
/** Walk up directories to find the nearest .kirograph/ folder. */
export declare function findNearestKiroGraphRoot(startPath: string): string | null;
//# sourceMappingURL=index.d.ts.map