export type EventNameType = "chunkAttempt" | "chunkSuccess" | "error" | "progress" | "success" | "online" | "offline" | "chunkAttemptFailure";
export interface UserProps {
    endpoint: string;
    file: File;
    retryChunkAttempt?: string | number;
    delayRetry?: string | number;
    chunkSize?: string | number;
    maxFileSize?: string | number;
    stallTimeout?: string | number;
    connectionRefreshInterval?: string | number;
}
export interface UploaderEventMap {
    chunkAttempt: CustomEvent<ChunkAttemptEventData>;
    chunkSuccess: CustomEvent<ChunkSuccessEventData>;
    progress: CustomEvent<ProgressEventData>;
    success: CustomEvent<SuccessEventData>;
    error: CustomEvent<ErrorEventData>;
    chunkAttemptFailure: CustomEvent<ChunkAttemptFailureEventData>;
    online: CustomEvent<OnlineEventData>;
    offline: CustomEvent<OfflineEventData>;
}
export interface ChunkAttemptEventData extends CommonEventData {
    chunkNumber: number;
    chunkSize: number | undefined;
}
export interface ProgressEventData extends CommonEventData {
    progress: number;
}
export interface UploadResponse {
    statusCode: number;
    responseBody: any;
    url: string;
    method: string;
    headers: Record<string, string>;
}
export interface CommonEventData {
    totalChunks: number;
    uploadedChunks: number;
    remainingChunks: number;
    totalProgress: number;
    fileName: string;
    fileSize: number;
}
export interface ChunkSuccessEventData extends CommonEventData {
    chunkNumber: number;
    timeInterval: number;
    response: UploadResponse;
}
export interface ErrorEventData extends Partial<CommonEventData> {
    message: string;
    chunkNumber?: number;
    response?: UploadResponse;
    detail?: string;
    statusCode?: number;
    failedAttempts?: number;
    maxAttempts?: number;
}
export interface OnlineEventData extends CommonEventData {
    message: string;
}
export interface OfflineEventData extends CommonEventData {
    message: string;
    uploadOffset: number;
}
export interface ChunkAttemptFailureEventData extends CommonEventData {
    chunkAttempt: number;
    totalChunkFailureAttempts: number;
    chunkNumber: number;
    retryDelay: number;
    isTimeoutOrRateLimit: boolean;
    consecutiveBackoffFailures: number;
}
export interface SuccessEventData extends CommonEventData {
    uploadDuration: number;
    totalDuration: number;
    averageChunkSize: number;
    averageUploadSpeed: number;
}
export declare class Uploader {
    private readonly uploadEndpoint;
    private readonly sourceFile;
    private readonly maxRetryAttempts;
    private readonly retryDelaySeconds;
    private readonly configuredChunkSize;
    private readonly maxFileSizeBytes;
    private readonly eventEmitter;
    private readonly chunkProcessor;
    private readonly configuredChunkBytes;
    private readonly maxConsecutiveBackoffFailures;
    private sessionUri;
    private retryCount;
    private currentChunkIndex;
    private isNetworkOffline;
    private isUploadPaused;
    private isUploadAborted;
    private retryTimeoutId;
    private currentChunkStartPosition;
    private successfulChunksCount;
    private currentChunkBytes;
    private lastChunkTimestamp;
    private totalChunksCount;
    private activeRequest;
    private uploadStartTimestamp;
    private consecutiveBackoffFailures;
    private isUploadProgress;
    private isDestroyed;
    private isSessionInitiating;
    private readonly handleWindowOnline;
    private readonly handleWindowOffline;
    private readonly stallTimeoutMs;
    private readonly connectionRefreshBaseMs;
    private connectionRefreshMs;
    private lastUploadProgressAt;
    private chunkRequestStartedAt;
    private stallWatchdogId;
    static init(uploadProps: UserProps): Uploader;
    constructor(props: UserProps);
    destroy(): void;
    private emitTerminalError;
    private scheduleUploadStart;
    initiateSession(): Promise<void>;
    private abortActiveXhr;
    private startStallWatchdog;
    private stopStallWatchdog;
    private recycleConnection;
    abort(): void;
    pause(): void;
    resume(): Promise<void>;
    retryUpload(): void;
    validateUserInput(): void;
    private validateUploadEndpoint;
    private validateSourceFile;
    private validateRetrySettings;
    private validateRecoverySettings;
    private validateChunkSize;
    private validateMaxFileSize;
    on<K extends EventNameType>(eventName: K, fn: (event: UploaderEventMap[K]) => void): void;
    private emitEvent;
    private getCommonEventData;
    chunkUploadFailureHandler: (res: UploadResponse) => Promise<boolean>;
    private canProceedWithUpload;
    private canResumeUpload;
    private canRetryUpload;
    private resetUploadState;
    private calculateProgress;
    private parseResponseHeaders;
    private handleChunkSuccess;
    private handleResumeUpload;
    private updateUploadPosition;
    private queryCommittedByteCount;
    private synchronizeUploadPosition;
    private submitHttpRequest;
    handleRetryChunkUploading(res: UploadResponse): Promise<void>;
    validateUploadStatus(): Promise<void>;
    requestChunk(): Promise<void>;
}