/**
 * Compresses a PDF file using the specified preset and options
 *
 * @param pdfBuffer - The PDF file as an ArrayBuffer
 * @param options - Compression options
 * @returns Promise resolving to the compressed PDF and statistics
 *
 * @example
 * ```typescript
 * import { compress } from '@quicktoolsone/pdf-compress';
 *
 * const file = await fetch('document.pdf').then(r => r.arrayBuffer());
 * const result = await compress(file, {
 *   preset: 'balanced',
 *   onProgress: (event) => {
 *     console.log(`${event.phase}: ${event.progress}%`);
 *   }
 * });
 *
 * console.log(`Saved ${result.stats.percentageSaved.toFixed(1)}%`);
 * ```
 */
export declare function compress(pdfBuffer: ArrayBuffer, options?: Partial<CompressionOptions>): Promise<CompressionResult>;

/**
 * Compresses a PDF with the balanced preset (recommended)
 * Convenience wrapper around compress()
 *
 * @param pdfBuffer - The PDF file as an ArrayBuffer
 * @param options - Additional compression options (preset will be overridden)
 */
export declare function compressBalanced(pdfBuffer: ArrayBuffer, options?: Omit<Partial<CompressionOptions>, 'preset'>): Promise<CompressionResult>;

/**
 * Custom error class for compression failures
 */
export declare class CompressionError extends Error {
    attemptedPreset: CompressionPreset;
    originalSize: number;
    phase?: ProgressPhase | undefined;
    underlyingError?: Error | undefined;
    constructor(message: string, attemptedPreset: CompressionPreset, originalSize: number, phase?: ProgressPhase | undefined, underlyingError?: Error | undefined);
}

/**
 * Compression options
 */
export declare interface CompressionOptions {
    /** Compression preset to use */
    preset: CompressionPreset;
    /** Pages per chunk (default: 10) */
    chunkSize?: number;
    /** Progress callback function */
    onProgress?: (event: ProgressEvent_2) => void;
    /** Custom WASM URL (defaults to jsdelivr CDN) */
    wasmUrl?: string;
    /** Custom wasm_exec.js URL (defaults to jsdelivr CDN) */
    wasmExecUrl?: string;
    /** Enable graceful degradation (fallback to lighter presets on error, default: true) */
    gracefulDegradation?: boolean;
    /** Preserve metadata (default: true for lossless/balanced, false for max) */
    preserveMetadata?: boolean;
    /** Override target DPI for image downsampling (balanced/max only) */
    targetDPI?: number;
    /** Override JPEG quality (0-1, balanced/max only) */
    jpegQuality?: number;
    /** Enable rasterization in max mode (default: auto-detect) */
    enableRasterization?: boolean;
    /** Merge strategy: 'worker' (default) or 'main' thread */
    mergeStrategy?: 'worker' | 'main';
    /** Timeout in milliseconds (default: 300000 = 5 minutes) */
    timeout?: number;
}

/**
 * Compression preset options
 * - lossless: Structural optimization only, no quality loss (5-30% reduction)
 * - balanced: Smart image compression, preserve vectors (30-70% reduction)
 * - max: Aggressive compression with optional rasterization (60-90% reduction)
 */
export declare type CompressionPreset = 'lossless' | 'balanced' | 'max';

/**
 * Compression result
 */
export declare interface CompressionResult {
    /** Compressed PDF as ArrayBuffer */
    pdf: ArrayBuffer;
    /** Compression statistics */
    stats: CompressionStats;
    /** Warning message if graceful degradation occurred */
    warning?: string;
}

/**
 * Compression statistics
 */
export declare interface CompressionStats {
    /** Original PDF size in bytes */
    originalSize: number;
    /** Compressed PDF size in bytes */
    compressedSize: number;
    /** Compression ratio (0-1, where 0.5 means 50% of original size) */
    ratio: number;
    /** Bytes saved */
    bytesSaved: number;
    /** Percentage saved (0-100) */
    percentageSaved: number;
    /** Preset used (may differ from requested if graceful degradation occurred) */
    presetUsed: CompressionPreset;
    /** Processing time in milliseconds */
    processingTime: number;
    /** Number of chunks processed */
    chunksProcessed: number;
}

/**
 * Compresses a PDF with the lossless preset
 * Convenience wrapper around compress()
 *
 * @param pdfBuffer - The PDF file as an ArrayBuffer
 * @param options - Additional compression options (preset will be overridden)
 */
export declare function compressLossless(pdfBuffer: ArrayBuffer, options?: Omit<Partial<CompressionOptions>, 'preset'>): Promise<CompressionResult>;

/**
 * Compresses a PDF with the max preset
 * Convenience wrapper around compress()
 *
 * @param pdfBuffer - The PDF file as an ArrayBuffer
 * @param options - Additional compression options (preset will be overridden)
 */
export declare function compressMax(pdfBuffer: ArrayBuffer, options?: Omit<Partial<CompressionOptions>, 'preset'>): Promise<CompressionResult>;

/**
 * Progress event emitted during compression
 */
declare interface ProgressEvent_2 {
    /** Current phase of compression */
    phase: ProgressPhase;
    /** Progress percentage (0-100) */
    progress: number;
    /** Current chunk being processed (1-indexed) */
    currentChunk?: number;
    /** Total number of chunks */
    totalChunks?: number;
    /** Estimated time remaining in milliseconds */
    estimatedTimeRemaining?: number;
    /** Optional message for error recovery or warnings */
    message?: string;
}
export { ProgressEvent_2 as ProgressEvent }

/**
 * Progress event phases during compression
 */
export declare type ProgressPhase = 'chunking' | 'compressing' | 'merging' | 'error-recovery';

export { }