import { a as OpenRouterConfig } from './index-DhuFIcmH.mjs';
export { c as ClientEventEmitter, b as ClientEvents, C as ConversationOptions, H as HttpConfig, O as OpenRouterClient, R as RetryConfig, S as SendOptions } from './index-DhuFIcmH.mjs';
import { a as ChatCompletionRequest, C as ChatCompletionResponse, S as StreamChunk, M as ModelsListResponse } from './api-sxRH3cfv.mjs';
export { f as ChatChoice, b as ChatMessage, F as FunctionCall, d as FunctionDefinition, c as MessageContent, h as ModelInfo, O as OpenRouterError, g as StreamChoice, e as Tool, T as ToolCall } from './api-sxRH3cfv.mjs';
import { L as Logger } from './logger-DUq4P1BF.mjs';
export { a as Model, c as ModelCapabilities, M as ModelCatalog, b as ModelFilter, e as ModelMetadata, d as ModelPricing, g as getModelCatalog } from './ModelCatalog-BcfW6bZr.mjs';
export { M as ModelSelector } from './ModelSelector-DKlwZIBW.mjs';
export { BalancedRouter, BalancedWeights, CapabilityRouter, CostOptimizer, PerformanceRouter } from './models/routers/index.mjs';
export { CascadingOptions, CascadingStrategy, ContextAnalysis, ContextAwareStrategy, WeightConfig, WeightedStrategy, WeightedStrategyOptions } from './models/strategies/index.mjs';
export { C as CostTracker, P as PricingCalculator } from './CostTracker-DLCvQRUS.mjs';
export { AlertConfig, AlertEvent, AlertThreshold, BudgetAlerting } from './pricing/index.mjs';
import { EventEmitter } from 'eventemitter3';
export { ExpressAdapter, createExpressAdapter } from './adapters/express.mjs';
export { FastifyAdapter, createFastifyAdapter, createFastifyPlugin } from './adapters/fastify.mjs';
export { OpenRouterService, createNestJSService } from './adapters/nestjs.mjs';
export { CacheEntry, CacheManager, CacheManagerOptions, CacheStats, CacheStrategy, DeduplicationOptions, LRUCache, LRUCacheOptions, MemoryCache, MemoryCacheOptions, RequestDeduplicator } from './cache/index.mjs';
export { B as BudgetAlert, b as CostComparison, a as CostEstimate, C as CostSummary, T as TokenUsage, U as UsageRecord } from './pricing-BUJAtUlg.mjs';
export { I as IRouter, b as RouterWeight, c as RoutingMetrics, R as RoutingStrategy, S as SelectionCriteria, a as SelectionResult } from './routing-BoTeveC1.mjs';
import { z } from 'zod';

interface RequestOptions {
    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
    headers?: Record<string, string>;
    body?: unknown;
    timeout?: number;
}
interface HttpResponse<T = any> {
    status: number;
    headers: Record<string, string>;
    data: T;
}
declare class HttpClient {
    private config;
    private agent;
    private logger;
    constructor(config: OpenRouterConfig, logger?: Logger);
    request<T = any>(url: string, options: RequestOptions): Promise<HttpResponse<T>>;
    get<T = any>(url: string, headers?: Record<string, string>): Promise<HttpResponse<T>>;
    post<T = any>(url: string, body: unknown, headers?: Record<string, string>): Promise<HttpResponse<T>>;
    put<T = any>(url: string, body: unknown, headers?: Record<string, string>): Promise<HttpResponse<T>>;
    delete<T = any>(url: string, headers?: Record<string, string>): Promise<HttpResponse<T>>;
    /**
     * POST request with SSE streaming support
     */
    postStream<T = any>(url: string, body: unknown, headers?: Record<string, string>): AsyncIterable<T>;
    destroy(): void;
}

