@gotza02/sequential-thinking 10000.1.2 → 10000.1.4

package/dist/tools/sports/tools/match.js

@@ -9,6 +9,7 @@ import { scrapeMatchContent, findBestMatchUrl, findBestNewsUrl } from '../provid
 import { getGlobalCache, CacheService } from '../core/cache.js';
 import { formatMatchesTable, formatScore, formatMatchStatus } from '../utils/formatter.js';
 import { CACHE_CONFIG, LEAGUES } from '../core/constants.js';
+import { logger } from '../../../utils.js';
 // ============= Helper Functions =============
 /**
  * Get date context for search queries
@@ -62,6 +63,200 @@ async function findMatchId(homeTeam, awayTeam, league) {
     }
     return null;
 }
+/**
+ * Fetch comprehensive API data for a match
+ */
+async function fetchAPIMatchData(api, matchId, homeTeam, awayTeam) {
+    try {
+        // Fetch all data in parallel
+        const [matchResult, h2hResult, oddsResult] = await Promise.all([
+            api.getMatch(matchId),
+            api.getH2H(matchId),
+            api.getMatchOdds(matchId),
+        ]);
+        let homeForm;
+        let awayForm;
+        // Get team form if we have match data
+        if (matchResult.success && matchResult.data) {
+            const [homeFormResult, awayFormResult] = await Promise.all([
+                api.getTeamForm(matchResult.data.homeTeam.id, 5),
+                api.getTeamForm(matchResult.data.awayTeam.id, 5),
+            ]);
+            if (homeFormResult.success && homeFormResult.data) {
+                homeForm = homeFormResult.data;
+            }
+            if (awayFormResult.success && awayFormResult.data) {
+                awayForm = awayFormResult.data;
+            }
+        }
+        return {
+            match: matchResult.success ? matchResult.data : undefined,
+            h2h: h2hResult.success ? h2hResult.data : undefined,
+            homeForm,
+            awayForm,
+            odds: oddsResult.success ? oddsResult.data : undefined,
+            lastUpdated: new Date(),
+        };
+    }
+    catch (error) {
+        logger.error(`Error fetching API match data: ${error}`);
+        return null;
+    }
+}
+/**
+ * Assess what data coverage we have from API
+ */
+function assessDataCoverage(apiData) {
+    if (!apiData) {
+        return {
+            score: 0,
+            factors: {
+                hasAPIData: false,
+                hasRecentData: false,
+                sampleSize: 'small',
+                dataAge: 999,
+                missingDataPoints: ['all'],
+            },
+        };
+    }
+    let score = 0;
+    const missingDataPoints = [];
+    // Base match data
+    if (apiData.match) {
+        score += 40;
+    }
+    else {
+        missingDataPoints.push('match');
+    }
+    // H2H data
+    if (apiData.h2h && apiData.h2h.totalMatches > 0) {
+        score += 20;
+    }
+    else {
+        missingDataPoints.push('h2h');
+    }
+    // Form data
+    if (apiData.homeForm && apiData.homeForm.length >= 3) {
+        score += 15;
+    }
+    else {
+        missingDataPoints.push('homeForm');
+    }
+    if (apiData.awayForm && apiData.awayForm.length >= 3) {
+        score += 15;
+    }
+    else {
+        missingDataPoints.push('awayForm');
+    }
+    // Odds data
+    if (apiData.odds) {
+        score += 10;
+    }
+    else {
+        missingDataPoints.push('odds');
+    }
+    // Calculate data age
+    const dataAge = apiData.lastUpdated
+        ? (Date.now() - apiData.lastUpdated.getTime()) / (1000 * 60 * 60)
+        : 999;
+    // Determine sample size
+    let sampleSize = 'small';
+    const totalMatches = (apiData.homeForm?.length || 0) + (apiData.awayForm?.length || 0);
+    if (totalMatches >= 10)
+        sampleSize = 'large';
+    else if (totalMatches >= 5)
+        sampleSize = 'medium';
+    return {
+        score: Math.min(100, score),
+        factors: {
+            hasAPIData: score > 0,
+            hasRecentData: dataAge < 24,
+            sampleSize,
+            dataAge,
+            missingDataPoints,
+        },
+    };
+}
+/**
+ * Optimize search queries based on API data coverage
+ */
+function optimizeQueries(coverage, baseQueries) {
+    // Always search for these (API doesn't cover well)
+    const alwaysSearch = ['fatigue', 'setpieces', 'referee', 'weather'];
+    return baseQueries.filter(q => {
+        // Always include critical queries
+        if (alwaysSearch.includes(q.type))
+            return true;
+        // Skip queries that API already covers well
+        switch (q.type) {
+            case 'h2h':
+                // Skip H2H search if we have good H2H data
+                return !coverage.factors.hasAPIData || coverage.factors.missingDataPoints.includes('h2h');
+            case 'form':
+                // Skip form search if we have form data
+                return !coverage.factors.hasAPIData ||
+                    (coverage.factors.missingDataPoints.includes('homeForm') ||
+                        coverage.factors.missingDataPoints.includes('awayForm'));
+            case 'stats':
+                // Stats need web search for xG
+                return true;
+            case 'news':
+                // Always search for news/lineups
+                return true;
+            case 'odds':
+                // Skip odds search if we have API odds
+                return !coverage.factors.hasAPIData || coverage.factors.missingDataPoints.includes('odds');
+            default:
+                return true;
+        }
+    });
+}
+/**
+ * Calculate adaptive TTL based on data type and match timing
+ */
+function calculateAdaptiveTTL(dataType, matchDate) {
+    const now = Date.now();
+    const hoursUntilMatch = matchDate
+        ? (matchDate.getTime() - now) / (1000 * 60 * 60)
+        : Infinity;
+    switch (dataType) {
+        case 'odds':
+            // Odds change frequently - short TTL
+            if (hoursUntilMatch < 1)
+                return 60 * 1000; // 1 minute
+            if (hoursUntilMatch < 24)
+                return 5 * 60 * 1000; // 5 minutes
+            return 15 * 60 * 1000; // 15 minutes
+        case 'lineups':
+            // Lineups announced ~1 hour before match
+            if (hoursUntilMatch < 2)
+                return 5 * 60 * 1000; // 5 minutes
+            return 60 * 60 * 1000; // 1 hour
+        case 'news':
+            // News changes throughout the day
+            if (hoursUntilMatch < 24)
+                return 15 * 60 * 1000; // 15 minutes
+            return 60 * 60 * 1000; // 1 hour
+        case 'stats':
+        case 'h2h':
+            // Historical stats don't change
+            return 24 * 60 * 60 * 1000; // 24 hours
+        case 'form':
+            // Form updates after each match
+            if (hoursUntilMatch < 0)
+                return 60 * 1000; // Live match - 1 minute
+            return 6 * 60 * 60 * 1000; // 6 hours
+        case 'match':
+            // Match data changes based on timing
+            if (hoursUntilMatch < 0)
+                return 60 * 1000; // Live - 1 minute
+            if (hoursUntilMatch < 1)
+                return 5 * 60 * 1000; // 5 minutes
+            return 30 * 60 * 1000; // 30 minutes
+        default:
+            return 30 * 60 * 1000; // 30 minutes default
+    }
+}
 /**
  * Perform comprehensive match analysis using web search
  */
