import { AsyncLocalStorage } from 'async_hooks';
import { Request, Response, NextFunction } from 'express';

interface UsageMetrics {
    model: string;
    promptTokens: number;
    completionTokens: number;
    totalTokens: number;
    cost: number;
    timestamp: number;
    provider: string;
    userId?: string;
    teamId?: string;
    feature?: string;
    requestId?: string;
    metadata?: Record<string, any>;
}
interface AITrackingContext {
    userId?: string;
    teamId?: string;
    feature?: string;
    requestId?: string;
    metadata?: Record<string, any>;
}
interface AITrackerConfig {
    apiKey?: string;
    endpoint?: string;
    teamId?: string;
}
interface ModelCost {
    prompt: number;
    completion: number;
}
interface CostTable {
    [model: string]: ModelCost;
}
interface UsageReport {
    totalCost: number;
    totalTokens: number;
    usageByModel: {
        [model: string]: {
            cost: number;
            tokens: number;
            count: number;
        };
    };
    usageByProvider: {
        [provider: string]: {
            cost: number;
            tokens: number;
            count: number;
        };
    };
}
interface ProviderConfig {
    name: string;
    costTable?: CostTable;
}

interface AIProviderTracker<T = any, R = any> {
    name: string;
    trackRequest(params: T): void;
    trackResponse(response: R): UsageMetrics;
    calculateCost(model: string, promptTokens: number, completionTokens: number): number;
}
declare abstract class BaseProviderTracker<T = any, R = any> implements AIProviderTracker<T, R> {
    abstract name: string;
    protected costTable: Record<string, {
        prompt: number;
        completion: number;
    }>;
    constructor(costTable: Record<string, {
        prompt: number;
        completion: number;
    }>);
    abstract trackRequest(params: T): void;
    abstract trackResponse(response: R): UsageMetrics;
    calculateCost(model: string, promptTokens: number, completionTokens: number): number;
}

interface StorageProvider {
    save(metrics: UsageMetrics): Promise<void>;
    getAll(): Promise<UsageMetrics[]>;
}

interface Recommendation {
    currentModel: string;
    suggestedModel: string;
    reason: string;
    potentialSavings: number;
}

declare class CostTracker {
    private storage;
    constructor(storage?: StorageProvider);
    recordUsage(metrics: UsageMetrics, context?: AITrackingContext): Promise<void>;
    private checkMilestones;
    private maybeLogNudge;
    getUsageReport(): Promise<UsageReport>;
    getTotalCost(): Promise<number>;
    getUsageByUser(userId: string): Promise<UsageMetrics[]>;
    getUsageByFeature(feature: string): Promise<UsageMetrics[]>;
    getUsageByTeam(teamId: string): Promise<UsageMetrics[]>;
    getOptimizationSuggestions(): Promise<Recommendation[]>;
}
declare const tracker: CostTracker;

declare const contextStorage: AsyncLocalStorage<AITrackingContext>;
declare function setGlobalAIContext(context: AITrackingContext): void;
declare function getGlobalAIContext(): AITrackingContext;

declare function configureAITracker(newConfig: AITrackerConfig): void;
declare function getConfig(): AITrackerConfig;
declare function isProEnabled(): boolean;

declare class OpenAITracker extends BaseProviderTracker {
    name: string;
    constructor(customCosts?: Record<string, {
        prompt: number;
        completion: number;
    }>);
    trackRequest(params: any): void;
    trackResponse(response: any): UsageMetrics;
}
declare function trackOpenAI(client: any, options?: {
    context?: any;
    customCosts?: any;
}): any;

declare class AnthropicTracker extends BaseProviderTracker {
    name: string;
    constructor(customCosts?: Record<string, {
        prompt: number;
        completion: number;
    }>);
    trackRequest(params: any): void;
    trackResponse(response: any): UsageMetrics;
}
declare function trackAnthropic(client: any, options?: {
    context?: any;
    customCosts?: any;
}): any;

declare class GeminiTracker extends BaseProviderTracker {
    name: string;
    constructor(customCosts?: Record<string, {
        prompt: number;
        completion: number;
    }>);
    trackRequest(params: any): void;
    trackResponse(response: any): UsageMetrics;
}
declare function trackGemini(model: any, options?: {
    context?: any;
    customCosts?: any;
}): any;
/**
 * Support for the new @google/genai SDK
 */
declare function trackGenAI(ai: any, options?: {
    context?: any;
    customCosts?: any;
}): any;

declare function aiCostMiddleware(): (req: Request, res: Response, next: NextFunction) => Promise<void>;

interface ContextMiddlewareOptions {
    getUserId?: (req: Request) => string | undefined;
    getTeamId?: (req: Request) => string | undefined;
    getFeature?: (req: Request) => string | undefined;
    getRequestId?: (req: Request) => string | undefined;
    getMetadata?: (req: Request) => Record<string, any> | undefined;
}
declare function createAIContextMiddleware(options: ContextMiddlewareOptions): (req: any, res: Response, next: NextFunction) => void;

interface AlertOptions {
    dailyLimit: number;
    onAlert?: (currentCost: number, limit: number) => void;
}
declare function enableCostAlerts(options: AlertOptions): void;
declare function checkCostAlerts(limit: number): Promise<void>;

declare function onUsage(callback: (data: UsageMetrics) => void): void;
declare function emitUsage(metrics: UsageMetrics): void;

declare function monitorAI(): Promise<void>;

declare function sendUsageToCloud(metrics: UsageMetrics, retries?: number): Promise<void>;
declare const trackToCloud: typeof sendUsageToCloud;

export { type AIProviderTracker, type AITrackerConfig, type AITrackingContext, type AlertOptions, AnthropicTracker, BaseProviderTracker, type ContextMiddlewareOptions, type CostTable, CostTracker, GeminiTracker, type ModelCost, OpenAITracker, type ProviderConfig, type UsageMetrics, type UsageReport, aiCostMiddleware, checkCostAlerts, configureAITracker, contextStorage, createAIContextMiddleware, emitUsage, enableCostAlerts, getConfig, getGlobalAIContext, isProEnabled, monitorAI, onUsage, sendUsageToCloud, setGlobalAIContext, trackAnthropic, trackGemini, trackGenAI, trackOpenAI, trackToCloud, tracker };