import { KnowledgeSearchOptions, SearchConfig, BaseSearchResult, CodebaseKnowledgeConfigWithModels, CodebaseKnowledgeConfig, IGlobal, IInstance } from '@easbot/types';
export { CodebaseKnowledgeConfig, CodebaseKnowledgeConfigWithModels, SyncConfig } from '@easbot/types';
import { EmbeddingModelV3 } from '@ai-sdk/provider';
export { EmbeddingModelV3 as EmbeddingModel } from '@ai-sdk/provider';

type IndexState = 'uninitialized' | 'indexing' | 'complete' | 'partial' | 'failed' | 'stale';
interface FtsSearchResult {
    id: string;
    file_path: string;
    name: string;
    ast_type: string;
    language: Language;
    score: number;
    text: string;
    start_line: number;
    start_col: number;
    end_line: number;
    end_col: number;
}
declare class DatabaseManager {
    private db;
    private dbPath;
    private closed;
    private ftsAvailable;
    constructor(dbPath: string);
    private ensureSchema;
    private checkFtsAvailability;
    isFtsAvailable(): boolean;
    insertNode(node: Node): void;
    insertNodes(nodes: Node[]): void;
    private updateFtsNodesInternal;
    private updateFtsNode;
    private updateFtsNodes;
    insertEdge(edge: Edge): void;
    insertEdges(edges: Edge[]): void;
    queryNodes(filter: NodeQueryFilter): Node[];
    queryEdges(filter: EdgeQueryFilter): Edge[];
    queryAll<T = any>(sql: string, params?: (string | number)[]): T[];
    searchNodesFts(query: string, limit?: number): FtsSearchResult[];
    deleteNodesByFile(filePath: string): number;
    deleteEdgesByFile(filePath: string): number;
    getFileHash(filePath: string): string | null;
    setFileHash(filePath: string, hash: string): void;
    deleteFileHash(filePath: string): void;
    getAllFileHashes(): FileHashRecord[];
    checkIntegrity(): {
        issues: Array<{
            severity: 'error' | 'warn' | 'info';
            message: string;
        }>;
        stats: {
            nodes: number;
            edges: number;
            file_hashes: number;
            fts: number;
            node_embeddings: number;
            embedding_cache: number;
            parse_errors: number;
            unresolved_refs: number;
            name_segment_vocab: number;
            project_metadata: number;
            meta: number;
        };
    };
    getStatus(): {
        nodeCount: number;
        edgeCount: number;
        indexedFiles: number;
        dbPath: string;
        meta: Record<string, string>;
        indexState: IndexState;
        extractionVersion: number;
        isStale: boolean;
    };
    setLastSync(): void;
    getIndexState(): IndexState;
    setIndexState(state: IndexState): void;
    markIndexed(codebasePackageVersion: string): void;
    isIndexStale(): boolean;
    private detectAndMarkStaleOnInit;
    getNodeCount(): number;
    getEdgeCount(): number;
    getFileCount(): number;
    getNodeById(id: string): Node | null;
    getEdgeById(id: string): Edge | null;
    clearAll(options?: {
        keepEmbeddings?: boolean;
    }): void;
    getCachedEmbedding(contentHash: string): Float32Array | null;
    getVectorDims(): number | undefined;
    ensureVectorDims(dims: number): void;
    cacheEmbedding(contentHash: string, embedding: Float32Array): void;
    private deleteEmbeddingsByFile;
    getAllNodeEmbeddings(): Array<{
        node_id: string;
        embedding: Buffer;
    }>;
    storeNodeEmbeddings(embeddings: Array<{
        nodeId: string;
        embeddingText: string;
        embedding: Float32Array;
    }>): void;
    insertParseError(record: {
        filePath: string;
        language: string;
        stage: string;
        message: string;
        line?: number;
    }): number;
    insertUnresolvedRef(record: {
        fromNodeId?: string;
        referenceName: string;
        referenceKind: string;
        line?: number;
        col?: number;
        filePath: string;
        language: string;
        candidates?: string[];
    }): number;
    insertUnresolvedRefsBatch(records: Array<{
        fromNodeId?: string;
        referenceName: string;
        referenceKind: string;
        line?: number;
        col?: number;
        filePath: string;
        language: string;
        candidates?: string[];
    }>): number;
    insertNameSegment(segment: string, name: string): number;
    insertNameSegmentsBatch(pairs: Array<{
        segment: string;
        name: string;
    }>): number;
    setProjectMetadata(key: string, value: string): number;
    getNodeIdsByFile(filePath: string): string[];
    deleteFtsByFile(filePath: string): number;
    initialize(): void;
    close(): void;
    isClosed(): boolean;
    getDbPath(): string;
    transaction<T>(fn: () => T): T;
    getMeta(key: string): string | null;
    setMeta(key: string, value: string): void;
    deleteMeta(key: string): void;
}

