import { T as TokenUsage, a as CostEstimate, b as CostComparison, U as UsageRecord, C as CostSummary } from './pricing-BUJAtUlg.js';
import { M as ModelCatalog } from './ModelCatalog-BcfW6bZr.js';
import { EventEmitter } from 'eventemitter3';

declare class PricingCalculator {
    private catalog;
    constructor(catalog: ModelCatalog);
    /**
     * Estimate cost for a specific model
     */
    estimateCost(modelId: string, tokens: TokenUsage | {
        input: number;
        output: number;
    }): CostEstimate;
    /**
     * Estimate cost from text (approximation)
     */
    estimateFromText(modelId: string, inputText: string, estimatedOutputTokens: number): CostEstimate;
    /**
     * Compare costs across multiple models
     */
    compareModels(modelIds: string[], tokens: TokenUsage | {
        input: number;
        output: number;
    }): CostComparison;
    /**
     * Get cheapest model for a task
     */
    getCheapestModel(modelIds: string[], tokens: TokenUsage | {
        input: number;
        output: number;
    }): {
        modelId: string;
        estimate: CostEstimate;
    };
    /**
     * Calculate potential savings
     */
    calculateSavings(currentModelId: string, alternativeModelId: string, tokens: TokenUsage | {
        input: number;
        output: number;
    }): {
        savings: number;
        savingsPercentage: number;
        currentCost: number;
        alternativeCost: number;
    };
}

interface CostTrackerEvents {
    'usage:recorded': (record: UsageRecord) => void;
    'threshold:exceeded': (period: 'daily' | 'monthly' | 'total', current: number, limit: number) => void;
}
declare class CostTracker extends EventEmitter<CostTrackerEvents> {
    private retentionDays;
    private usageHistory;
    private totalCost;
    private costByModel;
    private costByProvider;
    constructor(retentionDays?: number);
    /**
     * Record a usage event
     */
    recordUsage(record: UsageRecord): void;
    /**
     * Get usage summary for a time period
     */
    getSummary(startDate?: Date, endDate?: Date): CostSummary;
    /**
     * Get daily costs
     */
    getDailyCost(date?: Date): number;
    /**
     * Get monthly costs
     */
    getMonthlyCost(year?: number, month?: number): number;
    /**
     * Get total cost
     */
    getTotalCost(): number;
    /**
     * Get usage by model
     */
    getUsageByModel(): Map<string, CostSummary>;
    /**
     * Get usage by provider
     */
    getUsageByProvider(): Map<string, CostSummary>;
    /**
     * Clear old records
     */
    private cleanup;
    private startCleanupInterval;
    /**
     * Export usage data
     */
    exportData(): UsageRecord[];
    /**
     * Reset all tracking data
     */
    reset(): void;
}

export { CostTracker as C, PricingCalculator as P };