@@ -83,15 +278,73 @@ export async function performMatchAnalysis(homeTeam, awayTeam, league, context)
     if (context) {
         queries.push({ type: 'general', query: `${baseQuery} ${context}${dateQuery}`, title: 'Specific Context' });
     }
-    // Optimization: Skip some web searches if we have a matchId (API should cover these)
+    // Try to get API data first
+    const api = createAPIProvider();
     const matchId = await findMatchId(homeTeam, awayTeam, league);
-    const queriesToExecute = matchId
-        ? queries.filter(q => !['news', 'stats'].includes(q.type)) // API covers lineups and basic stats
-        : queries;
+    let apiData = null;
+    if (matchId) {
+        apiData = await fetchAPIMatchData(api, matchId, homeTeam, awayTeam);
+    }
+    // Assess data coverage and optimize queries
+    const coverage = assessDataCoverage(apiData);
+    const queriesToExecute = optimizeQueries(coverage, queries);
     let combinedResults = `--- FOOTBALL MATCH DATA: ${homeTeam} vs ${awayTeam} ---\n`;
     if (matchId)
         combinedResults += `Resolved API Match ID: ${matchId}\n`;
+    combinedResults += `Data Quality Score: ${coverage.score}/100\n`;
     combinedResults += `Match Context Date: ${new Date().toLocaleDateString()}\n\n`;
