/**
 * Chunked File Uploader
 *
 * Handles large file uploads by splitting them into chunks.
 * Supports:
 * - Configurable chunk size
 * - Progress tracking
 * - Retry failed chunks
 * - Parallel chunk upload
 * - Pause/resume functionality
 */
export interface ChunkUploadConfig {
    /** Size of each chunk in bytes (default: 5MB) */
    chunkSize?: number;
    /** Number of parallel uploads (default: 3) */
    parallelUploads?: number;
    /** Max retries per chunk (default: 3) */
    maxRetries?: number;
    /** Delay between retries in ms (default: 1000) */
    retryDelay?: number;
    /** Upload endpoint */
    endpoint: string;
    /** Headers to include with each chunk request */
    headers?: Record<string, string>;
    /** Query params for the upload request */
    params?: Record<string, string>;
    /** Additional form data fields */
    fields?: Record<string, string>;
    /** File field name (default: 'file') */
    fileField?: string;
    /** Chunk index field name (default: 'chunkIndex') */
    chunkIndexField?: string;
    /** Total chunks field name (default: 'totalChunks') */
    totalChunksField?: string;
    /** File ID field name (for resume, default: 'fileId') */
    fileIdField?: string;
    /** Progress callback */
    onProgress?: (progress: UploadProgress) => void;
}
export interface UploadProgress {
    /** Bytes uploaded */
    uploaded: number;
    /** Total bytes */
    total: number;
    /** Percentage (0-100) */
    percentage: number;
    /** Current chunk index */
    chunkIndex: number;
    /** Total chunks */
    totalChunks: number;
    /** Upload speed in bytes/second */
    speed?: number;
    /** Estimated remaining time in seconds */
    remaining?: number;
}
export interface ChunkUploadResult {
    /** Upload success status */
    success: boolean;
    /** File ID from server (for resume/combine) */
    fileId?: string;
    /** Server response */
    response?: any;
    /** Error if failed */
    error?: string;
    /** Upload progress */
    progress: UploadProgress;
}
export interface ChunkInfo {
    index: number;
    start: number;
    end: number;
    size: number;
    data: Blob;
    retries: number;
}
/**
 * Chunked file uploader class
 */
export declare class ChunkedUploader {
    private config;
    private aborted;
    private paused;
    private uploadStartTime;
    private lastProgressUpdate;
    private fileId?;
    private uploadedChunks;
    constructor(config: ChunkUploadConfig);
    /**
     * Upload a file in chunks
     */
    upload(file: File | Blob, fileId?: string): Promise<ChunkUploadResult>;
    /**
     * Create file chunks
     */
    private createChunks;
    /**
     * Upload chunks with parallel processing
     */
    private uploadChunks;
    /**
     * Upload a single chunk
     */
    private uploadChunk;
    /**
     * Finalize upload (combine chunks on server)
     */
    private finalizeUpload;
    /**
     * Get current progress
     */
    private getProgress;
    /**
     * Report progress (throttled to avoid excessive updates)
     */
    private reportProgress;
    /**
     * Pause the upload
     */
    pause(): void;
    /**
     * Resume the upload
     */
    resume(): void;
    /**
     * Abort the upload
     */
    abort(): void;
    /**
     * Check if upload is paused
     */
    isPaused(): boolean;
    /**
     * Check if upload is aborted
     */
    isAborted(): boolean;
    /**
     * Generate a unique file ID
     */
    private generateFileId;
    private sleep;
}
/**
 * Create a chunked uploader instance
 */
export declare function createChunkedUploader(config: ChunkUploadConfig): ChunkedUploader;
/**
 * Upload a file in chunks (convenience function)
 */
export declare function uploadFileInChunks(file: File | Blob, config: ChunkUploadConfig): Promise<ChunkUploadResult>;
export default ChunkedUploader;