/**
 * Expert Profile Templates System
 *
 * Sophisticated pre-built consensus profiles for different use cases,
 * with advanced configuration options and intelligent model selection.
 *
 * Features:
 * - 10+ expert-crafted templates
 * - Dynamic model selection based on current rankings
 * - Budget-aware configurations
 * - Performance optimization settings
 * - Scope-specific templates (minimal/basic/production)
 * - Advanced routing variant control
 */
export interface ExpertTemplate {
    id: string;
    name: string;
    description: string;
    category: 'speed' | 'quality' | 'cost' | 'specialized' | 'production';
    scope: 'minimal' | 'basic' | 'production';
    expertLevel: 'beginner' | 'intermediate' | 'advanced' | 'expert';
    selectionStrategy: 'fixed' | 'dynamic' | 'hybrid';
    fixedModels?: {
        generator: string | number;
        refiner: string | number;
        validator: string | number;
        curator: string | number;
    };
    selectionCriteria?: {
        generator: ModelCriteria;
        refiner: ModelCriteria;
        validator: ModelCriteria;
        curator: ModelCriteria;
    };
    temperatures: {
        generator: number;
        refiner: number;
        validator: number;
        curator: number;
    };
    routingPreferences?: {
        generator?: string;
        refiner?: string;
        validator?: string;
        curator?: string;
    };
    budgetProfile?: {
        priority: 'cost' | 'performance' | 'balanced';
        maxCostPerConversation?: number;
        preferredCostRange?: 'ultra-low' | 'low' | 'medium' | 'high' | 'premium';
    };
    performanceProfile?: {
        priority: 'speed' | 'quality' | 'balanced';
        maxLatencyMs?: number;
        qualityThreshold?: number;
    };
    useCases: string[];
    tags: string[];
}
interface ModelCriteria {
    providers?: string[];
    rankingPosition?: 'top-5' | 'top-10' | 'top-15' | 'top-20' | 'cost-efficient' | 'rising-stars';
    contextWindow?: 'small' | 'medium' | 'large' | 'xl';
    capabilities?: string[];
    costRange?: 'ultra-low' | 'low' | 'medium' | 'high' | 'premium';
    fallback?: string | number | SemanticModelDescriptor;
}
interface SemanticModelDescriptor {
    type: 'speed-optimized' | 'cost-efficient' | 'premium-quality' | 'balanced' | 'latest-from-provider';
    tier?: 'budget' | 'standard' | 'premium' | 'flagship';
    capabilities?: string[];
    providers?: string[];
    contextWindow?: 'small' | 'medium' | 'large' | 'xl';
    fallbackStrategy?: 'same-provider' | 'same-tier' | 'cross-provider';
}
export declare const EXPERT_TEMPLATES: ExpertTemplate[];
export declare class ExpertTemplateManager {
    private rankings;
    private selector;
    private maintenance;
    constructor();
    /**
     * Get all available templates, optionally filtered
     */
    getTemplates(filter?: {
        category?: string;
        scope?: string;
        expertLevel?: string;
        useCases?: string[];
        tags?: string[];
    }): ExpertTemplate[];
    /**
     * Find the best template for a specific question or use case
     */
    findBestTemplate(question: string, preferences?: {
        budget?: 'low' | 'medium' | 'high';
        speed?: 'fast' | 'balanced' | 'quality';
        expertLevel?: 'beginner' | 'intermediate' | 'advanced' | 'expert';
    }): Promise<ExpertTemplate[]>;
    /**
     * Create a profile from an expert template
     */
    createProfileFromTemplate(templateId: string, profileName?: string, userId?: string): Promise<any>;
    /**
     * Select models based on criteria - ONLY returns internal IDs from unified database
     */
    private selectModelsFromCriteria;
    /**
     * Find fallback model from database for a specific stage
     */
    private findFallbackModelFromDatabase;
    /**
     * Resolve semantic model descriptor to internal ID using existing AI evolution architecture
     */
    private resolveSemanticModel;
    /**
     * Resolve any model reference (string, number, or semantic descriptor) to internal ID
     */
    private resolveModelToInternalId;
    /**
     * Get internal ID for a model by OpenRouter ID, with automatic fallback resolution
     */
    private getModelInternalId;
    /**
     * Get template recommendations for a user
     */
    getRecommendations(userLevel?: 'beginner' | 'intermediate' | 'advanced' | 'expert'): ExpertTemplate[];
}
export declare function createExpertProfile(templateId: string, profileName?: string, userId?: string): Promise<any>;
export declare function getAvailableTemplates(): ExpertTemplate[];
export declare function findTemplateForQuestion(question: string, preferences?: any): Promise<ExpertTemplate[]>;
export declare function getTemplateRecommendations(userLevel?: 'beginner' | 'intermediate' | 'advanced' | 'expert'): ExpertTemplate[];
export default ExpertTemplateManager;
//# sourceMappingURL=expert-profile-templates.d.ts.map