import type { QueryService } from '../domain/query/queryService.js';
/**
 * Documentation format types
 */
export type DocFormat = 'jsdoc' | 'tsdoc' | 'python-docstring' | 'markdown';
/**
 * Documentation completeness status
 */
export type DocStatus = 'complete' | 'partial' | 'missing';
/**
 * Generated documentation for a symbol
 */
export interface GeneratedDoc {
    symbolName: string;
    filePath: string;
    format: DocFormat;
    status: DocStatus;
    existingDoc?: string;
    generatedDoc: string;
    confidence: number;
    reasoning: string;
    sections: {
        summary?: string;
        description?: string;
        parameters?: Array<{
            name: string;
            type?: string;
            description: string;
        }>;
        returns?: {
            type?: string;
            description: string;
        };
        throws?: Array<{
            type: string;
            description: string;
        }>;
        examples?: string[];
        seeAlso?: string[];
    };
}
/**
 * Documentation analysis result
 */
export interface DocAnalysisResult {
    projectPath: string;
    targetSymbols: string[];
    analysis: Array<{
        symbolName: string;
        filePath: string;
        status: DocStatus;
        issues: string[];
        suggestions: string[];
    }>;
    summary: {
        total: number;
        complete: number;
        partial: number;
        missing: number;
        completeness: number;
    };
    stats: {
        analysisTimeMs: number;
    };
}
/**
 * Documentation generation result
 */
export interface GenerateDocsResult {
    projectPath: string;
    generated: GeneratedDoc[];
    summary: {
        total: number;
        successful: number;
        failed: number;
        avgConfidence: number;
    };
    stats: {
        generationTimeMs: number;
    };
}
/**
 * Documentation generator service dependencies
 */
export interface DocumentationGeneratorDeps {
    queryService: QueryService;
}
/**
 * Documentation generator service
 *
 * Analyzes code and generates missing documentation with contextual information
 */
export declare class DocumentationGenerator {
    private deps;
    constructor(deps: DocumentationGeneratorDeps);
    /**
     * Analyze documentation completeness
     */
    analyzeDocumentation(params: {
        projectPath: string;
        symbols: string[];
    }): Promise<DocAnalysisResult>;
    /**
     * Generate documentation for symbols
     */
    generateDocumentation(params: {
        projectPath: string;
        symbols: string[];
        format?: DocFormat;
        includeExamples?: boolean;
    }): Promise<GenerateDocsResult>;
    /**
     * Generate documentation for a single symbol
     */
    private generateDocForSymbol;
    /**
     * Convert CodeEntityInfo to DefinitionResult
     */
    private toDefinitionResult;
    /**
     * Extract existing documentation from definition
     */
    private extractExistingDoc;
    /**
     * Assess documentation status
     */
    private assessDocStatus;
    /**
     * Identify documentation issues
     */
    private identifyDocIssues;
    /**
     * Generate improvement suggestions
     */
    private generateSuggestions;
    /**
     * Compute summary statistics
     */
    private computeSummary;
    /**
     * Parse function signature
     */
    private parseSignature;
    /**
     * Gather contextual information
     */
    private gatherContext;
    /**
     * Generate documentation sections
     */
    private generateSections;
    /**
     * Generate summary line
     */
    private generateSummary;
    /**
     * Generate detailed description
     */
    private generateDescription;
    /**
     * Generate parameter description
     */
    private generateParamDescription;
    /**
     * Generate return value description
     */
    private generateReturnDescription;
    /**
     * Generate usage examples
     */
    private generateExamples;
    /**
     * Generate example function call
     */
    private generateExampleCall;
    /**
     * Format documentation in specified format
     */
    private formatDocumentation;
    /**
     * Format as JSDoc/TSDoc
     */
    private formatJSDoc;
    /**
     * Format as Python docstring
     */
    private formatPythonDocstring;
    /**
     * Format as Markdown
     */
    private formatMarkdown;
    /**
     * Calculate confidence score
     */
    private calculateConfidence;
    /**
     * Explain generation reasoning
     */
    private explainGeneration;
    /**
     * Humanize camelCase or snake_case name
     */
    private humanizeName;
}