import Deque from "double-ended-queue";
declare type DeleteStore = () => void;
declare type Unsubscribe = () => void;
declare type Id = string;
export declare type UploaderFunctionParams = {
    content: Blob;
    index: number;
    totalCount: number;
    id: string;
    signal: AbortSignal;
    name: string;
};
export declare type UploaderFunction<Result = unknown> = (data: UploaderFunctionParams) => Promise<Result | undefined>;
interface DefaultFiber {
    fileSignal: AbortSignal;
}
export interface Fiber extends DefaultFiber {
    task: () => Promise<any>;
}
export interface WorkingFiber extends DefaultFiber {
    work: Promise<any>;
}
declare type UploaderEvent = {
    fileId: string;
} & ({
    status: "error";
    reason: "Model was not founded in results" | readonly ["Cannot load file", Event];
} | {
    status: "success";
    data: unknown;
});
declare type AllExtensions = null;
export declare type Options = {
    /**
     * Max files count
     */
    filesCount: number;
    /**
     * Extensions, like accept attribute and input receive or null if need
     * to receive all extensions
     */
    extensions: string[] | AllExtensions;
    retryCount: number;
    maxWeight: number;
};
export declare type Store = {
    signal: AbortSignal;
    files: Map<AbortSignal, Id>;
    uploader: UploaderFunction;
    subscribers: Set<(event: UploaderEvent) => void>;
    unlistenedEvents: UploaderEvent[];
    options: Options;
    cache: any;
};
declare type FileData = {
    storeId: symbol;
    totalChunks: number;
    loadedChunks: unknown[];
};
export declare type Uploader = {
    queue: Deque<Fiber>;
    workingQueue: Set<WorkingFiber>;
    startNextTask: (finishedTask: {
        fiber: WorkingFiber;
        result: unknown;
    } | null) => void;
    stores: Record<symbol, Store | undefined>;
    filesData: Map<AbortSignal, FileData>;
    abortedFilesSignals: WeakSet<AbortSignal>;
    updateFileData: (data: unknown, signal: AbortSignal) => void;
    load: (storeId: symbol, file: File) => {
        id: Id;
        abortLoad: () => void;
    };
    createStore: (args: {
        id: symbol;
        uploader: UploaderFunction;
        options: Options;
    }) => DeleteStore;
    subscribe: (storeId: symbol, callback: (changes: UploaderEvent) => void) => Unsubscribe;
    getOptions: (storeId: symbol) => Options | undefined;
    notifySubscribers(storeId: symbol): void;
    getStore(id: symbol): Store;
    emitEvent(storeId: symbol, event: UploaderEvent): void;
    finalizeLoading(signal: AbortSignal, fileData: FileData): void;
    readCache<T>(storeId: symbol): T[] | undefined;
    writeCache(storeId: symbol, data: any): void;
};
export declare type ExternalUploader = Pick<Uploader, "createStore" | "subscribe" | "load" | "getOptions" | "writeCache" | "readCache">;
export declare type ApiFunctionType<Model, Result> = (model: Model, init?: RequestInit) => Promise<Result>;
export declare type MaybePromise<T> = Promise<T> | T;
export {};