type ParserInstance = any;
type LanguageInstance = any;
interface ParseTree {
    rootNode: SyntaxNode;
    walk(): TreeCursor;
    delete(): void;
}
interface SyntaxNode {
    type: string;
    text: string;
    startPosition: {
        row: number;
        column: number;
    };
    endPosition: {
        row: number;
        column: number;
    };
    childCount: number;
    children: SyntaxNode[];
    namedChildCount: number;
    namedChildren: SyntaxNode[];
    parent: SyntaxNode | null;
    childForFieldName(name: string): SyntaxNode | null;
    childForFieldId(id: number): SyntaxNode | null;
    firstChild: SyntaxNode | null;
    lastChild: SyntaxNode | null;
    nextSibling: SyntaxNode | null;
    prevSibling: SyntaxNode | null;
    nextNamedSibling: SyntaxNode | null;
    prevNamedSibling: SyntaxNode | null;
    descendantForPosition(position: {
        row: number;
        column: number;
    }): SyntaxNode;
    descendantsOfType(type: string | string[]): SyntaxNode[];
}
interface TreeCursor {
    nodeType: string;
    nodeText: string;
    startPosition: {
        row: number;
        column: number;
    };
    endPosition: {
        row: number;
        column: number;
    };
    gotoFirstChild(): boolean;
    gotoNextSibling(): boolean;
    gotoParent(): boolean;
    currentNode: SyntaxNode;
}
declare class ParserManager {
    private parsers;
    private initialized;
    private initPromise;
    initialize(): Promise<void>;
    private doInitialize;
    getParser(language: Language): ParserInstance | null;
    getLanguage(language: Language): LanguageInstance | null;
    detectLanguage(filePath: string): Language | null;
    parse(sourceCode: string, language: Language): ParseTree;
    parseFile(filePath: string, sourceCode: string): ParseTree;
    isLanguageSupported(language: Language): boolean;
    getSupportedLanguages(): Language[];
    isInitialized(): boolean;
    getStatus(): Record<Language, boolean>;
    dispose(): void;
}
declare function getParserManager(): Promise<ParserManager>;
declare function resetParserManager(): void;

type CodeSearchSource = 'fts' | 'structural' | 'vector' | 'basic';
interface SearchResult$1 extends BaseSearchResult {
    id: string;
    name: string;
    astType: string;
    language: Language;
    filePath: string;
    text: string;
    startLine: number;
    startCol: number;
    endLine: number;
    endCol: number;
    source: CodeSearchSource;
}
interface HybridSearchResult extends SearchResult$1 {
    vectorScore?: number;
    ftsScore?: number;
    hybridScore: number;
}
interface SearchOptions extends KnowledgeSearchOptions {
    language?: Language;
    filePath?: string;
    astType?: string;
    enableFts?: boolean;
    includeEdges?: boolean;
    edgesLimit?: number;
    embedding?: EmbeddingModelV3;
    enableEmbedding?: boolean;
}
interface RelationQueryOptions {
    maxDepth?: number;
    relationTypes?: RelationType[];
    direction?: 'incoming' | 'outgoing' | 'both';
    limit?: number;
}
declare class QueryInterface {
    private db;
    private embedding?;
    private config;
    constructor(db: DatabaseManager, embedding?: EmbeddingModelV3, config?: SearchConfig);
    search(query: string, options?: SearchOptions): Promise<NodeWithEdges[]>;
    private vectorSearchNodes;
    private getEdgesForNode;
    private embedText;
    private cosineSimilarity;
    private normalizeScore;
    queryNodes(filter: NodeQueryFilter): Node[];
    queryEdges(filter: EdgeQueryFilter): Edge[];
    queryEdgesWithNodes(filter: EdgeQueryFilter): EdgeWithNodes[];
    queryNeighbors(nodeId: string, options?: RelationQueryOptions): {
        nodes: Node[];
        edges: Edge[];
    };
    queryCallGraph(nodeId: string, depth?: number): Map<string, {
        callers: string[];
        callees: string[];
    }>;
    queryInheritance(nodeId: string): {
        ancestors: Node[];
        descendants: Node[];
    };
    queryMembers(nodeId: string, relation?: 'HAS_METHOD' | 'HAS_PROPERTY' | Array<'HAS_METHOD' | 'HAS_PROPERTY'>): Node[];
    queryOverrides(nodeId: string): Node[];
    getNode(nodeId: string): Node | null;
    getEdge(edgeId: string): Edge | null;
}
declare function createQueryInterface(db: DatabaseManager): QueryInterface;

