export interface SymbolInfo {
    name: string;
    kind: 'function' | 'class' | 'interface' | 'type' | 'variable' | 'method';
    file: string;
    line: number;
    endLine: number;
    signature: string;
    exported: boolean;
    parent?: string;
}
export interface IndexedFile {
    path: string;
    symbols: SymbolInfo[];
    imports: Array<{
        from: string;
        names: string[];
    }>;
    exports: string[];
    mtime: number;
}
import './parsers/typescript.ts';
import './parsers/php.ts';
import './parsers/python.ts';
import './parsers/go.ts';
import './parsers/rust.ts';
import './parsers/java.ts';
import './parsers/yaml.ts';
import './parsers/html.ts';
import './parsers/markdown.ts';
import './parsers/scss.ts';
import './parsers/css.ts';
import './parsers/json.ts';
import './parsers/toml.ts';
import './parsers/twig.ts';
import './parsers/generic-lang.ts';
export declare const indexStore: Map<string, IndexedFile>;
export declare function parseFile(filePath: string, content: string, mtime: number): Promise<IndexedFile>;
export interface TsExtractSymbolsInput {
    /** Absolute or relative path — used only as metadata in SymbolInfo.file */
    readonly path: string;
    /** Raw file content to parse */
    readonly content: string;
}
export interface TsExtractSymbolsOutput {
    readonly symbols: SymbolInfo[];
    readonly imports: Array<{
        from: string;
        names: string[];
    }>;
    readonly exports: string[];
}
/**
 * Parse a file and return structured symbol/import/export data.
 * This is an internal bus service used by code-intel bricks.
 * It does NOT index into the in-memory store — call tsIndex/tsReindex for that.
 */
export declare function tsExtractSymbols(input: TsExtractSymbolsInput): Promise<TsExtractSymbolsOutput>;
export interface TsSupportedExtsOutput {
    /** All file extensions registered in the tree-sitter language registry. */
    readonly exts: string[];
}
/**
 * Return all file extensions supported by the tree-sitter registry.
 * Target: treesitter:supported-exts
 */
export declare function tsSupportedExts(): TsSupportedExtsOutput;
export interface TsExtractImportsInput {
    readonly path: string;
    readonly content: string;
}
export interface ImportEntry {
    from: string;
    names: string[];
    kind?: string;
}
export interface TsExtractImportsOutput {
    readonly imports: ImportEntry[];
}
/**
 * Extract import statements from a file via tree-sitter.
 * Target: treesitter:extract-imports
 */
export declare function tsExtractImports(input: TsExtractImportsInput): Promise<TsExtractImportsOutput>;
export interface TsExtractRefsInput {
    readonly path: string;
    readonly content: string;
    readonly name: string;
}
export interface RefEntry {
    name: string;
    line: number;
    col: number;
    kind: string;
}
export interface TsExtractRefsOutput {
    readonly refs: RefEntry[];
}
/**
 * Find all usages of `name` in a file (identifier matches, excluding declarations).
 * Target: treesitter:extract-refs
 */
export declare function tsExtractRefs(input: TsExtractRefsInput): Promise<TsExtractRefsOutput>;
export interface TsExtractCallsInput {
    readonly path: string;
    readonly content: string;
}
export interface CallEntry {
    caller: string;
    callee: string;
    line: number;
}
export interface TsExtractCallsOutput {
    readonly calls: CallEntry[];
}
/**
 * Extract caller→callee relationships for callgraph analysis.
 * Target: treesitter:extract-calls
 */
export declare function tsExtractCalls(input: TsExtractCallsInput): Promise<TsExtractCallsOutput>;
export interface TsExtractOutlineInput {
    readonly path: string;
    readonly content: string;
}
export interface OutlineNode {
    name: string;
    kind: string;
    line: number;
    children?: OutlineNode[];
}
export interface TsExtractOutlineOutput {
    readonly outline: OutlineNode[];
}
/**
 * Build a hierarchical outline from the symbol tree.
 * Target: treesitter:extract-outline
 */
export declare function tsExtractOutline(input: TsExtractOutlineInput): Promise<TsExtractOutlineOutput>;
export interface TsIndexInput {
    readonly dir: string;
}
export interface TsReindexInput {
    readonly path: string;
}
export declare function tsIndex(input: TsIndexInput): Promise<{
    files: number;
    symbols: number;
}>;
export declare function tsReindex(input: TsReindexInput): Promise<{
    symbols: number;
}>;
export declare function tsStatus(): {
    files: number;
    symbols: number;
    langs: string[];
};
export declare function tsCleanup(): {
    removed: number;
};
export declare function tsLangs(): string[];
//# sourceMappingURL=operations.d.ts.map