/**
 * Advanced Template Engine - Single Source of Truth System
 * Loads templates from files and provides intelligent variable substitution
 */
export interface TemplateMetadata {
    version: string;
    lastUpdated: string;
    rules: Record<string, RuleMetadata>;
    presets: Record<string, PresetMetadata>;
}
export interface RuleMetadata {
    id: string;
    title: string;
    description: string;
    category: string;
    priority: 'critical' | 'high' | 'medium' | 'low';
    applicability: {
        frameworks: string[];
        projectTypes: string[];
        required: boolean;
    };
    variables: Record<string, VariableDefinition>;
    dependencies?: string[];
    evolution?: {
        lastEvolved: string;
        confidence: number;
        evidenceCount: number;
    };
}
export interface VariableDefinition {
    description: string;
    type: 'string' | 'number' | 'boolean' | 'array';
    default?: any;
    required?: boolean;
    examples?: string[];
    validation?: {
        min?: number;
        max?: number;
        pattern?: string;
        enum?: string[];
    };
}
export interface PresetMetadata {
    name: string;
    description: string;
    rules: string[];
    variables?: Record<string, any>;
}
export interface TemplateContext {
    projectName: string;
    projectType: string;
    framework?: string;
    variables: Record<string, any>;
    globalVariables?: Record<string, any>;
}
export interface ProcessedTemplate {
    id: string;
    title: string;
    content: string;
    metadata: RuleMetadata;
    variablesUsed: string[];
    warnings: string[];
    tldr?: string[];
}
export interface OptimizationOptions {
    maxLength?: number;
    includeTldr?: boolean;
    consolidateSections?: boolean;
    includeClaudeOptimizations?: boolean;
    includeDynamicContext?: boolean;
}
export declare class AdvancedTemplateEngine {
    private templatesPath;
    private metadata;
    private templateCache;
    private defaultOptimizations;
    constructor(templatesPath?: string);
    /**
     * Initialize the template engine by loading metadata
     */
    initialize(): Promise<void>;
    /**
     * Get all available rule templates
     */
    getAvailableRules(): Promise<RuleMetadata[]>;
    /**
     * Get all available presets
     */
    getAvailablePresets(): Promise<PresetMetadata[]>;
    /**
     * Process a single rule template
     */
    processRule(ruleId: string, context: TemplateContext): Promise<ProcessedTemplate>;
    /**
     * Generate optimized CLAUDE.md with all enhancements
     */
    generateOptimizedClaudeMd(ruleIds: string[], context: TemplateContext, options?: OptimizationOptions): Promise<string>;
    private extractTldrFromContent;
    private generateTldr;
    private generateClaudeOptimizationSection;
    private generateDynamicContextSection;
    private consolidateRules;
    private extractKeyPoints;
    private summarizeRule;
    private optimizeLength;
    /**
     * Process multiple rules and generate complete CLAUDE.md (legacy method)
     */
    processRules(ruleIds: string[], context: TemplateContext): Promise<{
        content: string;
        processedRules: ProcessedTemplate[];
        warnings: string[];
        stats: {
            totalRules: number;
            applicableRules: number;
            criticalRules: number;
            warnings: number;
        };
    }>;
    /**
     * Process a preset configuration
     */
    processPreset(presetId: string, context: TemplateContext): Promise<{
        content: string;
        processedRules: ProcessedTemplate[];
        warnings: string[];
        preset: PresetMetadata;
    }>;
    /**
     * Validate template variables against metadata
     */
    validateVariables(ruleId: string, variables: Record<string, any>): Promise<{
        valid: boolean;
        errors: string[];
        warnings: string[];
        suggestions: Record<string, any>;
    }>;
    /**
     * Get variable suggestions for a rule
     */
    getVariableSuggestions(ruleId: string, projectType: string, framework?: string): Promise<Record<string, any>>;
    private loadMetadata;
    private loadTemplate;
    private isRuleApplicable;
    private processVariables;
    private validateVariableType;
    private validateVariableConstraints;
    private getProjectSpecificSuggestion;
    private inferVariableValue;
    private generateHeader;
    private generateEvolutionFooter;
}
export { AdvancedTemplateEngine as TemplateEngine };
export interface TemplateVariable {
    name: string;
    type: string;
    required: boolean;
    default?: any;
    description?: string;
}
export interface TemplateSection {
    name: string;
    content: string;
    variables: TemplateVariable[];
}
//# sourceMappingURL=template-engine.d.ts.map