type CodebaseConfig = CodebaseKnowledgeConfigWithModels;
type Language = 'ts' | 'tsx' | 'js' | 'py' | 'rs' | 'go' | 'c' | 'cpp' | 'csharp' | 'java' | 'scala' | 'ruby' | 'php' | 'zig';
declare const FILE_EXTENSION_MAP: Record<string, Language>;
type RelationType = 'CONTAINS' | 'CALLS' | 'IMPORTS' | 'TYPE_REFERENCES' | 'ANNOTATES' | 'EXTENDS' | 'IMPLEMENTS' | 'HAS_METHOD' | 'HAS_PROPERTY' | 'METHOD_OVERRIDES';
type ASTNodeType = 'class_declaration' | 'function_declaration' | 'method_declaration' | 'method_definition' | 'variable_declaration' | 'import_declaration' | 'import_statement' | 'interface_declaration' | 'type_alias_declaration' | 'enum_declaration' | 'struct_item' | 'impl_item' | 'trait_item' | 'function_definition' | 'function_item' | 'class_definition' | 'module' | 'identifier' | 'type_identifier' | 'property_identifier' | 'field_identifier' | 'call_expression' | 'new_expression' | 'member_expression' | 'assignment_expression' | 'binary_expression' | 'unary_expression' | 'arrow_function' | 'function_expression' | 'lexical_declaration' | 'variable_declarator' | 'formal_parameters' | 'parameter' | 'required_parameter' | 'optional_parameter' | 'rest_parameter' | 'object_type' | 'array_type' | 'union_type' | 'intersection_type' | 'literal_type' | 'generic_type' | 'named_imports' | 'import_clause' | 'export_statement' | 'export_clause' | 'decorator' | 'attribute_item' | 'macro_definition' | 'macro_invocation' | 'namespace_definition' | 'using_directive' | 'class_heredoc' | 'trait_adaptations' | 'namespace_declaration' | 'define_directive' | 'preproc_if' | 'preproc_function_def';
interface Node {
    id: string;
    name: string;
    ast_type: string;
    language: Language;
    file_path: string;
    start_line: number;
    start_col: number;
    end_line: number;
    end_col: number;
    text: string;
    created_at: string;
}
interface Edge {
    id: string;
    source: string;
    target: string;
    relation: RelationType;
    created_at: string;
}
interface NodeWithEdges extends Node {
    edges: Edge[];
}
interface ExtractedNode {
    name: string;
    ast_type: string;
    language: Language;
    file_path: string;
    start_line: number;
    start_col: number;
    end_line: number;
    end_col: number;
    text: string;
    parent_id?: string;
    metadata?: Record<string, unknown>;
}
interface ExtractedEdge {
    source: string;
    target: string;
    relation: RelationType;
    line?: number;
    col?: number;
    filePath?: string;
}
type CodeKnowledgeGraphConfig = CodebaseKnowledgeConfig;
interface NodeQueryFilter {
    filePath?: string;
    astType?: string;
    name?: string;
    language?: Language;
    ids?: string[];
    limit?: number;
    offset?: number;
}
interface EdgeQueryFilter {
    source?: string;
    target?: string;
    sourceOrTarget?: string[];
    relation?: RelationType;
    limit?: number;
    offset?: number;
}
interface EdgeWithNodes {
    edge: Edge;
    sourceNode: Node | null;
    targetNode: Node | null;
}
interface IndexResult {
    success: boolean;
    filesProcessed: number;
    nodesCreated: number;
    edgesCreated: number;
    errors: Array<{
        filePath: string;
        error: string;
    }>;
    duration: number;
}
interface SyncResult {
    success: boolean;
    filesAdded: number;
    filesUpdated: number;
    filesDeleted: number;
    filesSkipped: number;
    nodesCreated: number;
    edgesCreated: number;
    skipped?: boolean;
    errors: Array<{
        filePath: string;
        error: string;
    }>;
    duration: number;
}
interface GraphStatus {
    dbPath: string;
    nodeCount: number;
    edgeCount: number;
    indexedFiles: number;
    workspaceDir: string;
    meta: Record<string, string>;
    healthy: boolean;
    indexState?: IndexState;
    extractionVersion?: number;
    isStale?: boolean;
    indexedWithVersion?: string;
    lastSync?: string;
}
interface HealthCheckResult {
    healthy: boolean;
    issues: string[];
    nodeCount: number;
    edgeCount: number;
    fileCount: number;
    ftsAvailable: boolean;
    parserStatus: Record<Language, boolean>;
    database?: boolean;
    parsers?: Record<Language, boolean>;
    errors?: string[];
}
interface FileHashRecord {
    file_path: string;
    content_hash: string;
    last_modified: string;
}
type ProgressCallback = (progress: {
    currentFile: string;
    processed: number;
    total: number;
    stage: 'parsing' | 'extracting' | 'storing' | 'embedding';
}) => void;
interface IParser {
    parse(sourceCode: string): unknown;
    getLanguage(): Language;
}
interface INodeExtractor {
    extractNodes(tree: unknown, source: string, language: Language, filePath: string): ExtractedNode[];
}
interface IEdgeExtractor {
    extractEdges(tree: unknown, nodes: ExtractedNode[], language: Language, filePath: string): ExtractedEdge[];
}

