/**
 * Performance monitoring and optimization utilities for ProductBoard MCP server
 */
export interface PerformanceMetrics {
    requestId: string;
    operation: string;
    startTime: number;
    endTime?: number;
    duration?: number;
    cacheHit?: boolean;
    dataSize?: number;
    memoryUsage?: NodeJS.MemoryUsage;
    errorCount?: number;
    retryCount?: number;
}
export interface CacheEntry<T = unknown> {
    data: T;
    timestamp: number;
    ttl: number;
    accessCount: number;
    lastAccessed: number;
    size?: number;
}
export interface CacheStats {
    totalEntries: number;
    hitRate: number;
    memoryUsage: number;
    oldestEntry: number;
    newestEntry: number;
    averageAccessCount: number;
}
export interface ThrottleConfig {
    maxRequests: number;
    windowMs: number;
    skipSuccessfulRequests?: boolean;
    skipFailedRequests?: boolean;
    keyGenerator?: (operation: string, params?: unknown) => string;
}
export interface QueryOptimization {
    batchSize: number;
    concurrency: number;
    retryConfig: {
        maxRetries: number;
        backoffMs: number;
        exponential: boolean;
    };
    cacheConfig: {
        ttl: number;
        maxSize: number;
        strategy: 'LRU' | 'TTL' | 'FIFO';
    };
}
/**
 * Advanced caching system with intelligent TTL and memory management
 */
export declare class IntelligentCache<T = unknown> {
    private cache;
    private accessOrder;
    private maxSize;
    private defaultTtl;
    private strategy;
    private hitCount;
    private missCount;
    constructor(maxSize?: number, defaultTtl?: number, // 5 minutes
    strategy?: 'LRU' | 'TTL' | 'FIFO');
    /**
     * Get cached value with intelligent expiration
     */
    get(key: string): T | null;
    /**
     * Set cached value with dynamic TTL based on data characteristics
     */
    set(key: string, data: T, customTtl?: number): void;
    /**
     * Calculate dynamic TTL based on data characteristics
     */
    private calculateDynamicTtl;
    /**
     * Estimate data size for memory management
     */
    private estimateDataSize;
    /**
     * Evict entry based on strategy
     */
    private evictEntry;
    /**
     * Update access order for LRU strategy
     */
    private updateAccessOrder;
    /**
     * Remove key from access order array
     */
    private removeFromAccessOrder;
    /**
     * Get cache statistics
     */
    getStats(): CacheStats;
    /**
     * Clear expired entries
     */
    clearExpired(): number;
    /**
     * Clear all cached entries
     */
    clear(): void;
    /**
     * Get cache size
     */
    size(): number;
}
/**
 * Request throttling and rate limiting
 */
export declare class RequestThrottler {
    private requests;
    private config;
    constructor(config: ThrottleConfig);
    /**
     * Check if request should be throttled
     */
    shouldThrottle(operation: string, params?: unknown): boolean;
    /**
     * Record a request
     */
    recordRequest(operation: string, params?: unknown, wasSuccessful?: boolean): void;
    /**
     * Get throttle status for operation
     */
    getThrottleStatus(operation: string, params?: unknown): {
        isThrottled: boolean;
        requestCount: number;
        timeUntilReset: number;
    };
}
/**
 * Performance metrics collector
 */
export declare class PerformanceCollector {
    private metrics;
    private maxMetrics;
    constructor(maxMetrics?: number);
    /**
     * Start tracking a performance metric
     */
    start(operation: string, requestId?: string): PerformanceMetrics;
    /**
     * End tracking a performance metric
     */
    end(metric: PerformanceMetrics, success?: boolean): PerformanceMetrics;
    /**
     * Record cache hit/miss
     */
    recordCacheHit(metric: PerformanceMetrics, isHit: boolean): void;
    /**
     * Record data size
     */
    recordDataSize(metric: PerformanceMetrics, dataSize: number): void;
    /**
     * Record retry attempt
     */
    recordRetry(metric: PerformanceMetrics): void;
    /**
     * Get performance statistics
     */
    getStats(operation?: string): {
        totalRequests: number;
        averageDuration: number;
        cacheHitRate: number;
        errorRate: number;
        averageDataSize: number;
        percentiles: {
            p50: number;
            p90: number;
            p95: number;
            p99: number;
        };
    };
    /**
     * Calculate percentile
     */
    private percentile;
    /**
     * Generate unique request ID
     */
    private generateRequestId;
    /**
     * Clear old metrics
     */
    clearOldMetrics(olderThanMs?: number): number;
    /**
     * Get current metrics count
     */
    getMetricsCount(): number;
}
/**
 * Memory usage monitor
 */
export declare class MemoryMonitor {
    private measurements;
    private maxMeasurements;
    constructor(maxMeasurements?: number);
    /**
     * Record current memory usage
     */
    recordUsage(): NodeJS.MemoryUsage;
    /**
     * Get memory usage statistics
     */
    getStats(): {
        current: NodeJS.MemoryUsage;
        peak: {
            rss: number;
            heapTotal: number;
            heapUsed: number;
            external: number;
        };
        average: {
            rss: number;
            heapTotal: number;
            heapUsed: number;
            external: number;
        };
        trend: 'increasing' | 'decreasing' | 'stable';
    };
    /**
     * Calculate memory usage trend
     */
    private calculateTrend;
    /**
     * Check if memory usage is critical
     */
    isCritical(thresholdMB?: number): boolean;
    /**
     * Force garbage collection if available
     */
    forceGC(): boolean;
}
export declare const performanceCollector: PerformanceCollector;
export declare const memoryMonitor: MemoryMonitor;
export declare const globalCache: IntelligentCache<unknown>;
export declare const defaultThrottleConfig: ThrottleConfig;
export declare const aggressiveThrottleConfig: ThrottleConfig;