+    // Add API Data section if available
+    if (apiData && coverage.score > 0) {
+        combinedResults += `--- API DATA (Reliable Source) ---\n\n`;
+        if (apiData.h2h) {
+            combinedResults += `### Head-to-Head Record\n`;
+            combinedResults += `- Total Matches: ${apiData.h2h.totalMatches}\n`;
+            combinedResults += `- ${homeTeam} Wins: ${apiData.h2h.homeWins}\n`;
+            combinedResults += `- Draws: ${apiData.h2h.draws}\n`;
+            combinedResults += `- ${awayTeam} Wins: ${apiData.h2h.awayWins}\n`;
+            combinedResults += `- Goals: ${apiData.h2h.homeGoals}-${apiData.h2h.awayGoals}\n\n`;
+        }
+        if (apiData.homeForm?.length) {
+            combinedResults += `### ${homeTeam} Recent Form (Last ${apiData.homeForm.length})\n`;
+            combinedResults += apiData.homeForm.map(m => {
+                const isHome = m.homeTeam.name.includes(homeTeam);
+                const score = m.score ? `${m.score.home}-${m.score.away}` : '?';
+                const opponent = isHome ? m.awayTeam.name : m.homeTeam.name;
+                const result = isHome
+                    ? (m.score?.home ?? 0) > (m.score?.away ?? 0) ? 'W' : (m.score?.home === m.score?.away ? 'D' : 'L')
+                    : (m.score?.away ?? 0) > (m.score?.home ?? 0) ? 'W' : (m.score?.home === m.score?.away ? 'D' : 'L');
+                return `- ${result} vs ${opponent} (${score})`;
+            }).join('\n');
+            combinedResults += '\n\n';
+        }
+        if (apiData.awayForm?.length) {
+            combinedResults += `### ${awayTeam} Recent Form (Last ${apiData.awayForm.length})\n`;
+            combinedResults += apiData.awayForm.map(m => {
+                const isAway = m.awayTeam.name.includes(awayTeam);
+                const score = m.score ? `${m.score.home}-${m.score.away}` : '?';
+                const opponent = isAway ? m.homeTeam.name : m.awayTeam.name;
+                const result = isAway
+                    ? (m.score?.away ?? 0) > (m.score?.home ?? 0) ? 'W' : (m.score?.home === m.score?.away ? 'D' : 'L')
+                    : (m.score?.home ?? 0) > (m.score?.away ?? 0) ? 'W' : (m.score?.home === m.score?.away ? 'D' : 'L');
+                return `- ${result} vs ${opponent} (${score})`;
+            }).join('\n');
+            combinedResults += '\n\n';
+        }
+        if (apiData.odds) {
+            combinedResults += `### Current Odds (from API)\n`;
+            combinedResults += `- Home Win: ${apiData.odds.homeWin.toFixed(2)}\n`;
+            combinedResults += `- Draw: ${apiData.odds.draw.toFixed(2)}\n`;
+            combinedResults += `- Away Win: ${apiData.odds.awayWin.toFixed(2)}\n`;
+            if (apiData.odds.asianHandicap) {
+                combinedResults += `- Asian Handicap: ${apiData.odds.asianHandicap.line}\n`;
+            }
+            combinedResults += '\n';
+        }
+        combinedResults += `--- END API DATA ---\n\n`;
+    }
+    if (coverage.factors.missingDataPoints.length > 0) {
+        combinedResults += `*Note: Using web search to supplement: ${coverage.factors.missingDataPoints.join(', ')}*\n\n`;
+    }
     const candidateUrls = [];
     // Execute searches in parallel (in batches)
     const BATCH_SIZE = 4;
