/**
 * Cost Intelligence Engine
 *
 * Advanced cost optimization and budget management system that makes
 * consensus pipelines cost-aware and budget-friendly without sacrificing quality.
 *
 * Features:
 * - Real-time cost estimation and tracking
 * - Budget-aware model selection
 * - Cost optimization strategies
 * - ROI analysis for consensus vs single models
 * - Dynamic routing to cost-effective variants
 * - Smart budget allocation across stages
 */
import type { ModelCandidate } from './dynamic-model-selector.js';
export interface CostEstimate {
    estimatedCost: number;
    confidence: number;
    breakdown: {
        inputTokens: number;
        outputTokens: number;
        inputCost: number;
        outputCost: number;
    };
    routingOptimizations?: CostOptimization[];
}
export interface CostOptimization {
    strategy: string;
    potentialSavings: number;
    qualityImpact: number;
    description: string;
    routingVariant?: string;
}
export interface BudgetAllocation {
    totalBudget: number;
    stageAllocations: {
        generator: number;
        refiner: number;
        validator: number;
        curator: number;
    };
    reserveFund: number;
    allocationStrategy: string;
}
export interface CostEfficiencyMetrics {
    costPerToken: number;
    qualityPerDollar: number;
    timeToValue: number;
    totalValueScore: number;
}
export declare class CostIntelligence {
    /**
     * Estimate cost for a complete consensus pipeline
     */
    estimateConsensusCost(question: string, modelLineup: {
        generator: ModelCandidate;
        refiner: ModelCandidate;
        validator: ModelCandidate;
        curator: ModelCandidate;
    }, options?: {
        routingOptimizations?: boolean;
        includeFallbackBuffer?: boolean;
    }): Promise<CostEstimate>;
    /**
     * Create optimal budget allocation for a given total budget
     */
    createBudgetAllocation(totalBudget: number, questionComplexity: 'minimal' | 'basic' | 'production', strategy?: 'balanced' | 'front_loaded' | 'quality_focused' | 'cost_optimized'): Promise<BudgetAllocation>;
    /**
     * Find cost optimization opportunities for a model/stage
     */
    private findCostOptimizations;
    /**
     * Find cost-effective alternative model for a stage
     */
    private findCostEffectiveAlternative;
    /**
     * Calculate efficiency metrics for consensus vs single model
     */
    calculateEfficiencyMetrics(consensusCost: number, consensusQuality: number, singleModelCost: number, singleModelQuality: number, consensusTime: number, singleModelTime: number): Promise<CostEfficiencyMetrics>;
    /**
     * Estimate token usage based on question analysis
     */
    private estimateTokenUsage;
    /**
     * Get token multipliers for different stages
     */
    private getStageTokenMultiplier;
    /**
     * Calculate cost for a specific model and token usage
     */
    private calculateModelCost;
    /**
     * Record cost analytics for learning and optimization
     */
    recordCostAnalytics(conversationId: string, costBreakdown: any, optimizationsApplied: CostOptimization[], actualCost: number): Promise<void>;
    /**
     * Update cost analytics with actual costs after consensus completion
     */
    updateActualCosts(conversationId: string, actualCostData: {
        totalCost: number;
        stageBreakdown: {
            generator: number;
            refiner: number;
            validator: number;
            curator: number;
        };
        tokenBreakdown: {
            generator: {
                input: number;
                output: number;
            };
            refiner: {
                input: number;
                output: number;
            };
            validator: {
                input: number;
                output: number;
            };
            curator: {
                input: number;
                output: number;
            };
        };
        qualityScore?: number;
    }): Promise<void>;
    /**
     * Calculate cost efficiency score (0-1)
     */
    private calculateCostEfficiencyScore;
}
/**
 * Quick cost estimate for a question
 */
export declare function estimateQuestionCost(question: string, complexity?: 'minimal' | 'basic' | 'production'): Promise<number>;
/**
 * Get budget recommendation for a question type
 */
export declare function getBudgetRecommendation(questionComplexity: 'minimal' | 'basic' | 'production', qualityLevel?: 'standard' | 'high' | 'premium'): Promise<number>;
export default CostIntelligence;