/**
 * OpenRouter Rankings Intelligence System
 *
 * Comprehensive system for collecting, analyzing, and utilizing OpenRouter
 * programming model rankings to make intelligent model selection decisions.
 *
 * Features:
 * - Web scraping of OpenRouter programming rankings
 * - Model discovery with category filtering
 * - Real-time availability checking
 * - Cost optimization analysis
 * - Trend analysis and historical tracking
 * - Integration with existing sync system
 */
export interface ModelRanking {
    modelId: string;
    internalId: number;
    rankPosition: number;
    usagePercentage: number;
    relativeScore: number;
    provider: string;
    modelName: string;
    period: 'weekly' | 'monthly';
    dataQuality: 'scraped' | 'api' | 'estimated';
}
export interface RankingTrend {
    modelId: string;
    currentRank: number;
    previousRank: number;
    rankChange: number;
    trendDirection: 'rising' | 'falling' | 'stable';
    velocityScore: number;
}
export interface ModelCapabilities {
    modelId: string;
    capabilities: string[];
    inputModalities: string[];
    outputModalities: string[];
    contextWindow: number;
    pricingInput: number;
    pricingOutput: number;
    isActive: boolean;
}
export interface DiscoveryFilters {
    category?: 'programming' | 'reasoning' | 'creative' | 'multimodal';
    providers?: string[];
    maxCostPerToken?: number;
    minContextWindow?: number;
    capabilities?: string[];
    availability?: 'active' | 'any';
}
export interface RankingAnalysis {
    topModelsOverall: ModelRanking[];
    topModelsByProvider: Record<string, ModelRanking[]>;
    risingStars: ModelRanking[];
    costEfficient: ModelRanking[];
    trends: RankingTrend[];
    recommendations: {
        bestForSpeed: ModelRanking;
        bestForCost: ModelRanking;
        bestOverall: ModelRanking;
        emergingModels: ModelRanking[];
    };
}
export declare class OpenRouterRankings {
    private baseUrl;
    private rankingsUrl;
    private modelsApiUrl;
    /**
     * Main function to collect and store all ranking intelligence
     */
    collectRankingIntelligence(): Promise<{
        rankingsCollected: number;
        modelsDiscovered: number;
        trendsAnalyzed: number;
    }>;
    /**
     * Get OpenRouter programming rankings using the Models API
     */
    scrapeProgrammingRankings(period: 'week' | 'month'): Promise<ModelRanking[]>;
    /**
     * Parse model rankings from OpenRouter API data
     */
    private parseRankingsFromAPIData;
    /**
     * Parse model rankings from OpenRouter HTML (legacy fallback)
     */
    private parseRankingsFromHTML;
    /**
     * Alternative parsing method using different patterns
     */
    private parseRankingsAlternative;
    /**
     * Generate intelligent rankings based on API model data and heuristics
     * (Legacy method - now using parseRankingsFromAPIData as primary)
     */
    private generateIntelligentRankings;
    /**
     * Fallback rankings when scraping fails
     */
    private getFallbackRankings;
    /**
     * 🧹 Clean up pseudo-models from database rankings (self-healing)
     */
    private cleanupPseudoModelRankings;
    /**
     * Store rankings in database with internal ID resolution
     */
    storeRankings(rankings: ModelRanking[], period: 'weekly' | 'monthly'): Promise<number>;
    /**
     * Discover models via OpenRouter API
     */
    discoverModelsViaAPI(filters?: DiscoveryFilters): Promise<ModelCapabilities[]>;
    /**
     * Check if model matches discovery filters
     */
    private matchesFilters;
    /**
     * Fallback to get models from local database
     */
    private getModelsFromDatabase;
    /**
     * Analyze ranking trends
     */
    analyzeTrends(): Promise<RankingTrend[]>;
    /**
     * Get comprehensive ranking analysis
     */
    getRankingAnalysis(): Promise<RankingAnalysis>;
    /**
     * Update sync metadata
     */
    private updateSyncMetadata;
    /**
     * Check if rankings need refresh (older than 24 hours or no rankings exist)
     */
    needsRankingRefresh(): Promise<boolean>;
}
/**
 * Get top programming models from latest rankings
 */
export declare function getTopProgrammingModels(limit?: number): Promise<ModelRanking[]>;
/**
 * Find best models by criteria
 */
export declare function findBestModels(criteria: {
    forSpeed?: boolean;
    forCost?: boolean;
    forQuality?: boolean;
    provider?: string;
}): Promise<ModelRanking[]>;
/**
 * Sync rankings if needed (for integration with existing sync system)
 */
export declare function syncRankingsIfNeeded(): Promise<boolean>;
export default OpenRouterRankings;
//# sourceMappingURL=openrouter-rankings.d.ts.map