/**
 * Metrics Collection Module
 *
 * Simple in-memory metrics collection for AgentRouter observability.
 * Tracks:
 * - Request counts (by role, provider, status)
 * - Latency histograms with percentile calculations (by role, provider)
 * - Token usage (input, output by provider)
 * - Error counts (by type, provider)
 * - Circuit breaker state changes
 *
 * No external dependencies - pure TypeScript implementation.
 */
/**
 * Token usage statistics for a provider.
 */
export interface TokenStats {
    input: number;
    output: number;
    total: number;
}
/**
 * Latency statistics with percentiles.
 */
export interface LatencyStats {
    count: number;
    min: number;
    max: number;
    mean: number;
    p50: number;
    p95: number;
    p99: number;
}
/**
 * Circuit breaker state.
 */
export type CircuitBreakerState = 'closed' | 'open' | 'half-open';
/**
 * Circuit breaker state change event.
 */
export interface CircuitBreakerEvent {
    provider: string;
    previousState: CircuitBreakerState;
    newState: CircuitBreakerState;
    timestamp: number;
}
/**
 * Request status for metrics tracking.
 */
export type RequestStatus = 'success' | 'error' | 'timeout' | 'rate_limited';
/**
 * Input for recording a request.
 */
export interface RequestRecord {
    role: string;
    provider: string;
    status: RequestStatus;
    durationMs: number;
    tokens?: {
        input: number;
        output: number;
    };
}
/**
 * Aggregated metrics snapshot.
 */
export interface Metrics {
    requests: {
        total: number;
        byRole: Map<string, number>;
        byProvider: Map<string, number>;
        byStatus: Map<string, number>;
    };
    latency: {
        p50: number;
        p95: number;
        p99: number;
        byProvider: Map<string, LatencyStats>;
        byRole: Map<string, LatencyStats>;
    };
    tokens: {
        input: number;
        output: number;
        byProvider: Map<string, TokenStats>;
    };
    errors: {
        total: number;
        byType: Map<string, number>;
        byProvider: Map<string, number>;
    };
    circuitBreaker: {
        stateChanges: CircuitBreakerEvent[];
        currentStates: Map<string, CircuitBreakerState>;
    };
    startTime: number;
    lastUpdated: number;
}
/**
 * JSON-serializable metrics format.
 */
export interface MetricsJSON {
    requests: {
        total: number;
        byRole: Record<string, number>;
        byProvider: Record<string, number>;
        byStatus: Record<string, number>;
    };
    latency: {
        p50: number;
        p95: number;
        p99: number;
        byProvider: Record<string, LatencyStats>;
        byRole: Record<string, LatencyStats>;
    };
    tokens: {
        input: number;
        output: number;
        byProvider: Record<string, TokenStats>;
    };
    errors: {
        total: number;
        byType: Record<string, number>;
        byProvider: Record<string, number>;
    };
    circuitBreaker: {
        stateChanges: CircuitBreakerEvent[];
        currentStates: Record<string, CircuitBreakerState>;
    };
    startTime: number;
    lastUpdated: number;
    uptimeMs: number;
}
/**
 * Metrics collector for tracking AgentRouter performance and usage.
 *
 * Thread-safe for single-threaded Node.js runtime.
 * Maintains rolling latency data for percentile calculations.
 *
 * @example
 * ```typescript
 * const metrics = new MetricsCollector();
 *
 * // Record a successful request
 * metrics.recordRequest({
 *   role: 'coder',
 *   provider: 'anthropic',
 *   status: 'success',
 *   durationMs: 1234,
 *   tokens: { input: 100, output: 500 }
 * });
 *
 * // Record an error
 * metrics.recordError('RateLimitError', 'openai');
 *
 * // Get metrics snapshot
 * const snapshot = metrics.getMetrics();
 * console.log(`Total requests: ${snapshot.requests.total}`);
 * console.log(`P95 latency: ${snapshot.latency.p95}ms`);
 * ```
 */
export declare class MetricsCollector {
    private requestCount;
    private requestsByRole;
    private requestsByProvider;
    private requestsByStatus;
    private latencyValues;
    private latencyByProvider;
    private latencyByRole;
    private totalInputTokens;
    private totalOutputTokens;
    private tokensByProvider;
    private errorCount;
    private errorsByType;
    private errorsByProvider;
    private circuitBreakerEvents;
    private circuitBreakerStates;
    private readonly startTime;
    private lastUpdated;
    private readonly maxLatencySamples;
    private readonly maxCircuitBreakerEvents;
    /**
     * Create a new MetricsCollector.
     *
     * @param options Configuration options
     * @param options.maxLatencySamples Maximum number of latency samples to keep (default: 10000)
     * @param options.maxCircuitBreakerEvents Maximum circuit breaker events to keep (default: 1000)
     */
    constructor(options?: {
        maxLatencySamples?: number;
        maxCircuitBreakerEvents?: number;
    });
    /**
     * Record a completed request.
     *
     * @param record Request details to record
     */
    recordRequest(record: RequestRecord): void;
    /**
     * Record an error occurrence.
     *
     * @param errorType The type/class of the error
     * @param provider The provider that produced the error (optional)
     */
    recordError(errorType: string, provider?: string): void;
    /**
     * Record a circuit breaker state change.
     *
     * @param provider The provider whose circuit breaker changed
     * @param previousState The previous state
     * @param newState The new state
     */
    recordCircuitBreakerChange(provider: string, previousState: CircuitBreakerState, newState: CircuitBreakerState): void;
    /**
     * Get the current metrics snapshot.
     *
     * @returns Aggregated metrics with calculated percentiles
     */
    getMetrics(): Metrics;
    /**
     * Reset all metrics to initial state.
     * Useful for testing or periodic resets.
     */
    reset(): void;
    /**
     * Export metrics as a JSON string.
     *
     * @returns JSON string representation of all metrics
     */
    toJSON(): string;
    /**
     * Get a summary string suitable for logging.
     *
     * @returns Human-readable summary of key metrics
     */
    getSummary(): string;
    private incrementMap;
    private addLatencySample;
    private addLatencySampleToMap;
    private calculateLatencyStatsByKey;
}
/**
 * Default metrics collector instance for the agent-router package.
 * Pre-configured and ready to use.
 */
export declare const metrics: MetricsCollector;
/**
 * Re-export for convenience.
 */
export default metrics;
//# sourceMappingURL=metrics.d.ts.map