interface ICodebase {
    initialize(): Promise<void>;
    indexFile(filePath: string, progress?: ProgressCallback): Promise<IndexResult>;
    indexDirectory(dir?: string, progress?: ProgressCallback): Promise<IndexResult>;
    sync(progress?: ProgressCallback): Promise<SyncResult>;
    markDirty(): void;
    search(query: string, options?: SearchOptions): Promise<NodeWithEdges[]>;
    queryNodes(filter: NodeQueryFilter): Promise<Node[]>;
    queryEdges(filter: EdgeQueryFilter): Promise<Edge[]>;
    queryNeighbors(nodeId: string, options?: RelationQueryOptions): Promise<{
        nodes: Node[];
        edges: Edge[];
    }>;
    queryCallGraph(nodeId: string, depth?: number): Promise<Map<string, {
        callers: string[];
        callees: string[];
    }>>;
    queryInheritance(nodeId: string): Promise<{
        ancestors: Node[];
        descendants: Node[];
    }>;
    queryMembers(nodeId: string, relation?: 'HAS_METHOD' | 'HAS_PROPERTY' | Array<'HAS_METHOD' | 'HAS_PROPERTY'>): Promise<Node[]>;
    queryOverrides(nodeId: string): Promise<Node[]>;
    getNode(nodeId: string): Promise<Node | null>;
    getEdge(edgeId: string): Promise<Edge | null>;
    getStatus(): Promise<GraphStatus>;
    healthCheck(): Promise<HealthCheckResult>;
    clear(): Promise<void>;
    close(): Promise<void>;
    getDatabase(): DatabaseManager;
    getParser(): ParserManager;
    getQuery(): QueryInterface;
}

declare class ParserError extends Error {
    readonly name = "ParserError";
    readonly filePath: string;
    readonly cause?: Error;
    constructor(message: string, filePath: string, cause?: Error);
    toString(): string;
    toJSON(): Record<string, unknown>;
}
declare class DatabaseError extends Error {
    readonly name = "DatabaseError";
    readonly operation: string;
    readonly cause?: Error;
    constructor(message: string, operation: string, cause?: Error);
    toString(): string;
    toJSON(): Record<string, unknown>;
}
declare class FileSystemError extends Error {
    readonly name = "FileSystemError";
    readonly filePath: string;
    readonly cause?: Error;
    constructor(message: string, filePath: string, cause?: Error);
    toString(): string;
    toJSON(): Record<string, unknown>;
}
declare class SchemaError extends Error {
    readonly name = "SchemaError";
    readonly missing?: string[];
    constructor(message: string, missing?: string[]);
    toString(): string;
    toJSON(): Record<string, unknown>;
}
declare class ConfigError extends Error {
    readonly name = "ConfigError";
    readonly field?: string;
    constructor(message: string, field?: string);
    toString(): string;
    toJSON(): Record<string, unknown>;
}
declare class IndexError extends Error {
    readonly name = "IndexError";
    readonly filePath?: string;
    readonly cause?: Error;
    constructor(message: string, filePath?: string, cause?: Error);
    toString(): string;
    toJSON(): Record<string, unknown>;
}
declare class QueryError extends Error {
    readonly name = "QueryError";
    readonly params?: Record<string, unknown>;
    readonly cause?: Error;
    constructor(message: string, params?: Record<string, unknown>, cause?: Error);
    toString(): string;
    toJSON(): Record<string, unknown>;
}
declare class UnsupportedLanguageError extends Error {
    readonly name = "UnsupportedLanguageError";
    readonly extension: string;
    readonly filePath: string;
    constructor(extension: string, filePath: string);
    toString(): string;
    toJSON(): Record<string, unknown>;
}

declare class NodeExtractor {
    extractNodes(tree: ParseTree, source: string, language: Language, filePath: string): ExtractedNode[];
    private walkTree;
    private extractNode;
    private extractParameterTypes;
    private findTypeInNode;
    private getNodeName;
    private findNameInChildren;
    private findNameInGrandchildren;
    private extractImportName;
    private getNodeText;
    generateNodeId(node: ExtractedNode): string;
}
declare function createNodeExtractor(): NodeExtractor;

