export interface ProcessingCheckpoint {
    operationId: string;
    stage: 'backup' | 'jsx_cleaning' | 'jsx_validation' | 'jsx_export' | 'file_writing' | 'completed';
    progress: number;
    data: {
        originalJSX?: string;
        processedJSX?: string;
        currentChunk?: number;
        totalChunks?: number;
        intermediateResults?: string[];
        backupPath?: string;
        chunkSize?: number;
        lastProcessedIndex?: number;
        processingStartTime?: number;
        stageStartTime?: number;
    };
    timestamp: number;
    projectName: string;
    lastActivity: number;
}
declare class CheckpointManager {
    private checkpoints;
    private maxCheckpoints;
    private checkpointFile;
    private saveTimeout;
    constructor();
    private loadCheckpoints;
    private saveCheckpointsToDisk;
    saveCheckpoint(checkpoint: ProcessingCheckpoint): void;
    getCheckpoint(operationId: string): ProcessingCheckpoint | undefined;
    removeCheckpoint(operationId: string): void;
    listActiveOperations(): string[];
    getDetailedOperations(): Array<{
        operationId: string;
        stage: string;
        progress: number;
        projectName: string;
        ageSeconds: number;
        isStale: boolean;
    }>;
    cleanStaleOperations(maxAgeHours?: number): number;
}
export declare const checkpointManager: CheckpointManager;
export declare class ResumableJSXProcessor {
    private readonly chunkSize;
    private readonly stageTimeout;
    private readonly chunkYieldInterval;
    /**
     * Process JSX with timeout protection AND resumption capability
     * If timeout occurs, saves checkpoint and throws resumable error
     * If checkpoint exists, continues from where it left off
     */
    processJSXWithResumption(jsx: string, projectName: string, operationId: string, existingCheckpoint?: ProcessingCheckpoint): Promise<string>;
    /**
     * Wrapper that applies timeout protection to any operation
     * Saves checkpoint if timeout occurs
     */
    private timeoutProtectedOperation;
    /**
     * Resumable JSX cleaning with chunk-based processing
     * Can resume from any chunk position
     */
    private resumableJSXCleaning;
    /**
     * Safe JSX chunk cleaning without regex catastrophic backtracking
     */
    private cleanJSXChunkSafely;
    /**
     * Extract component props using safe string parsing instead of regex
     */
    private extractComponentPropsFromChunk;
    /**
     * Process a line containing component prop with safe parsing
     */
    private processComponentLine;
    private yieldControl;
    private splitIntoChunks;
    private validateJSXStructure;
    /**
     * Ensure proper export - simplified version without complex processing
     */
    private ensureProperExport;
}
export declare const jsxProcessor: ResumableJSXProcessor;
export {};
//# sourceMappingURL=checkpoint-processor.d.ts.map