/// <reference types="node" />
import { StorageType } from './../common/types';
import { FunctionEnv } from './../common/SerializeFunction';
import { Client, Request } from './Client';
declare type ResponseFactory<T> = (rdd: RDD<T>) => Request<any> | Promise<Request<any>>;
export declare class RDD<T> {
    context: Context;
    constructor(context: Context);
    generateTask(): Request<any> | Promise<Request<any>>;
    collect(): Promise<T[]>;
    take(count: number): Promise<T[]>;
    count(): Promise<number>;
    max(): Promise<T | null>;
    min(): Promise<T | null>;
    mapPartitions<T1>(func: (v: T[]) => T1[] | Promise<T1[]>, env?: FunctionEnv): RDD<T1>;
    glom(): RDD<T[]>;
    map<T1>(func: ((v: T) => T1), env?: FunctionEnv): RDD<T1>;
    reduce(func: ((a: T, b: T) => T), env?: FunctionEnv): Promise<T | null>;
    flatMap<T1>(func: ((v: T) => T1[]), env?: FunctionEnv): RDD<T1>;
    filter(func: (v: T) => boolean, env?: FunctionEnv): RDD<T>;
    distinct(numPartitions?: number): RDD<T>;
    repartition(numPartitions: number): RDD<T>;
    partitionBy(numPartitions: number, partitionFunc: (v: T) => number, env?: FunctionEnv): GeneratedRDD<T>;
    coalesce(numPartitions: number): GeneratedRDD<T>;
    reduceByKey<K, V>(this: RDD<[K, V]>, func: ((a: V, B: V) => V), numPartitions?: number, partitionFunc?: (v: K) => number, env?: FunctionEnv): RDD<[K, V]>;
    combineByKey<K, V, C>(this: RDD<[K, V]>, createCombiner: ((a: V) => C), mergeValue: ((a: C, b: V) => C), mergeCombiners: ((a: C, b: C) => C), numPartitions?: number, partitionFunc?: (v: K) => number, env?: FunctionEnv): RDD<[K, C]>;
    persist(storageType?: StorageType): CacheRDD<T>;
    cache(): CacheRDD<T>;
    union(...others: RDD<T>[]): RDD<T>;
    getNumPartitions(): Promise<number>;
    saveAsTextFile(baseUrl: string, { overwrite, encoding, extension, compressor, functionEnv, }?: {
        overwrite?: boolean;
        encoding?: string;
        extension?: string;
        compressor?: (data: Buffer) => Buffer | Promise<Buffer>;
        functionEnv?: FunctionEnv;
    }): Promise<void>;
    groupWith<K, V, V1>(this: RDD<[K, V]>, other1: RDD<[K, V1]>): RDD<[K, [V[], V1[]]]>;
    groupWith<K, V, V1, V2>(this: RDD<[K, V]>, other1: RDD<[K, V1]>, other2: RDD<[K, V2]>): RDD<[K, [V[], V1[], V2[]]]>;
    groupWith<K, V, V1, V2, V3>(this: RDD<[K, V]>, other1: RDD<[K, V1]>, other2: RDD<[K, V2]>, other3: RDD<[K, V3]>): RDD<[K, [V[], V1[], V2[], V3[]]]>;
    cogroup<K, V, V1>(this: RDD<[K, V]>, other: RDD<[K, V1]>, numPartitions?: number): RDD<[K, [V[], V1[]]]>;
    join<K, V, V1>(this: RDD<[K, V]>, other: RDD<[K, V1]>, numPartitions?: number): RDD<[K, [V, V1]]>;
    leftOuterJoin<K, V, V1>(this: RDD<[K, V]>, other: RDD<[K, V1]>, numPartitions?: number): RDD<[K, [V, V1 | null]]>;
    rightOuterJoin<K, V, V1>(this: RDD<[K, V]>, other: RDD<[K, V1]>, numPartitions?: number): RDD<[K, [V | null, V1]]>;
    fullOuterJoin<K, V, V1>(this: RDD<[K, V]>, other: RDD<[K, V1]>, numPartitions?: number): RDD<[K, [V | null, V1 | null]]>;
    sort(ascending?: boolean, numPartitions?: number): RDD<T>;
    sortBy<K>(keyFunc: (data: T) => K, ascending?: boolean, numPartitions?: number, env?: FunctionEnv): RDD<T>;
}
export declare class GeneratedRDD<T> extends RDD<T> {
    _generateTask: ResponseFactory<T>;
    constructor(context: Context, generateTask: ResponseFactory<T>);
    generateTask(): Request<any> | Promise<Request<any>>;
}
export declare class CacheRDD<T> extends RDD<T> {
    cacheId: number | null;
    dependency: RDD<T>;
    storageType: StorageType;
    constructor(storageType: StorageType, dependency: RDD<T>);
    generateTask(): Promise<Request<any>>;
    unpersist(): Promise<void>;
}
export declare class Context {
    client: Client;
    constructor(c: Client);
    emptyRDD(): RDD<never>;
    range(from: number, to?: number, step?: number, numPartitions?: number): RDD<number>;
    parallelize<T>(arr: T[], numPartitions?: number): RDD<T>;
    union<T>(...rdds: RDD<T>[]): RDD<T>;
    binaryFiles(baseUrl: string, { recursive, }?: {
        recursive?: boolean;
    }): RDD<[string, Buffer]>;
    wholeTextFiles(baseUrl: string, { decompressor, encoding, recursive, functionEnv, }?: {
        encoding?: string;
        recursive?: boolean;
        decompressor?: (data: Buffer, filename: string) => Buffer | Promise<Buffer>;
        functionEnv?: FunctionEnv;
    }): RDD<[string, string]>;
    textFile(baseUrl: string, options?: {
        encoding?: string;
        recursive?: boolean;
        decompressor?: (data: Buffer, filename: string) => Buffer | Promise<Buffer>;
        functionEnv?: FunctionEnv;
        __dangerousDontCopy?: boolean;
    }): RDD<string>;
}
export {};