declare class EdgeExtractor {
    extractEdges(tree: ParseTree, nodes: ExtractedNode[], language: Language, filePath: string): ExtractedEdge[];
    private extractContainsEdges;
    private extractCallEdges;
    private extractInheritanceEdges;
    private collectTypeAnnotations;
    private collectNamedIdentifiers;
    private extractClauseNames;
    private extractImportEdges;
    private walkTree;
    private findEnclosingFunction;
    private extractCalleeName;
    private extractImportPaths;
    private extractPythonImportPaths;
    private extractImportWholePath;
    generateNodeId(node: ExtractedNode): string;
    private extractTypeReferences;
    private extractHasMethodEdges;
    private extractHasPropertyEdges;
    private emitContainerToMemberEdges;
    private extractOverrideEdges;
    private collectMemberIdsByName;
    private buildImportAliasMap;
    private findEnclosingClass;
    private extractAnnotationEdges;
    private extractTypeName;
    private resolveTypeNodeId;
    private generateNodeIdFromName;
}
declare function createEdgeExtractor(): EdgeExtractor;

interface WriteStatement {
    sql: string;
    params: unknown[];
}
interface AsyncWriteBackendOptions {
    dbPath: string;
    mock?: boolean;
    batchSize?: number;
    batchIntervalMs?: number;
    queueMax?: number;
    betterSqlite3Path?: string;
}
declare class AsyncWriteBackend {
    private worker;
    private readonly mock;
    private readonly dbPath;
    private readonly batchSize;
    private readonly batchIntervalMs;
    private readonly queueMax;
    private bufferedStatements;
    private pendingRequests;
    private nextRequestId;
    private flushTimer;
    readonly ready: Promise<void>;
    private disposed;
    constructor(options: AsyncWriteBackendOptions);
    private initRealAsync;
    private installAckHandler;
    private requireWorker;
    private waitForReady;
    waitReady(): Promise<void>;
    enqueue(statements: WriteStatement[]): void;
    private flushBuffer;
    flush(timeoutMs?: number): Promise<void>;
    dispose(): Promise<void>;
    pendingCount(): number;
}

declare class WriteProxy {
    private readonly db;
    private readonly writeBackend;
    private readonly options;
    constructor(db: DatabaseManager, writeBackend: AsyncWriteBackend, options?: {
        ftsAvailable?: boolean;
    });
    insertNodes(nodes: Node[]): void;
    insertEdges(edges: Edge[]): void;
    setFileHash(filePath: string, hash: string): void;
    setLastSync(): void;
    cacheEmbedding(contentHash: string, embedding: Float32Array): void;
    storeNodeEmbeddings(embeddings: Array<{
        nodeId: string;
        embeddingText: string;
        embedding: Float32Array;
    }>): void;
    deleteEdgesByFile(filePath: string): number;
    deleteNodesByFile(filePath: string): number;
    deleteFtsByFile(filePath: string): number;
    deleteFileHash(filePath: string): void;
    flush(): Promise<void>;
    setMeta(key: string, value: string): void;
    deleteMeta(key: string): void;
    markIndexed(codebasePackageVersion: string, extractionVersion: number, timestamp: string): void;
    setIndexState(state: 'uninitialized' | 'indexing' | 'complete' | 'partial' | 'failed' | 'stale'): void;
    dispose(): Promise<void>;
    pendingCount(): number;
}

interface IndexerConfig {
    workspaceDir: string;
    batchSize: number;
    ignorePatterns: string[];
    incremental: boolean;
    embedding: EmbeddingModelV3;
}
declare class Indexer {
    private db;
    private parserManager;
    private nodeExtractor;
    private edgeExtractor;
    private config;
    private writeProxy;
    constructor(db: DatabaseManager, parserManager: ParserManager, config: IndexerConfig, writeProxy?: WriteProxy);
    flushPendingWrites(): Promise<void>;
    private get dbWriter();
    private generateNodeEmbeddingText;
    private embedText;
    indexFile(filePath: string, progress?: ProgressCallback): Promise<IndexResult>;
    indexDirectory(dir?: string, progress?: ProgressCallback): Promise<IndexResult>;
    sync(progress?: ProgressCallback): Promise<SyncResult>;
    private scanFiles;
    private loadGitignore;
    private toRelativePosix;
    private readFile;
    private computeHash;
    private storeNodes;
    private storeNameSegments;
    private splitIdentifier;
    private storeEdges;
    private storeUnresolvedRefs;
    private getValidEdgeCount;
    private embedNodes;
    private chunkArray;
}
declare function createIndexer(db: DatabaseManager, parserManager: ParserManager, config: IndexerConfig): Indexer;