@@ -164,6 +417,225 @@ export async function performMatchAnalysis(homeTeam, awayTeam, league, context)
     combinedResults += `🏆 FINAL VERDICT:\n   - Asian Handicap Leans\n   - Goal Line (Over/Under)\n   - The "Value Pick"`;
     return combinedResults;
 }
+/**
+ * Calculate probability range with uncertainty quantification
+ */
+function calculateProbabilityRange(baseProbability, dataQuality) {
+    // Higher data quality = narrower range
+    const qualityFactor = dataQuality.score / 100;
+    const baseUncertainty = 0.15; // 15% base uncertainty
+    // Adjust uncertainty based on data quality
+    const adjustedUncertainty = baseUncertainty * (1 - qualityFactor * 0.7);
+    // Calculate range
+    const mid = baseProbability;
+    const margin = adjustedUncertainty * Math.sqrt(baseProbability * (1 - baseProbability));
+    return {
+        low: Math.max(0, mid - margin * 1.645), // 5th percentile
+        mid,
+        high: Math.min(1, mid + margin * 1.645), // 95th percentile
+    };
+}
+/**
+ * Detect value bets from predictions and odds
+ */
+async function detectValueBets(apiData, homeTeam, awayTeam) {
+    const valueBets = [];
+    if (!apiData?.odds)
+        return valueBets;
+    // Estimate probabilities from API data
+    // Simple model: use form and H2H to estimate
+    let homeWinProb = 0.33;
+    let drawProb = 0.33;
+    let awayWinProb = 0.33;
+    if (apiData.homeForm && apiData.awayForm) {
+        const homeWins = apiData.homeForm.filter(m => {
+            const isHome = m.homeTeam.name.includes(homeTeam);
+            return isHome ? (m.score?.home ?? 0) > (m.score?.away ?? 0) : (m.score?.away ?? 0) > (m.score?.home ?? 0);
+        }).length;
+        const awayWins = apiData.awayForm.filter(m => {
+            const isAway = m.awayTeam.name.includes(awayTeam);
+            return isAway ? (m.score?.away ?? 0) > (m.score?.home ?? 0) : (m.score?.home ?? 0) > (m.score?.away ?? 0);
+        }).length;
+        // Normalize to probabilities
+        const total = homeWins + awayWins + 2; // +2 for draws
+        homeWinProb = (homeWins + 1) / total;
+        awayWinProb = (awayWins + 1) / total;
+        drawProb = 1 - homeWinProb - awayWinProb;
+    }
+    // Calculate value for each market
+    const markets = [
+        { selection: `${homeTeam} Win`, prob: homeWinProb, odds: apiData.odds.homeWin },
+        { selection: 'Draw', prob: drawProb, odds: apiData.odds.draw },
+        { selection: `${awayTeam} Win`, prob: awayWinProb, odds: apiData.odds.awayWin },
+    ];
+    for (const market of markets) {
+        if (!market.odds || market.prob <= 0)
+            continue;
+        const fairOdds = 1 / market.prob;
+        const value = (market.odds / fairOdds) - 1;
+        // Only include if value > 5%
+        if (value >= 0.05) {
+            const kelly = (market.prob * market.odds - 1) / (market.odds - 1);
+            valueBets.push({
+                selection: market.selection,
+                market: '1x2',
+                odds: market.odds,
+                fairOdds,
+                value,
+                confidence: Math.min(90, 50 + value * 200), // Scale value to confidence
+                kellyFraction: Math.max(0, kelly / 2), // Half Kelly
+                recommendedStake: Math.max(0, kelly / 2) * 100, // Based on 100 unit bankroll
+                reasoning: `Estimated probability ${(market.prob * 100).toFixed(1)}% vs implied ${((1 / market.odds) * 100).toFixed(1)}%`,
+            });
+        }
+    }
+    return valueBets.sort((a, b) => b.value - a.value);
+}
+/**
+ * Build structured analysis result from API and web data
+ */
+async function buildStructuredAnalysis(homeTeam, awayTeam, league, apiData, coverage) {
+    // Calculate base probabilities
+    let homeWinProb = 0.35;
+    let drawProb = 0.30;
+    let awayWinProb = 0.35;
+    // Adjust based on form if available
+    if (apiData?.homeForm && apiData?.awayForm) {
+        const homePoints = apiData.homeForm.reduce((sum, m) => {
+            const isHome = m.homeTeam.name.includes(homeTeam);
+            const score = m.score;
+            if (!score)
+                return sum;
+            if (isHome) {
+                return sum + (score.home > score.away ? 3 : score.home === score.away ? 1 : 0);
+            }
+            else {
+                return sum + (score.away > score.home ? 3 : score.away === score.home ? 1 : 0);
+            }
+        }, 0);
+        const awayPoints = apiData.awayForm.reduce((sum, m) => {
+            const isAway = m.awayTeam.name.includes(awayTeam);
+            const score = m.score;
+            if (!score)
+                return sum;
+            if (isAway) {
+                return sum + (score.away > score.home ? 3 : score.away === score.home ? 1 : 0);
+            }
+            else {
+                return sum + (score.home > score.away ? 3 : score.home === score.away ? 1 : 0);
+            }
+        }, 0);
+        const totalPoints = homePoints + awayPoints + 5; // +5 for draw possibility
+        homeWinProb = (homePoints + 1.5) / totalPoints;
+        awayWinProb = (awayPoints + 1.5) / totalPoints;
+        drawProb = 1 - homeWinProb - awayWinProb;
+    }
+    // Calculate probability ranges
+    const predictions = {
+        matchResult: {
+            homeWin: calculateProbabilityRange(homeWinProb, coverage),
+            draw: calculateProbabilityRange(drawProb, coverage),
+            awayWin: calculateProbabilityRange(awayWinProb, coverage),
+        },
+        overUnder25: {
+            over: calculateProbabilityRange(0.50, coverage), // Placeholder
+            under: calculateProbabilityRange(0.50, coverage),
+        },
+        btts: {
+            yes: calculateProbabilityRange(0.50, coverage), // Placeholder
+            no: calculateProbabilityRange(0.50, coverage),
+        },
+    };
+    // Detect value bets
+    const valueBets = await detectValueBets(apiData, homeTeam, awayTeam);
+    // Build six-persona analysis
+    const analysis = {
+        dataScientist: {
+            homeWinProbability: predictions.matchResult.homeWin,
+            drawProbability: predictions.matchResult.draw,
+            awayWinProbability: predictions.matchResult.awayWin,
+            expectedGoals: { home: 1.3, away: 1.2 }, // Placeholder - would need xG data
+            keyStats: [],
+        },
+        tacticalScout: {
+            styleMatchup: 'Analysis requires detailed tactical data',
+            keyBattles: [],
+            tacticalAdvantage: 'neutral',
+        },
+        physio: {
+            homeFatigue: {
+                score: 50,
+                daysRest: 3,
+                squadDepth: 5,
+                keyInjuries: [],
+            },
+            awayFatigue: {
+                score: 50,
+                daysRest: 3,
+                squadDepth: 5,
+                keyInjuries: [],
+            },
+            injuryImpact: 'Analysis requires injury data',
+        },
+        setPieceAnalyst: {
+            homeStrength: 5,
+            awayStrength: 5,
+            predictedCorners: 10,
+            aerialAdvantage: 'neutral',
+        },
+        insider: {
+            marketMovement: apiData?.odds ? `Home: ${apiData.odds.homeWin.toFixed(2)}, Draw: ${apiData.odds.draw.toFixed(2)}, Away: ${apiData.odds.awayWin.toFixed(2)}` : 'No odds data',
+        },
+        skeptic: {
+            upsetRisk: 0.25,
+            trapIndicators: [],
+            gameScenarios: [],
+        },
+    };
+    // Determine best bet
+    const bestBet = valueBets.length > 0
+        ? valueBets[0].selection
+        : `${homeTeam} Win or Draw (Double Chance)`;
+    return {
+        match: {
+            homeTeam,
+            awayTeam,
+            league,
+            matchId: apiData?.match?.id,
+        },
+        dataQuality: coverage,
+        analysis,
+        predictions,
+        valueBets,
+        verdict: {
+            summary: `Analysis based on ${coverage.score}/100 data quality. ${apiData?.h2h ? `H2H: ${apiData.h2h.homeWins}-${apiData.h2h.draws}-${apiData.h2h.awayWins}` : 'No H2H data'}`,
+            bestBet,
+            confidence: coverage.score,
+            riskLevel: coverage.score >= 70 ? 'low' : coverage.score >= 40 ? 'medium' : 'high',
+        },
+        metadata: {
+            generatedAt: new Date(),
+            dataSources: apiData ? ['api-football'] : ['web-search'],
+        },
+    };
+}
+/**
+ * Perform structured match analysis with JSON output
+ */
+export async function performStructuredMatchAnalysis(homeTeam, awayTeam, league, context) {
+    // Fetch API data
+    const api = createAPIProvider();
+    const matchId = await findMatchId(homeTeam, awayTeam, league);
+    let apiData = null;
+    if (matchId) {
+        apiData = await fetchAPIMatchData(api, matchId, homeTeam, awayTeam);
+    }
+    // Assess data coverage
+    const coverage = assessDataCoverage(apiData);
+    // Build structured analysis
+    const result = await buildStructuredAnalysis(homeTeam, awayTeam, league, apiData, coverage);
+    return result;
+}
 // ============= Tool Registration =============
 export function registerMatchTools(server) {
     /**
@@ -211,7 +683,60 @@ Market Intelligence, Referee stats, Weather, Fatigue analysis, Set Pieces.`, {
         };
     });
     /**
-     * Tool 2: get_live_scores
+     * Tool 2: analyze_football_match_structured
+     * Structured JSON output for programmatic use
+     */
+    server.tool('analyze_football_match_structured', `Comprehensive football match analysis with structured JSON output.
+Returns: Probabilities with confidence ranges, 6-persona analysis, value bets, data quality score.
+Use this for programmatic access to match analysis.`, {
+        homeTeam: z.string().describe('Name of the home team'),
+        awayTeam: z.string().describe('Name of the away team'),
+        league: z.string().optional().describe('League name (optional, helps with accuracy)'),
+        includeOdds: z.boolean().optional().default(true).describe('Include current odds in analysis'),
+    }, async ({ homeTeam, awayTeam, league, includeOdds }) => {
+        try {
+            const result = await performStructuredMatchAnalysis(homeTeam, awayTeam, league);
+            // Format as readable JSON with summary
+            const output = {
+                summary: `${homeTeam} vs ${awayTeam}`,
+                dataQuality: `${result.dataQuality.score}/100`,
+                predictions: {
+                    homeWin: `${(result.predictions.matchResult.homeWin.mid * 100).toFixed(1)}% (${(result.predictions.matchResult.homeWin.low * 100).toFixed(1)}%-${(result.predictions.matchResult.homeWin.high * 100).toFixed(1)}%)`,
+                    draw: `${(result.predictions.matchResult.draw.mid * 100).toFixed(1)}% (${(result.predictions.matchResult.draw.low * 100).toFixed(1)}%-${(result.predictions.matchResult.draw.high * 100).toFixed(1)}%)`,
+                    awayWin: `${(result.predictions.matchResult.awayWin.mid * 100).toFixed(1)}% (${(result.predictions.matchResult.awayWin.low * 100).toFixed(1)}%-${(result.predictions.matchResult.awayWin.high * 100).toFixed(1)}%)`,
+                },
+                valueBets: result.valueBets.length > 0
+                    ? result.valueBets.map(vb => ({
+                        selection: vb.selection,
+                        odds: vb.odds.toFixed(2),
+                        value: `${(vb.value * 100).toFixed(1)}%`,
+                        stake: `${vb.recommendedStake.toFixed(1)}u`
+                    }))
+                    : 'No value bets detected',
+                bestBet: result.verdict.bestBet,
+                confidence: `${result.verdict.confidence}/100`,
+                riskLevel: result.verdict.riskLevel,
+                fullAnalysis: result,
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(output, null, 2)
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true,
+            };
+        }
+    });
+    /**
+     * Tool 3: get_live_scores
      * Get live football scores for a league or team
      */
     server.tool('get_live_scores', `Get live football scores.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "10000.1.2",
+  "version": "10000.1.4",
   "publishConfig": {
     "access": "public"
   },

package/dist/tools/sports/core/alert-manager.d.ts

@@ -1,96 +0,0 @@
-/**
- * ALERT MANAGER
- * Real-time alert system with rule engine
- */
-import { EventEmitter } from 'events';
-import type { LiveEvent } from './realtime-manager.js';
-export interface AlertRule {
-    id: string;
-    name: string;
-    type: AlertType;
-    condition: AlertCondition;
-    channels: NotificationChannel[];
-    cooldown: number;
-    enabled: boolean;
-    createdAt: number;
-    lastTriggered?: number;
-    triggerCount?: number;
-}
-export type AlertType = 'odds_drop' | 'odds_value' | 'goal' | 'red_card' | 'lineup_change' | 'match_start' | 'match_end' | 'custom';
-export type AlertCondition = OddsDropCondition | OddsValueCondition | EventCondition | CompositeCondition;
-export interface OddsDropCondition {
-    type: 'odds_drop';
-    matchId?: string;
-    team?: string;
-    threshold: number;
-    percentage: number;
-}
-export interface OddsValueCondition {
-    type: 'odds_value';
-    matchId?: string;
-    minValue: number;
-    maxOdds?: number;
-}
-export interface EventCondition {
-    type: 'event';
-    matchId?: string;
-    eventTypes: string[];
-}
-export interface CompositeCondition {
-    type: 'composite';
-    conditions: AlertCondition[];
-    operator: 'AND' | 'OR';
-}
-export interface NotificationChannel {
-    type: 'webhook' | 'email' | 'slack' | 'discord' | 'console';
-    config: Record<string, any>;
-}
-export interface AlertMessage {
-    ruleId: string;
-    ruleName: string;
-    type: AlertType;
-    severity: 'info' | 'warning' | 'critical';
-    title: string;
-    body: string;
-    data: any;
-    timestamp: number;
-}
-export declare class AlertManager extends EventEmitter {
-    private rules;
-    private checkInterval?;
-    private alertHistory;
-    private maxHistorySize;
-    constructor();
-    start(): void;
-    stop(): void;
-    addRule(rule: Omit<AlertRule, 'id' | 'createdAt' | 'triggerCount'>): AlertRule;
-    removeRule(ruleId: string): boolean;
-    getRules(): AlertRule[];
-    getRule(ruleId: string): AlertRule | undefined;
-    toggleRule(ruleId: string, enabled: boolean): boolean;
-    processEvent(event: LiveEvent): void;
-    private evaluateCondition;
-    private evaluateOddsDrop;
-    private evaluateOddsValue;
-    private evaluateEventCondition;
-    private evaluateCompositeCondition;
-    private triggerAlert;
-    private createAlertMessage;
-    private determineSeverity;
-    private formatAlertTitle;
-    private formatAlertBody;
-    private sendNotification;
-    private sendWebhook;
-    private sendSlack;
-    private sendDiscord;
-    private checkScheduledAlerts;
-    getAlertHistory(limit?: number): AlertMessage[];
-    clearHistory(): void;
-    getStats(): {
-        totalRules: number;
-        enabledRules: number;
-        totalAlerts: number;
-    };
-}
-export declare function getAlertManager(): AlertManager;
-export declare function resetAlertManager(): void;