typekro 0.2.2 → 0.3.0

package/dist/core/expressions/lazy-analysis.d.ts

@@ -0,0 +1,1128 @@
+/**
+ * Lazy Analysis Support for JavaScript to CEL Expression Conversion
+ *
+ * This module provides lazy evaluation capabilities for expressions containing
+ * KubernetesRef objects, optimizing performance by deferring analysis until
+ * the results are actually needed.
+ */
+import type { KubernetesRef, CelExpression } from '../types/common.js';
+import type { AnalysisContext, CelConversionResult } from './analyzer.js';
+import { JavaScriptToCelAnalyzer } from './analyzer.js';
+import { ConversionError } from '../errors.js';
+/**
+ * Lazy wrapper for expressions that may contain KubernetesRef objects
+ * Defers analysis until the CEL expression is actually needed
+ */
+export declare class LazyAnalyzedExpression {
+    private readonly _expression;
+    private readonly _context;
+    private _analyzed;
+    private _result;
+    private _error;
+    private readonly _analyzer;
+    constructor(_expression: any, _context: AnalysisContext, analyzer?: JavaScriptToCelAnalyzer);
+    /**
+     * Get the original expression without triggering analysis
+     */
+    get originalExpression(): any;
+    /**
+     * Get the analysis context
+     */
+    get context(): AnalysisContext;
+    /**
+     * Check if the expression has been analyzed yet
+     */
+    get isAnalyzed(): boolean;
+    /**
+     * Check if the expression requires conversion (contains KubernetesRef objects)
+     * This is a fast check that doesn't trigger full analysis
+     */
+    get requiresConversion(): boolean;
+    /**
+     * Check if the expression is static (no KubernetesRef objects)
+     * This is a fast check that doesn't trigger analysis
+     */
+    get isStatic(): boolean;
+    /**
+     * Get the analysis result, triggering analysis if not already done
+     */
+    get result(): CelConversionResult;
+    /**
+     * Get the CEL expression, triggering analysis if needed
+     */
+    get celExpression(): CelExpression | null;
+    /**
+     * Get the dependencies, triggering analysis if needed
+     */
+    get dependencies(): KubernetesRef<any>[];
+    /**
+     * Get conversion errors, triggering analysis if needed
+     */
+    get errors(): ConversionError[];
+    /**
+     * Check if the analysis was successful, triggering analysis if needed
+     */
+    get isValid(): boolean;
+    /**
+     * Force analysis to occur immediately
+     */
+    analyze(): CelConversionResult;
+    /**
+     * Try to get the result without throwing errors
+     */
+    tryGetResult(): {
+        success: boolean;
+        result?: CelConversionResult;
+        error?: Error;
+    };
+    /**
+     * Create a new lazy expression with a different context
+     */
+    withContext(newContext: AnalysisContext): LazyAnalyzedExpression;
+    /**
+     * Create a new lazy expression with a different analyzer
+     */
+    withAnalyzer(analyzer: JavaScriptToCelAnalyzer): LazyAnalyzedExpression;
+    /**
+     * Perform the actual analysis
+     */
+    private _performAnalysis;
+    /**
+     * Reset the analysis state (for testing or re-analysis)
+     */
+    reset(): void;
+    /**
+     * Get a string representation for debugging
+     */
+    toString(): string;
+}
+/**
+ * Collection of lazy analyzed expressions for batch processing
+ */
+export declare class LazyExpressionCollection {
+    private readonly _expressions;
+    private readonly _analyzer;
+    constructor(analyzer?: JavaScriptToCelAnalyzer);
+    /**
+     * Add an expression to the collection
+     */
+    add(key: string, expression: any, context: AnalysisContext): LazyAnalyzedExpression;
+    /**
+     * Get a lazy expression by key
+     */
+    get(key: string): LazyAnalyzedExpression | undefined;
+    /**
+     * Check if an expression exists
+     */
+    has(key: string): boolean;
+    /**
+     * Remove an expression
+     */
+    remove(key: string): boolean;
+    /**
+     * Get all expression keys
+     */
+    keys(): string[];
+    /**
+     * Get all lazy expressions
+     */
+    values(): LazyAnalyzedExpression[];
+    /**
+     * Get all entries
+     */
+    entries(): [string, LazyAnalyzedExpression][];
+    /**
+     * Get the number of expressions
+     */
+    get size(): number;
+    /**
+     * Check how many expressions require conversion
+     */
+    get requiresConversionCount(): number;
+    /**
+     * Check how many expressions are static
+     */
+    get staticCount(): number;
+    /**
+     * Check how many expressions have been analyzed
+     */
+    get analyzedCount(): number;
+    /**
+     * Analyze all expressions that require conversion
+     */
+    analyzeAll(): Map<string, CelConversionResult>;
+    /**
+     * Analyze expressions in parallel (for independent expressions)
+     */
+    analyzeAllParallel(): Promise<Map<string, CelConversionResult>>;
+    /**
+     * Get statistics about the collection
+     */
+    getStats(): LazyCollectionStats;
+    /**
+     * Clear all expressions
+     */
+    clear(): void;
+    /**
+     * Reset analysis state for all expressions
+     */
+    resetAll(): void;
+}
+/**
+ * Statistics about a lazy expression collection
+ */
+export interface LazyCollectionStats {
+    /** Total number of expressions */
+    total: number;
+    /** Number of expressions that require conversion */
+    requiresConversion: number;
+    /** Number of static expressions (no conversion needed) */
+    static: number;
+    /** Number of expressions that have been analyzed */
+    analyzed: number;
+    /** Number of expressions pending analysis */
+    pending: number;
+    /** Ratio of expressions requiring conversion (0-1) */
+    conversionRatio: number;
+    /** Analysis progress for expressions requiring conversion (0-1) */
+    analysisProgress: number;
+}
+/**
+ * Factory function to create lazy analyzed expressions
+ */
+export declare function createLazyExpression(expression: any, context: AnalysisContext, analyzer?: JavaScriptToCelAnalyzer): LazyAnalyzedExpression;
+/**
+ * Factory function to create lazy expression collections
+ */
+export declare function createLazyCollection(analyzer?: JavaScriptToCelAnalyzer): LazyExpressionCollection;
+/**
+ * On-demand expression analyzer that performs KubernetesRef detection and analysis
+ * only when results are actually needed
+ */
+export declare class OnDemandExpressionAnalyzer {
+    private readonly _analyzer;
+    private readonly _cache;
+    private _cacheHits;
+    private _cacheMisses;
+    constructor(analyzer?: JavaScriptToCelAnalyzer);
+    /**
+     * Create a lazy expression that will be analyzed on-demand
+     */
+    createLazyExpression(expression: any, context: AnalysisContext, cacheKey?: string): LazyAnalyzedExpression;
+    /**
+     * Analyze an expression immediately if it contains KubernetesRef objects,
+     * otherwise return it as-is
+     */
+    analyzeIfNeeded(expression: any, context: AnalysisContext): {
+        needsConversion: boolean;
+        result: any;
+        lazy?: LazyAnalyzedExpression;
+    };
+    /**
+     * Batch analyze multiple expressions, only processing those that need conversion
+     */
+    batchAnalyze(expressions: Array<{
+        key: string;
+        expression: any;
+        context: AnalysisContext;
+    }>): Map<string, {
+        needsConversion: boolean;
+        result: any;
+        lazy?: LazyAnalyzedExpression;
+    }>;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        hits: number;
+        misses: number;
+        size: number;
+        hitRatio: number;
+    };
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+    /**
+     * Generate a cache key for an expression and context
+     */
+    private _generateCacheKey;
+}
+/**
+ * Expression tree analyzer for complex nested expressions with KubernetesRef objects
+ */
+export declare class ExpressionTreeAnalyzer {
+    private readonly _onDemandAnalyzer;
+    constructor(analyzer?: JavaScriptToCelAnalyzer);
+    /**
+     * Analyze a complex expression tree, creating lazy expressions for branches
+     * that contain KubernetesRef objects
+     */
+    analyzeTree(expressionTree: any, context: AnalysisContext, path?: string[]): ExpressionTreeResult;
+    /**
+     * Get all lazy expressions from a tree result
+     */
+    getAllLazyExpressions(treeResult: ExpressionTreeResult): LazyAnalyzedExpression[];
+    /**
+     * Get statistics about the expression tree
+     */
+    getTreeStats(treeResult: ExpressionTreeResult): ExpressionTreeStats;
+    /**
+     * Check if a value is a primitive type
+     */
+    private _isPrimitive;
+}
+/**
+ * Result of analyzing an expression tree
+ */
+export interface ExpressionTreeResult {
+    /** Path to this node in the tree */
+    path: string[];
+    /** Whether this node or its children need conversion */
+    needsConversion: boolean;
+    /** Static value if no conversion is needed */
+    staticValue: any;
+    /** Lazy expression if conversion is needed */
+    lazyExpression: LazyAnalyzedExpression | null;
+    /** Child nodes */
+    children: Map<string, ExpressionTreeResult>;
+}
+/**
+ * Statistics about an expression tree
+ */
+export interface ExpressionTreeStats {
+    /** Total number of nodes in the tree */
+    totalNodes: number;
+    /** Number of nodes that need lazy analysis */
+    lazyNodes: number;
+    /** Number of static nodes */
+    staticNodes: number;
+    /** Maximum depth of the tree */
+    maxDepth: number;
+    /** Ratio of lazy nodes to total nodes */
+    lazyRatio: number;
+}
+/**
+ * Global on-demand analyzer instance
+ */
+export declare const globalOnDemandAnalyzer: OnDemandExpressionAnalyzer;
+/**
+ * Lazy loading manager for complex expression trees with magic proxy integration
+ */
+export declare class LazyExpressionTreeLoader {
+    private readonly _treeAnalyzer;
+    private readonly _loadedTrees;
+    private readonly _loadingPromises;
+    private _loadCount;
+    constructor(analyzer?: JavaScriptToCelAnalyzer);
+    /**
+     * Load an expression tree lazily, returning immediately with a promise
+     */
+    loadTree(expressionTree: any, context: AnalysisContext, treeId?: string): Promise<ExpressionTreeResult>;
+    /**
+     * Load multiple trees in parallel
+     */
+    loadTrees(trees: Array<{
+        tree: any;
+        context: AnalysisContext;
+        id?: string;
+    }>): Promise<Map<string, ExpressionTreeResult>>;
+    /**
+     * Get a tree if it's already loaded, otherwise return null
+     */
+    getLoadedTree(treeId: string): ExpressionTreeResult | null;
+    /**
+     * Check if a tree is currently being loaded
+     */
+    isLoading(treeId: string): boolean;
+    /**
+     * Check if a tree is loaded
+     */
+    isLoaded(treeId: string): boolean;
+    /**
+     * Preload trees that are likely to be needed soon
+     */
+    preloadTrees(trees: Array<{
+        tree: any;
+        context: AnalysisContext;
+        id?: string;
+        priority?: number;
+    }>): Promise<void>;
+    /**
+     * Get loading statistics
+     */
+    getStats(): LazyTreeLoaderStats;
+    /**
+     * Clear loaded trees to free memory
+     */
+    clearCache(): void;
+    /**
+     * Perform the actual tree loading
+     */
+    private _performTreeLoad;
+    /**
+     * Generate a unique ID for a tree
+     */
+    private _generateTreeId;
+    /**
+     * Estimate memory usage of loaded trees
+     */
+    private _estimateMemoryUsage;
+    /**
+     * Estimate the size of a tree result
+     */
+    private _estimateTreeSize;
+}
+/**
+ * Magic proxy integration for lazy expression loading
+ */
+export declare class MagicProxyLazyIntegration {
+    private readonly _treeLoader;
+    private readonly _proxyCache;
+    constructor(analyzer?: JavaScriptToCelAnalyzer);
+    /**
+     * Create a lazy proxy for a complex object that may contain KubernetesRef objects
+     */
+    createLazyProxy<T extends object>(target: T, context: AnalysisContext, options?: LazyProxyOptions): T;
+    /**
+     * Load expression trees for all KubernetesRef-containing values in an object
+     */
+    preloadObjectTrees(obj: any, context: AnalysisContext, maxDepth?: number): Promise<void>;
+    /**
+     * Get statistics about the magic proxy integration
+     */
+    getStats(): MagicProxyIntegrationStats;
+    /**
+     * Clear all caches
+     */
+    clearCaches(): void;
+    /**
+     * Create a lazy value wrapper
+     */
+    private _createLazyValue;
+    /**
+     * Check if a value is simple (not an object or array)
+     */
+    private _isSimpleValue;
+    /**
+     * Generate a unique ID for a proxy
+     */
+    private _generateProxyId;
+    /**
+     * Invalidate cache entries related to a proxy
+     */
+    private _invalidateCache;
+    /**
+     * Collect trees from an object recursively
+     */
+    private _collectTreesFromObject;
+}
+/**
+ * Options for creating lazy proxies
+ */
+export interface LazyProxyOptions {
+    /** Unique identifier for the proxy */
+    id?: string;
+    /** Maximum depth to traverse for preloading */
+    maxDepth?: number;
+    /** Whether to preload trees immediately */
+    preload?: boolean;
+}
+/**
+ * Statistics about lazy tree loading
+ */
+export interface LazyTreeLoaderStats {
+    /** Number of loaded trees */
+    loadedTrees: number;
+    /** Number of trees currently loading */
+    loadingTrees: number;
+    /** Total number of load operations */
+    totalLoads: number;
+    /** Estimated memory usage in bytes */
+    memoryUsage: number;
+}
+/**
+ * Statistics about magic proxy integration
+ */
+export interface MagicProxyIntegrationStats {
+    /** Number of cached proxies */
+    cachedProxies: number;
+    /** Tree loader statistics */
+    treeLoaderStats: LazyTreeLoaderStats;
+}
+/**
+ * Global lazy tree loader instance
+ */
+export declare const globalLazyTreeLoader: LazyExpressionTreeLoader;
+/**
+ * Memory-optimized expression manager for large sets of KubernetesRef-containing expressions
+ */
+export declare class MemoryOptimizedExpressionManager {
+    private readonly _expressions;
+    private readonly _expressionSizes;
+    private readonly _accessTimes;
+    private readonly _analyzer;
+    private _totalMemoryUsage;
+    private _maxMemoryUsage;
+    private _cleanupThreshold;
+    private _lastCleanup;
+    constructor(analyzer?: JavaScriptToCelAnalyzer, options?: MemoryOptimizationOptions);
+    /**
+     * Create or retrieve a lazy expression with memory management
+     */
+    getOrCreateExpression(key: string, expression: any, context: AnalysisContext): LazyAnalyzedExpression;
+    /**
+     * Batch create expressions with memory optimization
+     */
+    batchCreateExpressions(expressions: Array<{
+        key: string;
+        expression: any;
+        context: AnalysisContext;
+    }>): Map<string, LazyAnalyzedExpression>;
+    /**
+     * Get memory usage statistics
+     */
+    getMemoryStats(): MemoryStats;
+    /**
+     * Force cleanup of unused expressions
+     */
+    forceCleanup(): MemoryCleanupResult;
+    /**
+     * Set memory limits
+     */
+    setMemoryLimits(maxMemoryUsage: number, cleanupThreshold: number): void;
+    /**
+     * Clear all expressions
+     */
+    clear(): void;
+    /**
+     * Get expressions that are likely to be garbage collected soon
+     */
+    getExpiringExpressions(): string[];
+    /**
+     * Estimate the memory size of an expression
+     */
+    private _estimateExpressionSize;
+    /**
+     * Check if cleanup is needed
+     */
+    private _shouldCleanup;
+    /**
+     * Perform memory cleanup
+     */
+    private _performCleanup;
+    /**
+     * Clean up dead weak references
+     */
+    private _cleanupDeadReferences;
+    /**
+     * Clean up least recently used expressions
+     */
+    private _cleanupLRU;
+    /**
+     * Clean up a single expression
+     */
+    private _cleanupExpression;
+}
+/**
+ * Advanced parallel expression analyzer for independent expressions with KubernetesRef objects
+ */
+export declare class ParallelExpressionAnalyzer {
+    private readonly _analyzer;
+    private readonly _maxConcurrency;
+    private readonly _detector;
+    private _activeAnalyses;
+    private _totalAnalyses;
+    private _completedAnalyses;
+    private _failedAnalyses;
+    constructor(analyzer?: JavaScriptToCelAnalyzer, maxConcurrency?: number, detector?: OptimizedKubernetesRefDetector);
+    /**
+     * Analyze multiple expressions in parallel with advanced scheduling
+     */
+    analyzeParallel(expressions: Array<{
+        key: string;
+        expression: any;
+        context: AnalysisContext;
+    }>): Promise<Map<string, CelConversionResult>>;
+    /**
+     * Analyze expressions with priority-based scheduling and dependency resolution
+     */
+    analyzePrioritized(expressions: Array<{
+        key: string;
+        expression: any;
+        context: AnalysisContext;
+        priority: number;
+        dependencies?: string[];
+    }>): Promise<Map<string, CelConversionResult>>;
+    /**
+     * Analyze expressions with adaptive concurrency based on system load
+     */
+    analyzeAdaptive(expressions: Array<{
+        key: string;
+        expression: any;
+        context: AnalysisContext;
+    }>, options?: AdaptiveAnalysisOptions): Promise<Map<string, CelConversionResult>>;
+    /**
+     * Stream analysis results as they complete
+     */
+    analyzeStream(expressions: Array<{
+        key: string;
+        expression: any;
+        context: AnalysisContext;
+    }>): AsyncGenerator<{
+        key: string;
+        result: CelConversionResult;
+        progress: number;
+    }>;
+    /**
+     * Get comprehensive analysis statistics
+     */
+    getStats(): AdvancedParallelAnalysisStats;
+    /**
+     * Create work queue with complexity analysis
+     */
+    private _createWorkQueue;
+    /**
+     * Process work queue in parallel
+     */
+    private _processWorkQueue;
+    /**
+     * Process a batch of work items
+     */
+    private _processBatch;
+    /**
+     * Build dependency graph for expressions
+     */
+    private _buildDependencyGraph;
+    /**
+     * Topological sort for dependency resolution
+     */
+    private _topologicalSort;
+    /**
+     * Group expressions by priority
+     */
+    private _groupByPriority;
+    /**
+     * Calculate expression complexity
+     */
+    private _calculateComplexity;
+    /**
+     * Create batches for parallel processing
+     */
+    private _createBatches;
+}
+/**
+ * Options for adaptive analysis
+ */
+export interface AdaptiveAnalysisOptions {
+    /** Initial concurrency level */
+    initialConcurrency?: number;
+    /** Maximum concurrency level */
+    maxConcurrency?: number;
+    /** Minimum concurrency level */
+    minConcurrency?: number;
+    /** Interval for adaptation in milliseconds */
+    adaptationInterval?: number;
+    /** Performance threshold in milliseconds */
+    performanceThreshold?: number;
+}
+/**
+ * Advanced parallel analysis statistics
+ */
+export interface AdvancedParallelAnalysisStats extends ParallelAnalysisStats {
+    /** Total number of analyses started */
+    totalAnalyses: number;
+    /** Number of completed analyses */
+    completedAnalyses: number;
+    /** Number of failed analyses */
+    failedAnalyses: number;
+    /** Success rate (0-1) */
+    successRate: number;
+    /** Detector cache statistics */
+    detectorStats: {
+        hits: number;
+        misses: number;
+        hitRatio: number;
+        size: number;
+    };
+}
+/**
+ * Memory optimization options
+ */
+export interface MemoryOptimizationOptions {
+    /** Maximum memory usage in bytes */
+    maxMemoryUsage?: number;
+    /** Cleanup threshold (0-1) */
+    cleanupThreshold?: number;
+}
+/**
+ * Memory usage statistics
+ */
+export interface MemoryStats {
+    /** Total number of expressions */
+    totalExpressions: number;
+    /** Total memory usage in bytes */
+    totalMemoryUsage: number;
+    /** Maximum allowed memory usage */
+    maxMemoryUsage: number;
+    /** Memory utilization ratio (0-1) */
+    memoryUtilization: number;
+    /** Average expression size in bytes */
+    averageExpressionSize: number;
+    /** Timestamp of last cleanup */
+    lastCleanup: number;
+    /** Whether cleanup is needed */
+    needsCleanup: boolean;
+}
+/**
+ * Memory cleanup result
+ */
+export interface MemoryCleanupResult {
+    /** Cleanup duration in milliseconds */
+    duration: number;
+    /** Initial memory usage */
+    initialMemoryUsage: number;
+    /** Final memory usage */
+    finalMemoryUsage: number;
+    /** Amount of memory freed */
+    freedMemory: number;
+    /** Initial expression count */
+    initialExpressionCount: number;
+    /** Final expression count */
+    finalExpressionCount: number;
+    /** Number of expressions cleaned */
+    cleanedExpressions: number;
+}
+/**
+ * Parallel analysis statistics
+ */
+export interface ParallelAnalysisStats {
+    /** Maximum concurrency level */
+    maxConcurrency: number;
+    /** Currently active analyses */
+    activeAnalyses: number;
+    /** Utilization ratio (0-1) */
+    utilizationRatio: number;
+}
+/**
+ * Global memory-optimized expression manager
+ */
+export declare const globalMemoryOptimizedManager: MemoryOptimizedExpressionManager;
+/**
+ * Performance profiler for expression analysis with KubernetesRef detection
+ */
+export declare class ExpressionAnalysisProfiler {
+    private readonly _profiles;
+    private readonly _analyzer;
+    private _enabled;
+    constructor(analyzer?: JavaScriptToCelAnalyzer);
+    /**
+     * Enable or disable profiling
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Profile expression analysis performance
+     */
+    profileExpression(expression: any, context: AnalysisContext, profileId?: string): {
+        result: CelConversionResult;
+        profile: PerformanceProfile;
+    };
+    /**
+     * Profile multiple expressions in batch
+     */
+    profileBatch(expressions: Array<{
+        expression: any;
+        context: AnalysisContext;
+        id?: string;
+    }>): Map<string, {
+        result: CelConversionResult;
+        profile: PerformanceProfile;
+    }>;
+    /**
+     * Get performance statistics
+     */
+    getStats(): PerformanceStats;
+    /**
+     * Get profiles that exceed performance thresholds
+     */
+    getSlowProfiles(durationThreshold?: number): PerformanceProfile[];
+    /**
+     * Get profiles with high KubernetesRef detection overhead
+     */
+    getHighOverheadProfiles(overheadThreshold?: number): PerformanceProfile[];
+    /**
+     * Clear all profiles
+     */
+    clearProfiles(): void;
+    /**
+     * Export profiles for analysis
+     */
+    exportProfiles(): PerformanceProfile[];
+    /**
+     * Generate a profile ID
+     */
+    private _generateProfileId;
+    /**
+     * Calculate expression complexity score
+     */
+    private _calculateComplexity;
+    /**
+     * Estimate memory usage
+     */
+    private _estimateMemoryUsage;
+}
+/**
+ * Performance profile for an expression analysis
+ */
+export interface PerformanceProfile {
+    /** Unique profile ID */
+    id: string;
+    /** Original expression */
+    expression: string;
+    /** Start time (performance.now()) */
+    startTime: number;
+    /** End time (performance.now()) */
+    endTime: number;
+    /** Total duration in milliseconds */
+    duration: number;
+    /** Time spent on KubernetesRef detection */
+    kubernetesRefDetectionTime: number;
+    /** Time spent on AST parsing */
+    astParsingTime: number;
+    /** Time spent on CEL generation */
+    celGenerationTime: number;
+    /** Estimated memory usage in bytes */
+    memoryUsage: number;
+    /** Number of KubernetesRef objects found */
+    kubernetesRefCount: number;
+    /** Expression complexity score */
+    expressionComplexity: number;
+    /** Whether this was a cache hit */
+    cacheHit: boolean;
+}
+/**
+ * Performance statistics
+ */
+export interface PerformanceStats {
+    /** Total number of profiles */
+    totalProfiles: number;
+    /** Average analysis duration */
+    averageDuration: number;
+    /** Average KubernetesRef detection time */
+    averageKubernetesRefDetectionTime: number;
+    /** Average CEL generation time */
+    averageCelGenerationTime: number;
+    /** Average memory usage */
+    averageMemoryUsage: number;
+    /** Average KubernetesRef count */
+    averageKubernetesRefCount: number;
+    /** Average complexity score */
+    averageComplexity: number;
+    /** Slowest expression profile */
+    slowestExpression: PerformanceProfile | null;
+    /** Fastest expression profile */
+    fastestExpression: PerformanceProfile | null;
+    /** Most complex expression profile */
+    mostComplexExpression: PerformanceProfile | null;
+    /** Cache hit ratio (0-1) */
+    cacheHitRatio: number;
+}
+/**
+ * Optimized KubernetesRef detector with caching and fast paths
+ */
+export declare class OptimizedKubernetesRefDetector {
+    private readonly _cache;
+    private readonly _refCache;
+    private _cacheHits;
+    private _cacheMisses;
+    private _maxCacheSize;
+    /**
+     * Fast detection of KubernetesRef objects with caching
+     */
+    containsKubernetesRefs(value: unknown, useCache?: boolean): boolean;
+    /**
+     * Extract KubernetesRef objects with optimized traversal
+     */
+    extractKubernetesRefs(value: unknown, useCache?: boolean): KubernetesRef<any>[];
+    /**
+     * Optimized traversal that stops early when possible
+     */
+    traverseOptimized(value: unknown, callback: (value: unknown, path: string[]) => boolean | undefined, path?: string[], maxDepth?: number): boolean;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        hits: number;
+        misses: number;
+        hitRatio: number;
+        size: number;
+    };
+    /**
+     * Clear caches
+     */
+    clearCache(): void;
+    /**
+     * Set maximum cache size
+     */
+    setMaxCacheSize(size: number): void;
+    /**
+     * Uncached KubernetesRef detection with optimizations
+     */
+    private _containsKubernetesRefsUncached;
+    /**
+     * Uncached KubernetesRef extraction with optimizations
+     */
+    private _extractKubernetesRefsUncached;
+    /**
+     * Generate cache key for a value
+     */
+    private _generateCacheKey;
+    /**
+     * Simple hash function for cache keys
+     */
+    private _simpleHash;
+    /**
+     * Fast primitive check
+     */
+    private _isPrimitive;
+    /**
+     * Fast KubernetesRef check
+     */
+    isKubernetesRef(value: unknown): boolean;
+}
+/**
+ * Optimized expression traverser for complex nested structures
+ */
+export declare class OptimizedExpressionTraverser {
+    private readonly _detector;
+    private readonly _visitedObjects;
+    constructor(detector?: OptimizedKubernetesRefDetector);
+    /**
+     * Traverse expression tree with cycle detection and optimization
+     */
+    traverse(expression: any, visitor: (value: any, path: string[], context: TraversalContext) => TraversalAction, options?: TraversalOptions): TraversalResult;
+    /**
+     * Find all KubernetesRef objects efficiently
+     */
+    findAllKubernetesRefs(expression: any, maxDepth?: number): KubernetesRef<any>[];
+    /**
+     * Check if expression contains KubernetesRefs efficiently
+     */
+    hasKubernetesRefs(expression: any, maxDepth?: number): boolean;
+}
+/**
+ * Traversal action returned by visitor functions
+ */
+export declare enum TraversalAction {
+    /** Continue normal traversal */
+    CONTINUE = "continue",
+    /** Skip this subtree */
+    SKIP = "skip",
+    /** Stop entire traversal */
+    STOP = "stop"
+}
+/**
+ * Context provided to traversal visitors
+ */
+export interface TraversalContext {
+    /** Current depth in the tree */
+    depth: number;
+    /** Whether the current value is a KubernetesRef */
+    isKubernetesRef: boolean;
+    /** Whether the current value contains KubernetesRefs */
+    hasKubernetesRefs: boolean;
+    /** Path to the current value */
+    path: string[];
+}
+/**
+ * Options for expression traversal
+ */
+export interface TraversalOptions {
+    /** Maximum depth to traverse */
+    maxDepth?: number;
+    /** Whether to detect and skip cycles */
+    detectCycles?: boolean;
+    /** Whether to skip duplicate objects */
+    skipDuplicates?: boolean;
+    /** Whether to enable early termination */
+    earlyTermination?: boolean;
+}
+/**
+ * Result of expression traversal
+ */
+export interface TraversalResult {
+    /** Number of nodes visited */
+    visited: number;
+    /** Number of nodes skipped */
+    skipped: number;
+    /** KubernetesRef objects found */
+    kubernetesRefs: KubernetesRef<any>[];
+    /** Whether maximum depth was reached */
+    maxDepthReached: boolean;
+    /** Number of cycles detected */
+    cyclesDetected: number;
+    /** Number of duplicates skipped */
+    duplicatesSkipped: number;
+}
+/**
+ * Global optimized KubernetesRef detector
+ */
+export declare const globalOptimizedDetector: OptimizedKubernetesRefDetector;
+/**
+ * Expression complexity analyzer with warnings for magic proxy usage
+ */
+export declare class ExpressionComplexityAnalyzer {
+    private readonly _detector;
+    private readonly _traverser;
+    private readonly _thresholds;
+    constructor(detector?: OptimizedKubernetesRefDetector, traverser?: OptimizedExpressionTraverser, thresholds?: Partial<ComplexityThresholds>);
+    /**
+     * Analyze expression complexity and generate warnings
+     */
+    analyzeComplexity(expression: any): ComplexityAnalysisResult;
+    /**
+     * Batch analyze multiple expressions
+     */
+    batchAnalyzeComplexity(expressions: Array<{
+        key: string;
+        expression: any;
+    }>): Map<string, ComplexityAnalysisResult>;
+    /**
+     * Get complexity statistics for a set of expressions
+     */
+    getComplexityStats(expressions: Array<{
+        key: string;
+        expression: any;
+    }>): ComplexityStats;
+    /**
+     * Calculate syntactic complexity (based on syntax patterns)
+     */
+    private _calculateSyntacticComplexity;
+    /**
+     * Calculate structural complexity (based on nesting and object structure)
+     */
+    private _calculateStructuralComplexity;
+    /**
+     * Calculate magic proxy complexity (based on KubernetesRef usage)
+     */
+    private _calculateMagicProxyComplexity;
+    /**
+     * Calculate cyclomatic complexity (based on control flow)
+     */
+    private _calculateCyclomaticComplexity;
+    /**
+     * Determine complexity level
+     */
+    private _determineComplexityLevel;
+    /**
+     * Generate warnings based on complexity analysis
+     */
+    private _generateWarnings;
+    /**
+     * Generate recommendations for reducing complexity
+     */
+    private _generateRecommendations;
+    /**
+     * Estimate conversion time based on complexity
+     */
+    private _estimateConversionTime;
+    /**
+     * Estimate memory impact
+     */
+    private _estimateMemoryImpact;
+}
+/**
+ * Complexity thresholds for different levels
+ */
+export interface ComplexityThresholds {
+    low: number;
+    medium: number;
+    high: number;
+    extreme: number;
+}
+/**
+ * Complexity level
+ */
+export type ComplexityLevel = 'low' | 'medium' | 'high' | 'extreme';
+/**
+ * Memory impact level
+ */
+export type MemoryImpact = 'low' | 'medium' | 'high' | 'extreme';
+/**
+ * Complexity metrics
+ */
+export interface ComplexityMetrics {
+    syntacticComplexity: number;
+    structuralComplexity: number;
+    magicProxyComplexity: number;
+    cyclomaticComplexity: number;
+    overallComplexity: number;
+    level: ComplexityLevel;
+}
+/**
+ * Complexity warning
+ */
+export interface ComplexityWarning {
+    type: string;
+    severity: 'info' | 'warning' | 'error';
+    message: string;
+    metric: string;
+    value: number;
+    threshold: number;
+}
+/**
+ * Result of complexity analysis
+ */
+export interface ComplexityAnalysisResult extends ComplexityMetrics {
+    expression: string;
+    warnings: ComplexityWarning[];
+    recommendations: string[];
+    analysisTime: number;
+    kubernetesRefCount: number;
+    estimatedConversionTime: number;
+    memoryImpact: MemoryImpact;
+}
+/**
+ * Complexity statistics for a set of expressions
+ */
+export interface ComplexityStats {
+    totalExpressions: number;
+    averageComplexity: number;
+    maxComplexity: number;
+    minComplexity: number;
+    complexityDistribution: Record<ComplexityLevel, number>;
+    totalWarnings: number;
+    averageWarnings: number;
+    mostComplexExpression: ComplexityAnalysisResult | null;
+    totalKubernetesRefs: number;
+    averageKubernetesRefs: number;
+}
+/**
+ * Global expression complexity analyzer
+ */
+export declare const globalComplexityAnalyzer: ExpressionComplexityAnalyzer;
+/**
+ * Global optimized expression traverser
+ */
+export declare const globalOptimizedTraverser: OptimizedExpressionTraverser;
+/**
+ * Global expression analysis profiler
+ */
+export declare const globalExpressionProfiler: ExpressionAnalysisProfiler;
+/**
+ * Global parallel expression analyzer
+ */
+export declare const globalParallelAnalyzer: ParallelExpressionAnalyzer;
+/**
+ * Global magic proxy integration instance
+ */
+export declare const globalMagicProxyIntegration: MagicProxyLazyIntegration;
+/**
+ * Global expression tree analyzer instance
+ */
+export declare const globalTreeAnalyzer: ExpressionTreeAnalyzer;
+/**
+ * Utility to check if a value should be wrapped in a lazy expression
+ */
+export declare function shouldUseLazyAnalysis(expression: any): boolean;
+//# sourceMappingURL=lazy-analysis.d.ts.map