import Database from 'better-sqlite3';
import type { Definition } from '../parser/definition-extractor.js';
import type { FileReference, ImportedSymbol, SymbolUsage } from '../parser/reference-extractor.js';
import { type CallsiteResult, type FileInsert, type IIndexWriter } from './schema.js';
import { CallGraphService } from './repositories/call-graph-service.js';
import { ContractRepository } from './repositories/contract-repository.js';
import { DefinitionRepository } from './repositories/definition-repository.js';
import { DependencyRepository } from './repositories/dependency-repository.js';
import { DomainRepository } from './repositories/domain-repository.js';
import { FeatureRepository } from './repositories/feature-repository.js';
import { FileRepository } from './repositories/file-repository.js';
import { FlowRepository } from './repositories/flow-repository.js';
import { GraphRepository } from './repositories/graph-repository.js';
import { InteractionAnalysis } from './repositories/interaction-analysis.js';
import { InteractionRepository } from './repositories/interaction-repository.js';
import { MetadataRepository } from './repositories/metadata-repository.js';
import { ModuleRepository } from './repositories/module-repository.js';
import { RelationshipRepository } from './repositories/relationship-repository.js';
import { SyncDirtyRepository } from './repositories/sync-dirty-repository.js';
/**
 * Database access layer that owns the connection and exposes repositories.
 * Implements IIndexWriter for the parse/indexing pipeline.
 */
export declare class IndexDatabase implements IIndexWriter {
    private conn;
    private _sourceDirectory;
    readonly files: FileRepository;
    readonly definitions: DefinitionRepository;
    readonly metadata: MetadataRepository;
    readonly dependencies: DependencyRepository;
    readonly relationships: RelationshipRepository;
    readonly domains: DomainRepository;
    readonly modules: ModuleRepository;
    readonly interactions: InteractionRepository;
    readonly contracts: ContractRepository;
    readonly features: FeatureRepository;
    readonly flows: FlowRepository;
    readonly graph: GraphRepository;
    readonly callGraph: CallGraphService;
    readonly interactionAnalysis: InteractionAnalysis;
    readonly syncDirty: SyncDirtyRepository;
    constructor(dbPath: string);
    initialize(): void;
    close(): void;
    getConnection(): Database.Database;
    getSourceDirectory(): string;
    resolveFilePath(dbPath: string): string;
    toRelativePath(absolutePath: string): string;
    setMetadata(key: string, value: string): void;
    insertFile(file: FileInsert): number;
    insertDefinition(fileId: number, def: Definition): number;
    insertReference(fromFileId: number, toFileId: number | null, ref: FileReference): number;
    insertSymbol(refId: number | null, defId: number | null, sym: ImportedSymbol, fileId?: number): number;
    insertUsage(symbolId: number, usage: SymbolUsage): void;
    getDefinitionByName(fileId: number, name: string): number | null;
    getDefinitionCount(): number;
    getReferenceCount(): number;
    getUsageCount(): number;
    getCallsites(definitionId: number): CallsiteResult[];
    getCallsitesForFile(fileId: number): CallsiteResult[];
    getCallsiteCount(): number;
    /**
     * Get overall database stats (cross-repo aggregation)
     */
    getStats(): {
        files: number;
        definitions: number;
        imports: number;
        usages: number;
        callsites: number;
        modules: number;
        assignedSymbols: number;
        unassignedSymbols: number;
        flows: number;
        interactions: number;
        relationships: number;
    };
    /**
     * Get exported definitions that are not called by anything (entry points)
     */
    getRootDefinitions(): Array<{
        id: number;
        name: string;
        kind: string;
        filePath: string;
        line: number;
    }>;
    /**
     * Find ghost rows: rows referencing entities that no longer exist.
     * Each query is wrapped in try/catch since tables may not exist.
     */
    findGhostRows(): {
        ghostRelationships: Array<{
            id: number;
            table: string;
        }>;
        ghostMembers: Array<{
            definitionId: number;
            table: string;
        }>;
        ghostEntryPoints: Array<{
            id: number;
            table: string;
        }>;
        ghostEntryModules: Array<{
            id: number;
            table: string;
        }>;
        ghostInteractions: Array<{
            id: number;
            table: string;
        }>;
        ghostSubflows: Array<{
            rowid: number;
            table: string;
        }>;
    };
    /**
     * Delete a ghost row by table and primary key.
     * Uses an allowlist of table names to prevent injection.
     */
    deleteGhostRow(table: string, id: number): boolean;
    /**
     * Remove stale file entries (files that no longer exist on disk).
     */
    cleanStaleFiles(): {
        removed: number;
        paths: string[];
    };
}
//# sourceMappingURL=database-facade.d.ts.map