/**
 * Unified Telemetry Collector
 * Part of Phase 2: System Stabilization
 */
export declare enum SystemEvent {
    MEMORY_QUERY_START = "memory.query.start",
    MEMORY_QUERY_END = "memory.query.end",
    MEMORY_CACHE_HIT = "memory.cache.hit",
    MEMORY_CACHE_MISS = "memory.cache.miss",
    MEMORY_CACHE_EVICT = "memory.cache.evict",
    MEMORY_ROUTING = "memory.routing.decision",
    MEMORY_ERROR = "memory.error",
    KG_QUERY_START = "kg.query.start",
    KG_QUERY_END = "kg.query.end",
    KG_INDEX_DONE = "kg.index.done",
    KG_OPTIMIZE = "kg.optimize.done",
    KG_NODE_ADD = "kg.node.add",
    KG_EDGE_ADD = "kg.edge.add",
    CONV_TURN_START = "conv.turn.start",
    CONV_TURN_END = "conv.turn.end",
    CONV_FOLLOWUP = "conv.followup.detected",
    CONV_CONTEXT_UPDATE = "conv.context.update",
    LEARN_PATTERN_ADD = "learn.pattern.added",
    LEARN_SUGGEST = "learn.suggestion.made",
    LEARN_FEEDBACK = "learn.feedback.received",
    SYSTEM_START = "system.start",
    SYSTEM_SHUTDOWN = "system.shutdown",
    SYSTEM_ERROR = "system.error",
    SYSTEM_HEALTH = "system.health.check"
}
export interface TelemetryEvent {
    event: SystemEvent | string;
    ts: number;
    dur?: number;
    tags: {
        _comp: "memory" | "kg" | "conv" | "learn" | "system";
        tenant?: string;
        topic?: string;
        strategy?: string;
        [_key: string]: string | undefined;
    };
    meta?: Record<string, unknown>;
    _error?: {
        message: string;
        stack?: string;
        code?: string;
    };
}
export interface TelemetryMetrics {
    eventCount: number;
    errorCount: number;
    avgDuration: number;
    p50Duration: number;
    p95Duration: number;
    p99Duration: number;
    errorRate: number;
    throughput: number;
}
export interface ComponentMetrics {
    [component: string]: TelemetryMetrics;
}
type EventListener = (event: TelemetryEvent) => void;
export declare class TelemetryCollector {
    private _events;
    private readonly maxEvents;
    private _listeners;
    private metricsCache;
    private cacheExpiry;
    private lastCacheUpdate;
    private eventCounters;
    private static instance;
    private constructor();
    /**
     * Get singleton instance
     */
    static getInstance(): TelemetryCollector;
    /**
     * Emit a telemetry event
     */
    emit(event: Omit<TelemetryEvent, "ts">): void;
    /**
     * Start a timed operation
     */
    startTimer(event: SystemEvent | string, tags: TelemetryEvent["tags"]): () => void;
    /**
     * Record an _error
     */
    recordError(component: TelemetryEvent["tags"]["_comp"], _error: Error | unknown, context?: Record<string, unknown>): void;
    /**
     * Subscribe to _events
     */
    subscribe(pattern: string | RegExp, _listener: EventListener): () => void;
    /**
     * Get _metrics for a component
     */
    getMetrics(component?: string, window?: number): TelemetryMetrics | ComponentMetrics;
    /**
     * Calculate _metrics for a component
     */
    private calculateMetrics;
    /**
     * Calculate _metrics for all _components
     */
    private calculateAllMetrics;
    /**
     * Calculate average
     */
    private calculateAverage;
    /**
     * Calculate percentile
     */
    private calculatePercentile;
    /**
     * Extract _error data
     */
    private extractErrorData;
    /**
     * Notify _listeners
     */
    private notifyListeners;
    /**
     * Log event for debugging
     */
    private logEvent;
    /**
     * Export _events for analysis
     */
    exportEvents(filter?: {
        component?: string;
        _startTime?: number;
        endTime?: number;
        event?: string | RegExp;
    }): TelemetryEvent[];
    /**
     * Clear all _events
     */
    clear(): void;
    /**
     * Get event _counts by type
     */
    getEventCounts(): Map<string, number>;
    /**
     * Generate summary _report
     */
    generateReport(window?: number): string;
}
export declare const telemetry: TelemetryCollector;
export {};