declare class CodeBase implements ICodebase {
    private config;
    private db;
    private writeBackend;
    private writeProxy;
    private parserManager;
    private indexer;
    private queryInterface;
    private initialized;
    private dirty;
    private syncTimer?;
    private syncingInProgress;
    private codebasePackageVersion;
    private fileWatcher;
    private get dbWriter();
    constructor(config?: Partial<CodebaseConfig>);
    initialize(): Promise<void>;
    private startSyncTimer;
    private stopSyncTimer;
    private ensureSynced;
    markDirty(): void;
    private validateConfig;
    private resolveDbPath;
    indexFile(filePath: string, progress?: ProgressCallback): Promise<IndexResult>;
    indexDirectory(dir?: string, progress?: ProgressCallback): Promise<IndexResult>;
    sync(progress?: ProgressCallback): Promise<SyncResult>;
    watch(options?: {
        ignorePatterns?: string[];
        debounceMs?: number;
        initialSync?: boolean;
    }): Promise<{
        stop(): Promise<void>;
    }>;
    search(query: string, options?: SearchOptions): Promise<NodeWithEdges[]>;
    queryNodes(filter: NodeQueryFilter): Promise<Node[]>;
    queryEdges(filter: EdgeQueryFilter): Promise<Edge[]>;
    queryNeighbors(nodeId: string, options?: RelationQueryOptions): Promise<{
        nodes: Node[];
        edges: Edge[];
    }>;
    queryCallGraph(nodeId: string, depth?: number): Promise<Map<string, {
        callers: string[];
        callees: string[];
    }>>;
    queryInheritance(nodeId: string): Promise<{
        ancestors: Node[];
        descendants: Node[];
    }>;
    queryMembers(nodeId: string, relation?: 'HAS_METHOD' | 'HAS_PROPERTY' | Array<'HAS_METHOD' | 'HAS_PROPERTY'>): Promise<Node[]>;
    queryOverrides(nodeId: string): Promise<Node[]>;
    getNode(nodeId: string): Promise<Node | null>;
    getEdge(edgeId: string): Promise<Edge | null>;
    getStatus(): Promise<GraphStatus>;
    healthCheck(): Promise<HealthCheckResult>;
    clear(options?: {
        keepEmbeddings?: boolean;
    }): Promise<void>;
    close(): Promise<void>;
    private ensureInitialized;
    getDatabase(): DatabaseManager;
    getParser(): ParserManager;
    getQuery(): QueryInterface;
    getWorkspaceDir(): string;
}
declare function createCodebase(config?: Partial<CodebaseConfig>): Promise<ICodebase>;

declare const I18n: {
    readonly defaultLocale: "zh-CN";
    readonly timeZone: "Asia/Shanghai";
    readonly locales: string[];
};
type Locale = (typeof I18n)['locales'][number];

interface CodebaseCliDeps {
    version?: string;
    cwd?: string;
    locale?: Locale;
}
interface CodebaseCliResult {
    code: number;
    handled: boolean;
    command?: string;
}
declare function renderBanner(deps?: CodebaseCliDeps): void;
declare function renderHelp(deps?: CodebaseCliDeps): void;
declare function handleCodebaseCli(args: string[], deps?: CodebaseCliDeps): Promise<CodebaseCliResult>;

interface FormattedNode {
    id: string;
    name: string;
    astType: string;
    language: string;
    filePath: string;
    startLine: number;
    endLine: number;
    isExported: boolean;
    modifiers: string[];
}
interface FormattedEdge {
    id: string;
    source: string;
    target: string;
    relation: string;
    direction?: 'in' | 'out';
}
interface FormattedSearchHit {
    node: FormattedNode;
    source: string;
    score: number;
    snippet: string;
    edges: FormattedEdge[];
}
declare function formatCodebaseNode(node: Node): FormattedNode;
declare function formatCodebaseEdge(edge: Edge, direction?: 'in' | 'out'): FormattedEdge;
declare function formatCodebaseSearchHits(nodes: Array<Node & {
    edges?: Edge[];
}>, sources: string[], scores: number[]): FormattedSearchHit[];
declare function emptyFormattedNode(): FormattedNode;

interface PendingFile {
    path: string;
    lastEventAt: number;
}
interface RenderOptions {
    pendingFiles?: PendingFile[];
    toolName: string;
    softLimit?: number;
    hardCeiling?: number;
    sync?: boolean;
    writeToDisk?: boolean;
}
interface ImpactBucket {
    depth: number;
    count: number;
    riskLabel: string;
    samples: Array<{
        name: string;
        file: string;
        line: number;
        relation: string;
    }>;
}
interface ContextInput {
    root: FormattedNode;
    incoming: FormattedEdge[];
    outgoing: FormattedEdge[];
    neighbors: Array<{
        node: FormattedNode;
        depth: number;
    }>;
}
declare function renderSearchResult(hits: FormattedSearchHit[], options: RenderOptions): Promise<string>;
declare function renderImpact(root: FormattedNode, buckets: ImpactBucket[], options: RenderOptions): Promise<string>;
declare function defaultRiskLabel(depth: number): string;
declare function renderContext(input: ContextInput, options: RenderOptions): Promise<string>;
declare function renderNode(node: FormattedNode, edges: FormattedEdge[], options: RenderOptions): Promise<string>;

