/// <reference types="node" />
import { StorageType } from './../common/types';
import { WorkerClient } from '../worker/WorkerClient';
import { Request, Response } from '../client/Client';
import { SerializedFunction } from '../common/SerializeFunction';
declare type InArgs = {
    type: 'value' | 'partitions' | 'parts';
    args?: any[];
    partitions?: string[];
    parts?: string[][];
};
declare type OutArgs = {
    type: 'reduce' | 'partitions' | 'parts' | 'saveFile';
    storageType?: StorageType;
    saveFunc?: SerializedFunction<(data: any[], filename: string) => void | Promise<void>>;
    partitionFunc?: SerializedFunction<(v: any[], arg: any, partitionIndex: number) => any[][]>;
    args?: any[];
};
declare type Partition = [number, string];
declare type CacheRecord = {
    storageType: StorageType;
    partitions: Partition[];
};
export interface FileLoader {
    canHandleUrl(baseUrl: string, type: 'load' | 'save'): boolean | Promise<boolean>;
    listFiles(baseUrl: string, recursive?: boolean): string[] | Promise<string[]>;
    createDataLoader(baseUrl: string): SerializedFunction<(filename: string) => Buffer | Promise<Buffer>>;
    initSaveProgress(baseUrl: string, overwrite?: boolean): void | Promise<void>;
    createDataSaver(baseUrl: string): SerializedFunction<(filename: string, buffer: Buffer) => void | Promise<void>>;
    markSaveSuccess(baseUrl: string): void | Promise<void>;
}
interface TaskDetail {
    index: number;
    total: number;
}
export declare class MasterServer {
    workers: WorkerClient[];
    caches: CacheRecord[];
    cacheIdCounter: number;
    fileLoaderRegistry: FileLoader[];
    constructor();
    registerFileLoader(loader: FileLoader): void;
    init(): Promise<void>;
    dispose(): Promise<void>;
    send(m: Response): void;
    onTaskBegin(task: TaskDetail, progressTotal: number): void;
    processRequest<T>(m: Request<T>): Promise<any>;
    getSplitIndecies(count: number): number[][];
    splitByWorker<T>(args: T[]): T[][];
    mergeWorkerResult<T>(resps: T[][]): T[];
    finalWork(ins: InArgs[], indecies: number[][], out: OutArgs | OutArgs[], mappers: SerializedFunction<(arg: any, partitionIndex: number) => any>[], task: TaskDetail, progressTotal: number): Promise<any[]>;
    createRDD(args: any[], out: OutArgs | OutArgs[], mappers: SerializedFunction<(arg: any, partitionIndex: number) => any>[], task: TaskDetail): Promise<any>;
    addCache(storageType: StorageType, partitions: Partition[]): number;
    loadCache(id: number, out: OutArgs | OutArgs[], mappers: SerializedFunction<(arg: any, partitionIndex: number) => any>[], task: TaskDetail): Promise<any>;
    releaseCache(id: number): Promise<void>;
    joinPieces(numPartitions: number, parts: string[][], out: OutArgs | OutArgs[], mappers: SerializedFunction<(arg: any, partitionIndex: number) => any>[], task: TaskDetail): Promise<any>;
    getPartitionCount(dependWork: Request<any>): Promise<number>;
    getFileLoader(baseUrl: string, type: 'load' | 'save'): Promise<FileLoader>;
    loadFile(baseUrl: string, recursive: boolean, out: OutArgs | OutArgs[], mappers: SerializedFunction<(arg: any, partitionIndex: number) => any>[], task: TaskDetail): Promise<any[]>;
    getTaskDetail(dependWork: Request<any>, out?: TaskDetail): TaskDetail;
    runWork(dependWork: Request<any>, out: OutArgs | OutArgs[], mappers?: SerializedFunction<(arg: any, partitionIndex: number) => any>[], task?: TaskDetail): Promise<any[]>;
}
export {};