/**
 * Base utilities for optimization strategies
 *
 * Provides common interfaces, metrics calculation, and registry pattern
 * for TONL optimization modules.
 */
/**
 * Standard metrics for optimization results
 */
export interface OptimizationMetrics {
    /** Original data size in bytes */
    originalBytes: number;
    /** Optimized data size in bytes */
    optimizedBytes: number;
    /** Compression ratio (original / optimized) */
    compressionRatio: number;
    /** Percentage of bytes saved */
    savingsPercent: number;
    /** Processing time in milliseconds */
    processingTimeMs: number;
}
/**
 * Standard result structure for optimization operations
 */
export interface OptimizationResult<T = unknown> {
    /** Strategy name that produced this result */
    strategy: string;
    /** Optimized/encoded data */
    data: T;
    /** Metadata needed for decoding */
    metadata: Record<string, unknown>;
    /** Performance metrics */
    metrics: OptimizationMetrics;
    /** Whether optimization was beneficial */
    beneficial: boolean;
}
/**
 * Common interface for all optimization strategies
 */
export interface Optimizer {
    /** Unique strategy name */
    readonly name: string;
    /** Human-readable description */
    readonly description: string;
    /** Analyze data to determine if optimization is beneficial */
    analyze(data: unknown): {
        beneficial: boolean;
        estimatedSavings: number;
    };
    /** Encode/optimize data */
    encode(data: unknown, options?: unknown): OptimizationResult<unknown>;
    /** Decode/restore original data */
    decode(encoded: unknown, metadata: Record<string, unknown>): unknown;
}
/**
 * Calculate byte size of a value (JSON serialized)
 */
export declare function calculateByteSize(value: unknown): number;
/**
 * Calculate optimization metrics
 */
export declare function calculateMetrics(originalData: unknown, optimizedData: unknown, startTime: number): OptimizationMetrics;
/**
 * Check if optimization result is beneficial
 */
export declare function isBeneficial(metrics: OptimizationMetrics, minSavingsPercent?: number): boolean;
/**
 * Create a standard optimization result
 */
export declare function createResult<T>(strategy: string, data: T, metadata: Record<string, unknown>, metrics: OptimizationMetrics): OptimizationResult<T>;
/**
 * Registry entry for an optimizer
 */
interface OptimizerEntry {
    name: string;
    description: string;
    factory: () => Optimizer;
    priority: number;
}
/**
 * Registry for optimization strategies
 * Allows dynamic discovery and selection of optimizers
 */
declare class OptimizerRegistry {
    private optimizers;
    /**
     * Register an optimizer
     */
    register(entry: OptimizerEntry): void;
    /**
     * Get an optimizer by name
     */
    get(name: string): Optimizer | undefined;
    /**
     * Get all registered optimizer names
     */
    getNames(): string[];
    /**
     * Get all optimizers sorted by priority
     */
    getAll(): Optimizer[];
    /**
     * Check if an optimizer is registered
     */
    has(name: string): boolean;
    /**
     * Get optimizer descriptions for documentation
     */
    getDescriptions(): Array<{
        name: string;
        description: string;
    }>;
}
/**
 * Global optimizer registry instance
 */
export declare const optimizerRegistry: OptimizerRegistry;
/**
 * Chain multiple optimizers together
 */
export declare function chainOptimizers<T>(data: T, optimizers: Optimizer[], options?: {
    stopOnNoImprovement?: boolean;
}): OptimizationResult<T>;
/**
 * Select best optimizer for given data
 */
export declare function selectBestOptimizer(data: unknown, optimizers: Optimizer[]): {
    optimizer: Optimizer;
    estimatedSavings: number;
} | null;
/**
 * Analyze array for optimization potential
 */
export declare function analyzeArray(arr: unknown[]): {
    length: number;
    uniqueCount: number;
    uniformType: boolean;
    dominantType: string;
    hasNulls: boolean;
    numericRange: {
        min: number;
        max: number;
    } | null;
};
/**
 * Estimate token count for a value (rough approximation)
 */
export declare function estimateTokens(value: unknown): number;
export {};
//# sourceMappingURL=base.d.ts.map