declare const SECTION_MARKER = "**`";
declare const SECTION_END = "**";
interface TruncateOptions {
    softLimit?: number;
    hardCeiling?: number;
    toolName?: string;
    writeToDisk?: boolean;
}
type TruncateResult = {
    content: string;
    truncated: false;
} | {
    content: string;
    truncated: true;
    outputPath: string;
    hint: string;
    info: string;
};
declare function truncateAtSectionBoundary(text: string, options?: TruncateOptions): Promise<TruncateResult>;
declare function truncateAtSectionBoundarySync(text: string, options?: TruncateOptions): TruncateResult;

interface ServiceContext {
    workspaceDir: string;
    rootDir: string;
}
type NodeKind = 'function' | 'method' | 'class' | 'interface' | 'type' | 'variable' | 'route' | 'component' | 'const';
interface SearchParams {
    query?: string;
    kind?: NodeKind | string;
    file?: string;
    intent?: string;
    includeContent?: boolean;
    maxResults?: number;
    language?: Language;
    astType?: string;
    enableFts?: boolean;
    enableEmbedding?: boolean;
}
interface SearchHit {
    node: Node;
    edges: Edge[];
    source: string;
    score: number;
    snippet: string;
}
interface SearchResult {
    total: number;
    hits: SearchHit[];
    durationMs: number;
    truncated: boolean;
}
interface NodeParams {
    name?: string;
    nodeId?: string;
    file?: string;
    kind?: string;
    includeEdges?: boolean;
    includeContent?: boolean;
    edgesLimit?: number;
}
interface NodeResult {
    node: Node | null;
    edges: Edge[];
    ambiguous?: Array<{
        node: Node;
        score: number;
    }>;
}
interface ContextParams {
    name?: string;
    nodeId?: string;
    file?: string;
    kind?: string;
    depth?: number;
    maxNodes?: number;
    direction?: 'incoming' | 'outgoing' | 'both';
    relationTypes?: RelationType[];
}
interface ContextNode {
    node: Node;
    depth: number;
}
interface ContextResult {
    root: Node | null;
    nodes: ContextNode[];
    edges: Edge[];
    truncated: boolean;
    totalNodes: number;
    totalEdges: number;
}
interface ImpactParams {
    name?: string;
    nodeId?: string;
    file?: string;
    kind?: string;
    depth?: number;
    relationTypes?: RelationType[];
    maxResults?: number;
}
interface ImpactBucketEntry {
    depth: number;
    count: number;
    sample: Array<{
        id: string;
        name: string;
        filePath: string;
        relation: string;
    }>;
}
interface ImpactResult {
    root: Node | null;
    totalImpacted: number;
    buckets: ImpactBucketEntry[];
}
interface CallersParams {
    name?: string;
    nodeId?: string;
    file?: string;
    kind?: string;
    relationTypes?: RelationType[];
    maxResults?: number;
}
interface CallerEntry {
    id: string;
    name: string;
    astType: string;
    filePath: string;
    startLine: number;
    relation: string;
}
interface CallersResult {
    root: Node | null;
    callers: CallerEntry[];
    truncated: boolean;
}
interface CalleesParams extends CallersParams {
}
interface CalleesResult extends CallersResult {
}
interface ExploreParams {
    query: string;
    file?: string;
    kind?: string;
    maxFiles?: number;
    maxSymbols?: number;
    depth?: number;
    includeContent?: boolean;
    intent?: string;
}
interface ExploreEntryPoint {
    file: string;
    symbols: Array<{
        node: Node;
        callers: CallerEntry[];
        callees: CallerEntry[];
    }>;
}
interface ExploreResult {
    query: string;
    entryPoints: ExploreEntryPoint[];
    totalHits: number;
}
type StatusParams = {};
type StatusResult = GraphStatus;
type DoctorParams = {};
type DoctorResult = HealthCheckResult;
declare class ServiceError extends Error {
    readonly code: 'NOT_FOUND' | 'AMBIGUOUS' | 'INTERNAL' | 'NOT_INDEXED';
    readonly details?: Record<string, unknown> | undefined;
    constructor(message: string, code: 'NOT_FOUND' | 'AMBIGUOUS' | 'INTERNAL' | 'NOT_INDEXED', details?: Record<string, unknown> | undefined);
}
declare class NotFoundError extends ServiceError {
    constructor(name: string, candidates?: Array<{
        node: Node;
        score: number;
    }>);
}
declare class AmbiguousError extends ServiceError {
    constructor(name: string, candidates: Array<{
        node: Node;
        score: number;
    }>);
}

