/**
 * Performance Optimizations for Code Generation
 * Implements caching, lazy-loading, and parallel generation
 */
export interface IGenerationCache {
    get(type: string, params: Record<string, unknown>): Promise<string | null>;
    set(type: string, params: Record<string, unknown>, code: string): Promise<void>;
    save(): Promise<void>;
    clear(): Promise<void>;
    dispose(): Promise<void>;
    getStats(): Promise<{
        size: number;
        entries: number;
        diskUsage: string;
        keys: string[];
    }>;
}
/**
 * Generation Cache - Cache generated code to avoid re-generating identical code
 * Sealed namespace for immutability
 */
export declare const GenerationCache: Readonly<{
    /**
     * Create a new generation cache instance
     */
    create(cacheDir?: string, ttlMs?: number, maxEntries?: number): IGenerationCache;
}>;
export interface ILazyLoader {
    load<T>(modulePath: string): Promise<T>;
    preload(modulePaths: string[]): Promise<void>;
    clear(): void;
}
/**
 * Lazy Module Loader - Load dependencies only when needed
 * Sealed namespace for immutability
 */
export declare const LazyLoader: Readonly<{
    /**
     * Create a new lazy loader instance
     */
    create(): ILazyLoader;
}>;
/**
 * Parallel Generator - Run multiple generators in parallel
 */
/**
 * Run generators in parallel batches
 */
export declare function runBatch<T>(generators: Array<() => Promise<T>>, batchSize?: number): Promise<T[]>;
/**
 * Run all generators in parallel
 */
export declare function runAll<T>(generators: Array<() => Promise<T>>): Promise<T[]>;
export declare const ParallelGenerator: Readonly<{
    runBatch: typeof runBatch;
    runAll: typeof runAll;
}>;
/**
 * Memoize - Cache function results based on arguments
 */
/**
 * Create a memoized version of a function
 */
export declare function createMemoized<T extends (...args: any[]) => any>(fn: T, options?: {
    ttl?: number;
    keyGenerator?: (args: Parameters<T>) => string;
    maxSize?: number;
}): T;
export declare const Memoize: Readonly<{
    create: typeof createMemoized;
}>;
export interface IPerformanceOptimizer {
    generateWithCache<T>(type: string, params: Record<string, unknown>, generatorFn: () => Promise<T>): Promise<T>;
    generateInParallel<T>(generators: Array<() => Promise<T>>, batchSize?: number): Promise<T[]>;
    preloadModules(paths: string[]): Promise<void>;
    getStats(): {
        cacheHits: number;
        cacheMisses: number;
        hitRate: string;
        parallelRuns: number;
        estimatedSavedTime: string;
        cacheStatus: {
            size: number;
            keys: string[];
        };
    };
    saveCache(): void;
    clear(): void;
}
/**
 * Performance Optimizer - Wrapper for optimizations
 * Sealed namespace for immutability
 */
export declare const PerformanceOptimizer: Readonly<{
    /**
     * Create a new performance optimizer instance
     */
    create(): IPerformanceOptimizer;
}>;
export default PerformanceOptimizer;
//# sourceMappingURL=Optimizer.d.ts.map