/**
 * Numeric quantization for precision control
 *
 * Reduces token count by limiting floating-point precision
 * while preserving meaningful digits.
 */
import type { QuantizationOptions } from './types.js';
/**
 * Precision analysis result
 */
export interface PrecisionAnalysis {
    suggestedPrecision: number;
    minValue: number;
    maxValue: number;
    range: number;
    hasDecimals: boolean;
    lossEstimate: number;
    tokenSavings: number;
}
/**
 * Numeric quantizer for precision control
 */
export declare class NumericQuantizer {
    private options;
    constructor(options?: Partial<QuantizationOptions>);
    /**
     * Analyze numeric column and suggest optimal precision
     *
     * @param values - Array of numeric values
     * @returns Precision analysis with recommendations
     */
    analyzePrecision(values: number[]): PrecisionAnalysis;
    /**
     * Calculate optimal precision based on value distribution
     *
     * @param values - Numeric values
     * @param range - Value range
     * @returns Suggested decimal places
     */
    private calculateOptimalPrecision;
    /**
     * Estimate information loss from quantization
     *
     * @param values - Original values
     * @param precision - Target precision
     * @returns Loss as percentage (0-1)
     */
    private estimateLoss;
    /**
     * Estimate token savings from quantization
     *
     * @param values - Original values
     * @param precision - Target precision
     * @returns Estimated percentage of tokens saved (0-1)
     */
    private estimateTokenSavings;
    /**
     * Quantize a numeric value to specified precision
     *
     * @param value - Number to quantize
     * @param precision - Decimal places (0 for integer)
     * @returns Quantized value
     */
    quantize(value: number, precision: number): number;
    /**
     * Smart quantize - preserve meaningful digits automatically
     *
     * Examples:
     * - 0.00123 → 0.00123 (keep 5 decimals for small values)
     * - 123.456 → 123.46 (keep 2 decimals for large values)
     * - 0.1 → 0.1 (keep 1 decimal if significant)
     *
     * @param value - Number to quantize
     * @returns Quantized value
     */
    smartQuantize(value: number): number;
    /**
     * Quantize an array of values with column-specific precision
     *
     * @param values - Array of numbers
     * @param columnName - Column name (for override lookup)
     * @returns Quantized values
     */
    quantizeColumn(values: number[], columnName?: string): number[];
    /**
     * Generate precision directive
     *
     * Format: @precision columnName=2
     *
     * @param columnName - Column name
     * @param precision - Decimal places
     * @returns TONL directive string
     */
    generatePrecisionDirective(columnName: string, precision: number): string;
    /**
     * Parse precision directive
     *
     * @param directive - TONL directive like "@precision price=2"
     * @returns Object with column name and precision
     */
    parsePrecisionDirective(directive: string): {
        column: string;
        precision: number;
    };
    /**
     * Get precision for a column
     *
     * @param columnName - Column name
     * @returns Configured precision or default
     */
    getPrecision(columnName: string): number;
    /**
     * Set precision for a column
     *
     * @param columnName - Column name
     * @param precision - Decimal places
     */
    setPrecision(columnName: string, precision: number): void;
    /**
     * Check if quantization would be beneficial
     *
     * @param values - Numeric values
     * @param minSavingsThreshold - Minimum token savings (default: 0.10 = 10%)
     * @returns True if quantization is recommended
     */
    shouldQuantize(values: number[], minSavingsThreshold?: number): boolean;
}
//# sourceMappingURL=quantizer.d.ts.map