declare class OpenRouterAPI {
    private httpClient;
    private logger;
    constructor(httpClient: HttpClient, logger: Logger);
    /**
     * Create a chat completion
     */
    createChatCompletion(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
    /**
     * Create a streaming chat completion
     */
    createStreamingChatCompletion(request: ChatCompletionRequest): AsyncIterable<StreamChunk>;
    /**
     * List available models
     */
    listModels(): Promise<ModelsListResponse>;
    /**
     * Get generation info (for cost tracking)
     */
    getGeneration(generationId: string): Promise<any>;
}

interface RetryPolicyOptions {
    maxAttempts: number;
    baseDelay: number;
    maxDelay: number;
    exponential: boolean;
    retryableStatusCodes: number[];
}
declare class RetryPolicy {
    private options;
    private logger;
    constructor(options: RetryPolicyOptions, logger?: Logger);
    execute<T>(operation: () => Promise<T>, context?: string): Promise<T>;
    private shouldRetry;
    private calculateDelay;
    private sleep;
}

type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
interface CircuitBreakerOptions {
    failureThreshold: number;
    resetTimeout: number;
    monitorInterval: number;
}
interface CircuitBreakerEvents {
    'state:changed': (oldState: CircuitState, newState: CircuitState) => void;
    'circuit:opened': (failures: number) => void;
    'circuit:closed': () => void;
    'failure:recorded': (total: number) => void;
}
declare class CircuitBreaker extends EventEmitter<CircuitBreakerEvents> {
    private options;
    private state;
    private failureCount;
    private lastFailureTime?;
    private resetTimer?;
    private logger;
    constructor(options: CircuitBreakerOptions, logger?: Logger);
    execute<T>(operation: () => Promise<T>): Promise<T>;
    private onSuccess;
    private onFailure;
    private open;
    private halfOpen;
    private close;
    getState(): CircuitState;
    getFailureCount(): number;
    isOpen(): boolean;
    reset(): void;
    destroy(): void;
}

/**
 * Metrics Collector
 * Tracks latency, token usage, costs, and other performance metrics
 */

interface RequestMetrics {
    modelId: string;
    provider: string;
    startTime: number;
    endTime: number;
    duration: number;
    inputTokens: number;
    outputTokens: number;
    totalTokens: number;
    cost: number;
    success: boolean;
    errorType?: string;
    cacheHit?: boolean;
}
interface AggregatedMetrics {
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    averageLatency: number;
    p50Latency: number;
    p95Latency: number;
    p99Latency: number;
    totalTokens: number;
    totalCost: number;
    cacheHitRate: number;
    byModel: Map<string, ModelMetrics>;
    byProvider: Map<string, ProviderMetrics>;
}
interface ModelMetrics {
    requests: number;
    successRate: number;
    averageLatency: number;
    totalTokens: number;
    totalCost: number;
}
interface ProviderMetrics {
    requests: number;
    successRate: number;
    averageLatency: number;
    totalCost: number;
    errorRate: number;
}
declare class MetricsCollector extends EventEmitter {
    private metrics;
    private maxMetricsHistory;
    private aggregationInterval;
    private aggregationTimer?;
    constructor(options?: {
        maxHistory?: number;
        aggregationInterval?: number;
    });
    /**
     * Record a request metric
     */
    record(metric: RequestMetrics): void;
    /**
     * Start a request timer
     */
    startRequest(modelId: string, provider: string): {
        finish: (result: {
            inputTokens: number;
            outputTokens: number;
            cost: number;
            success: boolean;
            errorType?: string;
            cacheHit?: boolean;
        }) => void;
    };
    /**
     * Get aggregated metrics
     */
    getAggregatedMetrics(timeRange?: {
        start: number;
        end: number;
    }): AggregatedMetrics;
    /**
     * Get metrics for a specific model
     */
    getModelMetrics(modelId: string): ModelMetrics | null;
    /**
     * Get metrics for a specific provider
     */
    getProviderMetrics(provider: string): ProviderMetrics | null;
    /**
     * Clear all metrics
     */
    clear(): void;
    /**
     * Stop metrics collection
     */
    stop(): void;
    /**
     * Calculate percentile
     */
    private percentile;
    /**
     * Aggregate metrics by model
     */
    private aggregateByModel;
    /**
     * Aggregate metrics by provider
     */
    private aggregateByProvider;
    /**
     * Get empty metrics object
     */
    private getEmptyMetrics;
    /**
     * Start periodic aggregation
     */
    private startAggregation;
}

/**
 * Health Check System
 * Monitors service health and provider status
 */

interface HealthStatus {
    status: 'healthy' | 'degraded' | 'unhealthy';
    timestamp: number;
    checks: {
        api: CheckResult;
        providers: Map<string, CheckResult>;
        cache?: CheckResult;
        database?: CheckResult;
    };
    uptime: number;
    version: string;
}
interface CheckResult {
    status: 'pass' | 'warn' | 'fail';
    latency?: number;
    message?: string;
    timestamp: number;
}
interface HealthCheckOptions {
    interval?: number;
    timeout?: number;
    logger?: Logger;
}
declare class HealthCheck extends EventEmitter {
    private interval;
    private timeout;
    private logger;
    private checkTimer?;
    private startTime;
    private lastStatus?;
    constructor(options?: HealthCheckOptions);
    /**
     * Start health checks
     */
    start(): void;
    /**
     * Stop health checks
     */
    stop(): void;
    /**
     * Run a health check
     */
    runHealthCheck(): Promise<HealthStatus>;
    /**
     * Get last health status
     */
    getLastStatus(): HealthStatus | undefined;
    /**
     * Check API health
     */
    private checkAPI;
    /**
     * Check provider health
     */
    private checkProviders;
    /**
     * Check individual provider health
     */
    private checkProvider;
    /**
     * Determine overall health status
     */
    private determineStatus;
}

/**
 * Analytics System
 * Track usage patterns, trends, and insights
 */

interface UsageAnalytics {
    timeRange: {
        start: number;
        end: number;
    };
    summary: {
        totalRequests: number;
        uniqueModels: number;
        uniqueProviders: number;
        totalCost: number;
        totalTokens: number;
        averageRequestsPerMinute: number;
    };
    trends: {
        mostUsedModels: Array<{
            modelId: string;
            count: number;
            percentage: number;
        }>;
        costByProvider: Map<string, number>;
        requestsByHour: Map<number, number>;
        successRate: number;
        averageCostPerRequest: number;
    };
    recommendations?: {
        suggestedModels?: string[];
        potentialSavings?: number;
        optimizationTips?: string[];
    };
}
declare class Analytics extends EventEmitter {
    private metrics;
    constructor();
    /**
     * Add a metric for analysis
     */
    addMetric(metric: RequestMetrics): void;
    /**
     * Add multiple metrics
     */
    addMetrics(metrics: RequestMetrics[]): void;
    /**
     * Get usage analytics for a time range
     */
    getAnalytics(timeRange?: {
        start: number;
        end: number;
    }): UsageAnalytics;
    /**
     * Get model usage statistics
     */
    getModelUsage(): Map<string, {
        count: number;
        cost: number;
        tokens: number;
    }>;
    /**
     * Get provider usage statistics
     */
    getProviderUsage(): Map<string, {
        count: number;
        cost: number;
        successRate: number;
    }>;
    /**
     * Get cost trends over time
     */
    getCostTrends(granularity?: 'hour' | 'day'): Map<number, {
        cost: number;
        requests: number;
    }>;
    /**
     * Clear all metrics
     */
    clear(): void;
    /**
     * Calculate trends
     */
    private calculateTrends;
    /**
     * Generate recommendations based on usage patterns
     */
    private generateRecommendations;
    /**
     * Find duplicate request patterns
     */
    private findDuplicatePatterns;
    /**
     * Suggest alternative models based on usage
     */
    private suggestAlternativeModels;
    /**
     * Get empty analytics object
     */
    private getEmptyAnalytics;
}

/**
 * Base Provider Interface
 * Abstract class for provider-specific implementations
 */

interface ProviderConfig {
    name: string;
    apiKey?: string;
    baseURL?: string;
    timeout?: number;
    retryAttempts?: number;
    rateLimit?: {
        requestsPerSecond: number;
        tokensPerMinute?: number;
    };
}
interface ProviderCapabilities {
    streaming: boolean;
    vision: boolean;
    functionCalling: boolean;
    jsonMode: boolean;
    tools: boolean;
    multimodal: boolean;
}
interface ProviderStats {
    averageLatency: number;
    successRate: number;
    totalRequests: number;
    failedRequests: number;
    lastError?: string;
    lastErrorTime?: number;
}
interface ProviderHealth {
    status: 'healthy' | 'degraded' | 'unhealthy';
    lastCheck: number;
    latency?: number;
    error?: string;
}
declare abstract class BaseProvider {
    protected config: ProviderConfig;
    protected logger: Logger;
    protected metrics: ProviderStats;
    protected health: ProviderHealth;
    constructor(config: ProviderConfig, logger?: Logger);
    /**
     * Get provider name
     */
    getName(): string;
    /**
     * Get provider capabilities
     */
    abstract getCapabilities(): ProviderCapabilities;
    /**
     * Get available models for this provider
     */
    abstract getModels(): Promise<string[]>;
    /**
     * Check if provider supports a specific model
     */
    abstract supportsModel(modelId: string): boolean;
    /**
     * Transform OpenRouter request to provider-specific format
     */
    abstract transformRequest(request: any): any;
    /**
     * Transform provider-specific response to OpenRouter format
     */
    abstract transformResponse(response: any): any;
    /**
     * Get provider-specific rate limits
     */
    getRateLimits(): {
        requestsPerSecond: number;
        tokensPerMinute?: number;
    };
    /**
     * Get provider statistics
     */
    getStats(): ProviderStats;
    /**
     * Get provider health status
     */
    getHealth(): ProviderHealth;
    /**
     * Update metrics after request
     */
    protected updateMetrics(success: boolean, latency: number, error?: string): void;
    /**
     * Check provider health
     */
    checkHealth(): Promise<ProviderHealth>;
    /**
     * Reset metrics
     */
    resetMetrics(): void;
}

/**
 * Provider Registry
 * Manages all available providers and their instances
 */

interface ProviderRegistryOptions {
    logger?: Logger;
    defaultProviders?: boolean;
}
declare class ProviderRegistry {
    private providers;
    private logger;
    constructor(options?: ProviderRegistryOptions);
    /**
     * Register default providers
     */
    private registerDefaultProviders;
    /**
     * Register a provider
     */
    register(provider: BaseProvider): void;
    /**
     * Unregister a provider
     */
    unregister(providerName: string): boolean;
    /**
     * Get a provider by name
     */
    getProvider(name: string): BaseProvider | undefined;
    /**
     * Get all providers
     */
    getAllProviders(): BaseProvider[];
    /**
     * Get provider for a specific model
     */
    getProviderForModel(modelId: string): BaseProvider | undefined;
    /**
     * Get all available models across all providers
     */
    getAllModels(): Promise<Map<string, string[]>>;
    /**
     * Check health of all providers
     */
    checkAllHealth(): Promise<Map<string, any>>;
    /**
     * Get statistics from all providers
     */
    getAllStats(): Map<string, any>;
    /**
     * Get healthy providers only
     */
    getHealthyProviders(): BaseProvider[];
    /**
     * Get providers by capability
     */
    getProvidersByCapability(capability: string): BaseProvider[];
    /**
     * Clear all providers
     */
    clear(): void;
}

/**
 * OpenAI Provider Implementation
 */

declare class OpenAIProvider extends BaseProvider {
    constructor(config?: Partial<ProviderConfig>);
    getCapabilities(): ProviderCapabilities;
    getModels(): Promise<string[]>;
    supportsModel(modelId: string): boolean;
    transformRequest(request: any): any;
    transformResponse(response: any): any;
}

/**
 * Anthropic Provider Implementation
 */

declare class AnthropicProvider extends BaseProvider {
    constructor(config?: Partial<ProviderConfig>);
    getCapabilities(): ProviderCapabilities;
    getModels(): Promise<string[]>;
    supportsModel(modelId: string): boolean;
    transformRequest(request: any): any;
    transformResponse(response: any): any;
}

/**
 * Meta (Llama) Provider Implementation
 */

declare class LlamaProvider extends BaseProvider {
    constructor(config?: Partial<ProviderConfig>);
    getCapabilities(): ProviderCapabilities;
    getModels(): Promise<string[]>;
    supportsModel(modelId: string): boolean;
    transformRequest(request: any): any;
    transformResponse(response: any): any;
}

/**
 * Mistral Provider Implementation
 */

declare class MistralProvider extends BaseProvider {
    constructor(config?: Partial<ProviderConfig>);
    getCapabilities(): ProviderCapabilities;
    getModels(): Promise<string[]>;
    supportsModel(modelId: string): boolean;
    transformRequest(request: any): any;
    transformResponse(response: any): any;
}

/**
 * Cohere Provider Implementation
 */

declare class CohereProvider extends BaseProvider {
    constructor(config?: Partial<ProviderConfig>);
    getCapabilities(): ProviderCapabilities;
    getModels(): Promise<string[]>;
    supportsModel(modelId: string): boolean;
    transformRequest(request: any): any;
    transformResponse(response: any): any;
}

interface ProviderInfo {
    id: string;
    name: string;
    description?: string;
    website?: string;
    capabilities: {
        streaming: boolean;
        functionCalling: boolean;
        vision: boolean;
        tools: boolean;
    };
    rateLimits?: {
        requestsPerSecond: number;
        tokensPerMinute: number;
    };
    reliability?: {
        uptime: number;
        averageLatency: number;
    };
    models: string[];
    metadata?: Record<string, unknown>;
}
interface IProvider {
    getId(): string;
    getName(): string;
    getCapabilities(): ProviderInfo['capabilities'];
    supportsModel(modelId: string): boolean;
    getRateLimits(): ProviderInfo['rateLimits'];
}

declare const ModelCapabilitiesSchema: z.ZodObject<{
    vision: z.ZodDefault<z.ZodBoolean>;
    functionCalling: z.ZodDefault<z.ZodBoolean>;
    jsonMode: z.ZodDefault<z.ZodBoolean>;
    tools: z.ZodDefault<z.ZodBoolean>;
    streaming: z.ZodDefault<z.ZodBoolean>;
    codeGeneration: z.ZodOptional<z.ZodBoolean>;
    multilingual: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    vision: boolean;
    functionCalling: boolean;
    jsonMode: boolean;
    tools: boolean;
    streaming: boolean;
    multilingual?: boolean | undefined;
    codeGeneration?: boolean | undefined;
}, {
    vision?: boolean | undefined;
    multilingual?: boolean | undefined;
    codeGeneration?: boolean | undefined;
    functionCalling?: boolean | undefined;
    jsonMode?: boolean | undefined;
    tools?: boolean | undefined;
    streaming?: boolean | undefined;
}>;
declare const ModelPricingSchema: z.ZodObject<{
    inputTokens: z.ZodNumber;
    outputTokens: z.ZodNumber;
    imageInput: z.ZodOptional<z.ZodNumber>;
    currency: z.ZodDefault<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    inputTokens: number;
    outputTokens: number;
    currency: string;
    imageInput?: number | undefined;
}, {
    inputTokens: number;
    outputTokens: number;
    imageInput?: number | undefined;
    currency?: string | undefined;
}>;
declare const OpenRouterConfigSchema: z.ZodObject<{
    apiKey: z.ZodString;
    baseURL: z.ZodDefault<z.ZodString>;
    appName: z.ZodOptional<z.ZodString>;
    httpReferer: z.ZodOptional<z.ZodString>;
    defaultModel: z.ZodOptional<z.ZodString>;
    timeout: z.ZodDefault<z.ZodNumber>;
    maxRetries: z.ZodDefault<z.ZodNumber>;
    retryDelay: z.ZodDefault<z.ZodNumber>;
    modelSelection: z.ZodOptional<z.ZodObject<{
        strategy: z.ZodDefault<z.ZodEnum<["cost", "performance", "balanced", "capability", "custom"]>>;
        fallbackEnabled: z.ZodDefault<z.ZodBoolean>;
        maxFallbacks: z.ZodDefault<z.ZodNumber>;
        autoSelect: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        strategy: "cost" | "performance" | "balanced" | "capability" | "custom";
        maxFallbacks: number;
        fallbackEnabled: boolean;
        autoSelect: boolean;
    }, {
        strategy?: "cost" | "performance" | "balanced" | "capability" | "custom" | undefined;
        maxFallbacks?: number | undefined;
        fallbackEnabled?: boolean | undefined;
        autoSelect?: boolean | undefined;
    }>>;
    budgets: z.ZodOptional<z.ZodObject<{
        daily: z.ZodOptional<z.ZodNumber>;
        monthly: z.ZodOptional<z.ZodNumber>;
        total: z.ZodOptional<z.ZodNumber>;
        alertThreshold: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        alertThreshold: number;
        daily?: number | undefined;
        monthly?: number | undefined;
        total?: number | undefined;
    }, {
        daily?: number | undefined;
        monthly?: number | undefined;
        total?: number | undefined;
        alertThreshold?: number | undefined;
    }>>;
    cache: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        ttl: z.ZodDefault<z.ZodNumber>;
        maxSize: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        ttl: number;
        maxSize: number;
    }, {
        enabled?: boolean | undefined;
        ttl?: number | undefined;
        maxSize?: number | undefined;
    }>>;
    logging: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        level: "debug" | "info" | "warn" | "error";
    }, {
        enabled?: boolean | undefined;
        level?: "debug" | "info" | "warn" | "error" | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    timeout: number;
    apiKey: string;
    baseURL: string;
    maxRetries: number;
    retryDelay: number;
    appName?: string | undefined;
    httpReferer?: string | undefined;
    defaultModel?: string | undefined;
    modelSelection?: {
        strategy: "cost" | "performance" | "balanced" | "capability" | "custom";
        maxFallbacks: number;
        fallbackEnabled: boolean;
        autoSelect: boolean;
    } | undefined;
    budgets?: {
        alertThreshold: number;
        daily?: number | undefined;
        monthly?: number | undefined;
        total?: number | undefined;
    } | undefined;
    cache?: {
        enabled: boolean;
        ttl: number;
        maxSize: number;
    } | undefined;
    logging?: {
        enabled: boolean;
        level: "debug" | "info" | "warn" | "error";
    } | undefined;
}, {
    apiKey: string;
    timeout?: number | undefined;
    baseURL?: string | undefined;
    appName?: string | undefined;
    httpReferer?: string | undefined;
    defaultModel?: string | undefined;
    maxRetries?: number | undefined;
    retryDelay?: number | undefined;
    modelSelection?: {
        strategy?: "cost" | "performance" | "balanced" | "capability" | "custom" | undefined;
        maxFallbacks?: number | undefined;
        fallbackEnabled?: boolean | undefined;
        autoSelect?: boolean | undefined;
    } | undefined;
    budgets?: {
        daily?: number | undefined;
        monthly?: number | undefined;
        total?: number | undefined;
        alertThreshold?: number | undefined;
    } | undefined;
    cache?: {
        enabled?: boolean | undefined;
        ttl?: number | undefined;
        maxSize?: number | undefined;
    } | undefined;
    logging?: {
        enabled?: boolean | undefined;
        level?: "debug" | "info" | "warn" | "error" | undefined;
    } | undefined;
}>;
declare const SendOptionsSchema: z.ZodObject<{
    model: z.ZodOptional<z.ZodString>;
    temperature: z.ZodOptional<z.ZodNumber>;
    maxTokens: z.ZodOptional<z.ZodNumber>;
    topP: z.ZodOptional<z.ZodNumber>;
    stream: z.ZodOptional<z.ZodBoolean>;
    functions: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
    tools: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
    responseFormat: z.ZodOptional<z.ZodObject<{
        type: z.ZodEnum<["text", "json_object"]>;
    }, "strip", z.ZodTypeAny, {
        type: "text" | "json_object";
    }, {
        type: "text" | "json_object";
    }>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    model?: string | undefined;
    tools?: any[] | undefined;
    functions?: any[] | undefined;
    temperature?: number | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    stream?: boolean | undefined;
    responseFormat?: {
        type: "text" | "json_object";
    } | undefined;
    metadata?: Record<string, unknown> | undefined;
}, {
    model?: string | undefined;
    tools?: any[] | undefined;
    functions?: any[] | undefined;
    temperature?: number | undefined;
    maxTokens?: number | undefined;
    topP?: number | undefined;
    stream?: boolean | undefined;
    responseFormat?: {
        type: "text" | "json_object";
    } | undefined;
    metadata?: Record<string, unknown> | undefined;
}>;
declare const SelectionCriteriaSchema: z.ZodObject<{
    providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    capabilities: z.ZodOptional<z.ZodObject<{
        vision: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        functionCalling: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        jsonMode: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        tools: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        streaming: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        codeGeneration: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
        multilingual: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
    }, "strip", z.ZodTypeAny, {
        vision?: boolean | undefined;
        multilingual?: boolean | undefined;
        codeGeneration?: boolean | undefined;
        functionCalling?: boolean | undefined;
        jsonMode?: boolean | undefined;
        tools?: boolean | undefined;
        streaming?: boolean | undefined;
    }, {
        vision?: boolean | undefined;
        multilingual?: boolean | undefined;
        codeGeneration?: boolean | undefined;
        functionCalling?: boolean | undefined;
        jsonMode?: boolean | undefined;
        tools?: boolean | undefined;
        streaming?: boolean | undefined;
    }>>;
    maxCost: z.ZodOptional<z.ZodNumber>;
    minContextWindow: z.ZodOptional<z.ZodNumber>;
    modality: z.ZodOptional<z.ZodEnum<["text", "multimodal"]>>;
    excludeDeprecated: z.ZodDefault<z.ZodBoolean>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    tier: z.ZodOptional<z.ZodEnum<["budget", "balanced", "premium"]>>;
    fallbackModels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    preferredProviders: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    excludeProviders: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    strategy: z.ZodOptional<z.ZodEnum<["cost", "performance", "balanced", "capability", "custom"]>>;
}, "strip", z.ZodTypeAny, {
    excludeDeprecated: boolean;
    tier?: "balanced" | "budget" | "premium" | undefined;
    fallbackModels?: string[] | undefined;
    preferredProviders?: string[] | undefined;
    excludeProviders?: string[] | undefined;
    strategy?: "cost" | "performance" | "balanced" | "capability" | "custom" | undefined;
    capabilities?: {
        vision?: boolean | undefined;
        multilingual?: boolean | undefined;
        codeGeneration?: boolean | undefined;
        functionCalling?: boolean | undefined;
        jsonMode?: boolean | undefined;
        tools?: boolean | undefined;
        streaming?: boolean | undefined;
    } | undefined;
    providers?: string[] | undefined;
    maxCost?: number | undefined;
    minContextWindow?: number | undefined;
    modality?: "text" | "multimodal" | undefined;
    tags?: string[] | undefined;
}, {
    tier?: "balanced" | "budget" | "premium" | undefined;
    fallbackModels?: string[] | undefined;
    preferredProviders?: string[] | undefined;
    excludeProviders?: string[] | undefined;
    strategy?: "cost" | "performance" | "balanced" | "capability" | "custom" | undefined;
    capabilities?: {
        vision?: boolean | undefined;
        multilingual?: boolean | undefined;
        codeGeneration?: boolean | undefined;
        functionCalling?: boolean | undefined;
        jsonMode?: boolean | undefined;
        tools?: boolean | undefined;
        streaming?: boolean | undefined;
    } | undefined;
    providers?: string[] | undefined;
    maxCost?: number | undefined;
    minContextWindow?: number | undefined;
    modality?: "text" | "multimodal" | undefined;
    excludeDeprecated?: boolean | undefined;
    tags?: string[] | undefined;
}>;
type ValidatedConfig = z.infer<typeof OpenRouterConfigSchema>;
type ValidatedSendOptions = z.infer<typeof SendOptionsSchema>;
type ValidatedSelectionCriteria = z.infer<typeof SelectionCriteriaSchema>;