declare function renderSearch(nodes: NodeWithEdges[], options: RenderOptions): Promise<string>;
declare function renderImpactFromTuples(root: Node, tuples: Array<{
    source: Node;
    relation: string;
}>, options: RenderOptions): Promise<string>;
declare function renderContextFromQuery(root: Node, incoming: Edge[], outgoing: Edge[], neighbors: Node[], options: RenderOptions): Promise<string>;
declare function renderNodeDetail(node: Node | null, edges: Edge[], options: RenderOptions): Promise<string>;
declare function renderExploreFromResult(result: ExploreResult, options: RenderOptions): Promise<string>;

declare function search(ctx: ServiceContext, params: SearchParams): Promise<SearchResult>;
declare function node(ctx: ServiceContext, params: NodeParams): Promise<NodeResult>;
declare function context(ctx: ServiceContext, params: ContextParams): Promise<ContextResult>;
declare function impact(ctx: ServiceContext, params: ImpactParams): Promise<ImpactResult>;
declare function callers(ctx: ServiceContext, params: CallersParams): Promise<CallersResult>;
declare function callees(ctx: ServiceContext, params: CalleesParams): Promise<CalleesResult>;
declare function explore(ctx: ServiceContext, params: ExploreParams): Promise<ExploreResult>;
declare function status(ctx: ServiceContext, _params: StatusParams): Promise<StatusResult>;
declare function doctor(ctx: ServiceContext, _params: DoctorParams): Promise<DoctorResult>;

declare function setGlobalAdapter(global: IGlobal | null): void;
declare function resetGlobalAdapter(): void;
declare function getGlobal(): IGlobal;
declare function setInstanceAdapter(instance: IInstance | null): void;
declare function resetInstanceAdapter(): void;
declare function getInstance(): IInstance;
declare function getHomeDir(): string;
declare function getXdgData(): string;
declare function getXdgConfig(): string;
declare function getXdgState(): string;
declare function getXdgCache(): string;
declare function getProjectDirectory(): string;

export { type ASTNodeType, AmbiguousError, type CalleesParams, type CalleesResult, type CallerEntry, type CallersParams, type CallersResult, CodeBase, type CodeKnowledgeGraphConfig, type CodebaseCliDeps, type CodebaseCliResult, type CodebaseConfig, ConfigError, type ContextInput, type ContextNode, type ContextParams, type ContextResult, DatabaseError, DatabaseManager, type DoctorParams, type DoctorResult, type Edge, EdgeExtractor, type EdgeQueryFilter, type EdgeWithNodes, type ExploreEntryPoint, type ExploreParams, type ExploreResult, type ExtractedEdge, type ExtractedNode, FILE_EXTENSION_MAP, type FileHashRecord, FileSystemError, type FormattedEdge, type FormattedNode, type FormattedSearchHit, type GraphStatus, type HealthCheckResult, type HybridSearchResult, type ICodebase, type IEdgeExtractor, type INodeExtractor, type IParser, type ImpactBucket, type ImpactBucketEntry, type ImpactParams, type ImpactResult, IndexError, type IndexResult, Indexer, type IndexerConfig, type Language, type Node, NodeExtractor, type NodeKind, type NodeParams, type NodeQueryFilter, type NodeResult, type NodeWithEdges, NotFoundError, ParserError, ParserManager, type PendingFile, type ProgressCallback, QueryError, QueryInterface, type RelationQueryOptions, type RelationType, type RenderOptions, SECTION_END, SECTION_MARKER, SchemaError, type SearchHit, type SearchOptions, type SearchParams, type SearchResult$1 as SearchResult, type ServiceContext, ServiceError, type StatusParams, type StatusResult, type SyncResult, type TruncateOptions, type TruncateResult, UnsupportedLanguageError, callees, callers, context, createCodebase, createEdgeExtractor, createIndexer, createNodeExtractor, createQueryInterface, defaultRiskLabel, doctor, emptyFormattedNode, explore, formatCodebaseEdge, formatCodebaseNode, formatCodebaseSearchHits, getGlobal, getHomeDir, getInstance, getParserManager, getProjectDirectory, getXdgCache, getXdgConfig, getXdgData, getXdgState, handleCodebaseCli, impact, node, renderBanner, renderContext, renderContextFromQuery, renderExploreFromResult, renderHelp, renderImpact, renderImpactFromTuples, renderNode, renderNodeDetail, renderSearch, renderSearchResult, resetGlobalAdapter, resetInstanceAdapter, resetParserManager, search, setGlobalAdapter, setInstanceAdapter, status, truncateAtSectionBoundary, truncateAtSectionBoundarySync };