import { Raysync } from './proto/proto.js';
import { BaseResponse, ServerActionResponse, ServerAttributesResponse, ServerBaseResponse, ServerConfig, ServerEvent, ServerFileInfoResponse, ServerGetVirusList, ServerHttpDownloadResponse, ServerListResponse, ServerLoginResponse, ServerRecycleBinRecordsResponse, ServerRemoveRecycleBinItems, UserInfo, VirusListParams, TaskState, ServerExtractFileResponse, ServerHttpPreviewResponse } from '../types';
import { FastUploadTask, UploadTaskOptions } from './create-task';
interface TransferFileInfo {
    requestId: number;
    name?: string;
    path?: string;
    totalSize?: number;
    currentSize?: number;
    createTime?: number;
    errorCode?: number;
}
interface EncryptOptions {
    ivLength: number;
    encryptMethod?: (array: ArrayBuffer, ivBuffer?: ArrayBuffer, beginPosition?: number) => any;
    hashMethod?: (array: ArrayBuffer, prevHash?: string, beginPosition?: number, isEnd?: boolean) => any;
    beginPosition?: number;
    encryptType: number;
    aeaType?: number;
    aesKey?: string;
    withHash?: boolean;
    generateAEAKey?: (aesKey?: string) => string;
}
export default class FileServer {
    private websocket;
    /** Whether websocket is connected */
    connected: boolean;
    /** Whether user is logged in */
    hasLogin: boolean;
    /** User info (used for copying login state during task isolation) */
    private userInfo?;
    /** Group ID */
    private groupId?;
    private spaceId?;
    private emitter;
    private config;
    private parser;
    private pending;
    private messageQueue;
    /** Unified handling of client command errors */
    private _onResponse;
    onResponse: (listener: (e: BaseResponse) => any, thisArgs?: any) => import("../utils/event").IDisposable;
    /** Handle WebSocket errors */
    private _onClose;
    onClose: (listener: (e: CloseEvent | undefined) => any, thisArgs?: any) => import("../utils/event").IDisposable;
    private _beforeExecuteCommand;
    beforeExecuteCommand: (listener: (e: string | ArrayBuffer) => any, thisArgs?: any) => import("../utils/event").IDisposable;
    /** Triggered when connected */
    private _onConnect;
    onConnect: (listener: (e: unknown) => any, thisArgs?: any) => import("../utils/event").IDisposable;
    constructor(config: ServerConfig);
    initWebSocket(): void;
    private attachEvents;
    /** Provide external Emitter events */
    on: ServerEvent;
    off: ServerEvent;
    once: ServerEvent;
    close(): void;
    private executeCommand;
    login({ username, password, uk, token, spaceId, isEncrypt, authWay }: UserInfo): Promise<ServerLoginResponse>;
    setGroupId(groupId: number): void;
    setSpaceId(spaceId: number): Promise<ServerBaseResponse<any>>;
    httpDownload(path: string[]): Promise<ServerHttpDownloadResponse>;
    httpPreview(path: string): Promise<ServerHttpPreviewResponse>;
    extractFile(path: string, options: {
        skipOuterDir: boolean;
        forceOverwrite: boolean;
        requestId?: number;
    }): Promise<ServerExtractFileResponse>;
    cancelExtractFile(requestId: number): Promise<ServerExtractFileResponse>;
    getRecycleBinRecords({ spaceId, pageNum, pageSize, filename, storageId, groupId, }: {
        spaceId: number;
        pageNum?: number;
        pageSize?: number;
        filename?: string;
        storageId?: number;
        groupId?: number;
    }): Promise<ServerRecycleBinRecordsResponse>;
    removeRecycleBinItems(fileIds: number[]): Promise<ServerRemoveRecycleBinItems>;
    restoreRecycleBinItems(fileIds: number[], overwrite?: boolean): Promise<ServerRemoveRecycleBinItems>;
    getVirusFileList(p: VirusListParams): Promise<ServerGetVirusList>;
    clearRecycleBin(spaceId: number, options?: {
        storageId?: number;
        cleanSpace?: boolean;
        groupId?: number;
        action?: number;
    }): Promise<ServerBaseResponse<any>>;
    list(path?: string): Promise<ServerListResponse>;
    download(path: string, reportEvent?: boolean, downloadId?: number): void;
    mkdir(name: string, path?: string): Promise<ServerBaseResponse<any>>;
    remove(path?: string): Promise<ServerActionResponse>;
    rename({ path, newName, isDir, }: {
        path: string;
        newName: string;
        isDir?: boolean;
    }): Promise<ServerActionResponse>;
    copy(from: string, to: string): Promise<ServerActionResponse>;
    move(from: string, to: string): Promise<ServerActionResponse>;
    getAttributes(path: string): Promise<ServerAttributesResponse>;
    uploadFiles: Map<number, TransferFileInfo>;
    private uploadRequestId;
    private uploadStatus;
    pauseUpload(requestId: number): void;
    resumeUpload(requestId: number): void;
    cancelUpload(requestId: number): void;
    upload({ file, path, requestId, saveTimestamp, }: {
        file: File;
        path?: string;
        requestId?: number;
        saveTimestamp?: boolean;
    }): void;
    getEncryptFileInfo({ path, requestId }: {
        path: string;
        requestId?: number;
    }): Promise<ServerFileInfoResponse>;
    reportUploadTaskInfo(state: TaskState): Promise<ServerListResponse>;
    reportInstantFile(params: {
        filePath: Uint8Array;
        fileSize: number;
    }): Promise<ServerListResponse>;
    reportInstantFailureFile(params: Raysync.IFile_ReportInstantFailureFileEx): Promise<ServerListResponse>;
    uploadEncryptFile({ file, path, requestId, encryptMethod, encryptType, onEncryptionMismatch, ivLength, }: {
        file: File;
        path?: string;
        requestId?: number;
        encryptMethod?: (array: ArrayBuffer, ivBuffer?: ArrayBuffer, beginPosition?: number) => any;
        encryptType?: number;
        onEncryptionMismatch?: (type?: number) => void;
        ivLength?: number;
    }): void;
    uploadEncryptFileWithHash({ file, path, requestId, onEncryptionMismatch, reupload, ..._options }: {
        file: File;
        path?: string;
        requestId?: number;
        footerLength?: number;
        reupload?: boolean;
        onEncryptionMismatch?: (type?: number) => void;
    } & EncryptOptions): void;
    private checkBuffer;
    private setUploadFiles;
    private checkServerStatus;
    isRegisteredDownloadEvent: boolean;
    downloadId: number;
    downloadMap: Record<number, Function>;
    getIvFromServer(path: string, seek: number, ivLength: number): Promise<unknown>;
    private uploadStart;
    ivMap: Record<any, any>;
    hashMap: Record<any, any>;
    keyMap: Record<any, any>;
    private encryptUploading;
    private uploadEncryptFileSuccess;
    private uploading;
    private uploadSuccess;
    getFileInfo(path: string, requestId?: number): Promise<ServerFileInfoResponse>;
    /** Report event */
    private reportTraffic;
    reportConnectionInfo(obj: Record<string, any>): void;
    reportTask({ state, firstFileName, pathList, isUpload, fileCount, failedCount, sumFileSize, shareEmailSwitch, shareEmail, shareEmailContent, shareEmailPassword, }: {
        state: 0 | 1;
        firstFileName: string;
        pathList: string[];
        isUpload: boolean;
        fileCount: number;
        failedCount: number;
        sumFileSize?: number;
        shareEmailSwitch?: boolean;
        shareEmail?: string;
        shareEmailContent?: string;
        shareEmailPassword?: string;
    }): void;
    private reportOperation;
    reportVideoEvent({ path, startTime, endTime, }: {
        path: string;
        startTime: number;
        endTime?: number;
    }): void;
    private reportDownloadEndEvent;
    /**
     * Create upload task
     * Automatically creates an independent FileServer instance to ensure multi-task isolation
     * @param files File list (supports FileList, File[], DataTransferItemList)
     * @param options Task options
     * @returns UploadTask instance
     */
    createUploadTask(files: FileList | File[] | DataTransferItemList, options: UploadTaskOptions): FastUploadTask;
}
export {};