declare const DEFAULT_CONFIG: Partial<OpenRouterConfig>;
declare const DEFAULT_MODELS: {
    budget: string;
    balanced: string;
    premium: string;
    vision: string;
    coding: string;
};
declare const RETRY_STATUS_CODES: number[];
declare const OPENROUTER_ENDPOINTS: {
    readonly CHAT: "/chat/completions";
    readonly MODELS: "/models";
    readonly GENERATION: "/generation";
};

export { type AggregatedMetrics, Analytics, AnthropicProvider, BaseProvider, ChatCompletionRequest, ChatCompletionResponse, type CheckResult, CircuitBreaker, type CircuitBreakerOptions, CohereProvider, DEFAULT_CONFIG, DEFAULT_MODELS, HealthCheck, type HealthCheckOptions, type HealthStatus, HttpClient, type HttpResponse, type IProvider, LlamaProvider, MetricsCollector, MistralProvider, ModelCapabilitiesSchema, type ModelMetrics, ModelPricingSchema, ModelsListResponse, OPENROUTER_ENDPOINTS, OpenAIProvider, OpenRouterAPI, OpenRouterConfig, OpenRouterConfigSchema, type ProviderCapabilities, type ProviderConfig, type ProviderHealth, type ProviderInfo, type ProviderMetrics, ProviderRegistry, type ProviderRegistryOptions, type ProviderStats, RETRY_STATUS_CODES, type RequestMetrics, type RequestOptions, RetryPolicy, type RetryPolicyOptions, SelectionCriteriaSchema, SendOptionsSchema, StreamChunk, type UsageAnalytics, type ValidatedConfig, type ValidatedSelectionCriteria, type ValidatedSendOptions };