/**
 * SMI-1303: Tree-sitter Parser Manager
 *
 * Manages tree-sitter parser instances with lazy loading.
 * Uses web-tree-sitter (WASM) to avoid native module conflicts.
 *
 * @see docs/internal/architecture/multi-language-analysis.md
 * @see ADR-002: Docker glibc Requirement
 * @module analysis/tree-sitter/manager
 */
import type { SupportedLanguage } from '../types.js';
/**
 * Parser interface (matches web-tree-sitter API)
 */
export interface TreeSitterParser {
    parse(input: string, previousTree?: TreeSitterTree): TreeSitterTree;
    setLanguage(language: TreeSitterLanguage): void;
    delete(): void;
}
/**
 * Tree interface (matches web-tree-sitter API)
 */
export interface TreeSitterTree {
    rootNode: TreeSitterNode;
    delete(): void;
}
/**
 * Node interface (matches web-tree-sitter API)
 */
export interface TreeSitterNode {
    type: string;
    text: string;
    startPosition: {
        row: number;
        column: number;
    };
    endPosition: {
        row: number;
        column: number;
    };
    children: TreeSitterNode[];
    namedChildren: TreeSitterNode[];
    childCount: number;
    namedChildCount: number;
    child(index: number): TreeSitterNode | null;
    namedChild(index: number): TreeSitterNode | null;
    childForFieldName(fieldName: string): TreeSitterNode | null;
    descendantsOfType(types: string | string[]): TreeSitterNode[];
}
/**
 * Language module interface
 */
export interface TreeSitterLanguage {
}
/**
 * Options for TreeSitterManager
 */
export interface TreeSitterManagerOptions {
    /** Maximum parsers to cache (default: 6, one per language) */
    maxParsers?: number;
}
/**
 * Manages tree-sitter parser instances with lazy loading
 *
 * Parsers are loaded on-demand and cached for reuse.
 * Uses WASM-based web-tree-sitter to avoid native module issues.
 *
 * @example
 * ```typescript
 * const manager = new TreeSitterManager()
 * const parser = await manager.getParser('python')
 * const tree = parser.parse('def main(): pass')
 * manager.dispose()
 * ```
 */
export declare class TreeSitterManager {
    private parsers;
    private loading;
    private readonly maxParsers;
    private initialized;
    private initPromise;
    private ParserClass;
    private accessOrder;
    constructor(options?: TreeSitterManagerOptions);
    /**
     * SMI-1333: Update access order for LRU tracking
     * Moves the accessed language to the end (most recently used)
     */
    private updateAccessOrder;
    /**
     * Initialize web-tree-sitter (must be called before first use)
     *
     * This initializes the WASM runtime. Called automatically by getParser().
     */
    initialize(): Promise<void>;
    private doInitialize;
    /**
     * Get parser for a language, loading if necessary
     *
     * Parsers are cached for reuse. If the maximum number of
     * parsers is reached, the least recently used is evicted.
     *
     * @param language - Language to get parser for
     * @returns Configured parser instance
     * @throws Error if language is not supported or tree-sitter unavailable
     *
     * @example
     * ```typescript
     * const parser = await manager.getParser('python')
     * const tree = parser.parse(pythonCode)
     * ```
     */
    getParser(language: SupportedLanguage): Promise<TreeSitterParser>;
    /**
     * Load a parser for a specific language
     */
    private loadParser;
    /**
     * Load the language module for tree-sitter
     */
    private loadLanguageModule;
    /**
     * Check if a language is available
     *
     * @param language - Language to check
     * @returns True if the language can be loaded
     */
    isLanguageAvailable(language: SupportedLanguage): Promise<boolean>;
    /**
     * Get list of currently loaded languages
     */
    getLoadedLanguages(): SupportedLanguage[];
    /**
     * Clean up all parser resources
     *
     * Call this when the manager is no longer needed
     * to free memory and WASM resources.
     */
    dispose(): void;
}
//# sourceMappingURL=manager.d.ts.map