/**
 * The signature of resolve function for Promise.
 */
export interface PromiseResolver<T> {

    (val?: T): void;
}

/**
 * The signature of reject function for Promise.
 */
export interface PromiseRejector<T> {

    (err: T): void;
}

/**
 * Type for the string-index dictionary object.
 */
export interface Dictionary<T> {

    [key: string]: T;
}

/**
 * Type for the number-index dictionary object.
 */
export interface NumericDictionary<T> {

    [key: number]: T;
}

/**
 * The signature of a no data bound asynchronous callback.
 */
export interface AsyncErrorCallback<E> {

    (error?: E): void;
}

/**
 * The signature of a no data bound asynchronous callback.
 */
export interface RetryCallback<E> {

    (error?: E, quit?: boolean): void;
}

/**
 * The signature of a data bound asynchronous callback.
 */
export interface SeriesNextCallback<E> {

    (error?: E, ...args: any[]): void;
}

/**
 * The signature of simple functions for controlling callback.
 */
export interface SeriesFunction<E> {

    (next: SeriesNextCallback<E>, ...args: any[]): void;
}

/**
 * The signature of the iterator function of list.forEach.
 */
export interface ForEachIterator<T, E> {

    (val: T, key: string | number, next: AsyncErrorCallback<E>): void;
}

/**
 * The signature of the next callback function of list.map.
 */
export interface MapNextCallback<T, E> {

    (error: E, val?: T): void;
}

/**
 * The signature of the result callback of list.map.
 */
export interface MapResultCallback<T, E> {

    (error: E, vals?: Dictionary<T> | T[]): void;
}

/**
 * The signature of the iterator function of list.map.
 */
export interface MapIterator<T, E> {

    (val: T, key: string | number, next: MapNextCallback<T, E>): void;
}

export interface ISetNextTick {

    (fn: Function, ...args: any[]): void;
}

/**
 * The signature of simple functions for controlling callback.
 */
export interface SimpleFunction<E> {

    (next: AsyncErrorCallback<E>): void;
}

export interface FlowNextCallback<E> {

    (next: string, error?: E, ...args: any[]): void;
}

export interface FlowFunction<E> {

    (next: FlowNextCallback<E>, ...args: any[]): void;
}

export interface ParallelCallback<E> {

    (err?: NumericDictionary<E>): void;
}

export interface SyncConditionTester {

    (): boolean;
}

export interface BooleanCallback {

    (result: boolean): void;
}

export interface ConditionTester {

    (cb: BooleanCallback): void;
}

/**
 * The signature for worker function of retry.
 *
 * The second parameter tells the sequence for retrying.
 * And sequence === 0 means the first time before retrying.
 */
export interface RetryWorker<E> {

    (next: RetryCallback<E>, sequence: number): void;
}

export type RepeatWorker<E> = RetryWorker<E>;