/** Scalable Database Utilities */
import { EventEmitter } from 'events';
export interface DatabaseConfig {
    host: string;
    port?: number;
    database: string;
    username?: string;
    password?: string;
    maxConnections?: number;
    minConnections?: number;
    acquireTimeout?: number;
    idleTimeout?: number;
    queryTimeout?: number;
    enableQueryCache?: boolean;
    cacheMaxSize?: number;
    cacheTtlMs?: number;
}
export interface QueryOptions {
    timeout?: number;
    cache?: boolean;
    cacheKey?: string;
    retries?: number;
    limit?: number;
    offset?: number;
    batchSize?: number;
}
export interface QueryResult<T = any> {
    rows: T[];
    rowCount: number;
    duration: number;
    cached: boolean;
    hasMore?: boolean;
    nextOffset?: number;
    totalRows?: number;
}
export interface DatabaseMetrics {
    totalQueries: number;
    cachedQueries: number;
    failedQueries: number;
    averageQueryTime: number;
    activeConnections: number;
    connectionPoolHits: number;
    connectionPoolMisses: number;
    truncatedQueries: number;
}
/**
 * Scalable Database Client with connection pooling and query caching
 */
export declare class ScalableDatabaseClient extends EventEmitter {
    private config;
    private connectionPool;
    private activeConnections;
    private waitingQueue;
    private readonly maxQueueSize;
    private readonly maxResultRows;
    private readonly maxBatchSize;
    private isShutdown;
    private queryCache;
    private cacheMaxSize;
    private cacheTtlMs;
    private cleanupInterval?;
    private queryPatterns;
    private readonly maxQueryPatterns;
    private queryComplexityThresholds;
    private indexSuggestions;
    private fieldUsageStats;
    private readonly maxIndexSuggestions;
    private readonly indexAnalysisInterval;
    private indexAnalysisIntervalId?;
    private metrics;
    constructor(config: DatabaseConfig);
    /**
     * Execute a query with caching, retry logic, and pagination support
     */
    query<T = any>(sql: string, params?: any[], options?: QueryOptions): Promise<QueryResult<T>>;
    /**
     * Apply pagination limits to prevent memory exhaustion
     */
    private applyPaginationLimits;
    /**
     * Process query result with pagination and memory management
     */
    private processQueryResult;
    /**
     * Get total row count for paginated queries
     */
    private getTotalCount;
    /**
     * Execute paginated query to get all results efficiently
     */
    queryAll<T = any>(sql: string, params?: any[], options?: QueryOptions): Promise<QueryResult<T>>;
    /**
     * Execute multiple queries in a transaction
     */
    transaction<T>(queries: Array<{
        sql: string;
        params?: any[];
    }>): Promise<QueryResult<T>[]>;
    /**
     * Batch execute the same query with multiple parameter sets
     */
    batchQuery<T = any>(sql: string, paramsList: any[][], options?: QueryOptions): Promise<QueryResult<T>[]>;
    private executeQueryWithRetry;
    private executeSingleQuery;
    private acquireConnection;
    private releaseConnection;
    private createConnection;
    private initializeConnectionPool;
    private generateCacheKey;
    private getFromCache;
    private setCache;
    private startCacheCleanup;
    private updateAverageQueryTime;
    /**
     * Cleanup old query patterns to prevent memory leaks
     */
    private cleanupQueryPatterns;
    /**
     * Evict least recently used cache entries
     */
    private evictLeastRecentlyUsed;
    private isNonRetryableError;
    private beginTransaction;
    private commitTransaction;
    private rollbackTransaction;
    /**
     * Get current database metrics
     */
    getMetrics(): DatabaseMetrics;
    /**
     * Clear query cache
     */
    clearCache(): void;
    /**
     * Get cache statistics
     */
    getCacheStats(): {
        size: number;
        hitRate: number;
    };
    /**
     * Get current memory pressure (0-1 scale)
     */
    private getMemoryPressure;
    /**
     * Calculate adaptive result limit based on conditions
     */
    private calculateAdaptiveResultLimit;
    /**
     * Generate detailed truncation warning
     */
    private generateTruncationWarning;
    /**
     * Get truncation recommendation based on analysis
     */
    private getTruncationRecommendation;
    /**
     * Analyze query patterns for optimization
     */
    private analyzeQueryPattern;
    /**
     * Analyze field usage for index optimization
     */
    private analyzeFieldUsage;
    /**
     * Extract field names from SQL clause
     */
    private extractFieldNames;
    /**
     * Increment field usage statistics
     */
    private incrementFieldUsage;
    /**
     * Start periodic index analysis
     */
    private startIndexAnalysis;
    /**
     * Perform index analysis and generate suggestions
     */
    private performIndexAnalysis;
    /**
     * Calculate index score based on field usage statistics
     */
    private calculateIndexScore;
    /**
     * Find composite index opportunities
     */
    private findCompositeIndexOpportunities;
    /**
     * Get current index suggestions
     */
    getIndexSuggestions(): Array<{
        fields: string[];
        score: number;
        recommendation: string;
    }>;
    /**
     * Get field usage statistics for monitoring
     */
    getFieldUsageStats(): Record<string, {
        selectCount: number;
        whereCount: number;
        joinCount: number;
        orderByCount: number;
    }>;
    /**
     * Close all connections and cleanup
     */
    close(): Promise<void>;
}
/**
 * Create a scalable database client
 */
export declare function createScalableDatabaseClient(config: DatabaseConfig): ScalableDatabaseClient;
export default ScalableDatabaseClient;
//# sourceMappingURL=scalableDatabase.d.ts.map