import { Emitter } from '@deot/helper-emitter';

declare type Add = (arg1: number, arg2: number) => number;

export declare const add: Add;

export declare const alternation: (this: any, ...args: any[]) => any;

export declare abstract class AMonad {
    value: any;
    constructor(value: any);
    abstract toString(): any;
    abstract map(fn: Function): any;
    flatMap(fn: Function): any;
    join(): any;
    valueOf(): any;
}

export declare abstract class APointed {
    value: any;
    constructor(value: any);
    abstract map(fn: Function): any;
    abstract toString(): any;
    valueOf(): any;
}

export declare abstract class ATask extends Emitter {
    _pasuer: Function;
    pasuer: Promise<void>;
    canceler: Promise<void>;
    isCancel: boolean;
    isPasue: boolean;
    suspend(x: any, target?: any): Promise<any>;
    abstract start(...args: any[]): any;
    abstract cancel(...args: any[]): any;
    abstract pasue(...args: any[]): any;
    abstract resume(...args: any[]): any;
    setPasueStatus(status: boolean): void;
    setCancelStatus(status: boolean): void;
    end(): any;
    immediate(): any;
}

export declare const catch$: (this: any, ...args: any[]) => any;

export declare const compose: (...funcs: Function[]) => Function;

export declare const curry: {
    (fn: (...args: any[]) => any): (this: any, ...args: any[]) => any;
    placeholder: any;
};

declare type Divide = (arg1: number, arg2: number) => number;

export declare const divide: Divide;

export declare class Either extends AMonad {
    static of: (fn: Function) => Either;
    static try: (fn: Function) => Either;
    static ok: (value: any) => Either;
    static right: (value: any) => Either;
    static left: (value: any) => Either;
    static error: (value: any) => Either;
    isLeft: boolean;
    isRight: boolean;
    constructor(value: any, isError?: boolean);
    map(fn: Function): Either;
    toString(): string;
}

export declare const filter: (this: any, ...args: any[]) => any;

export declare const fork: (this: any, ...args: any[]) => any;

declare type Func = () => Promise<any>;

export declare const identity: (x: any) => any;

export declare class IO extends AMonad {
    static of(value: any): IO;
    map(fn: Function): IO;
    toString(): string;
    valueOf(): any;
}

export declare class Job extends ATask {
    static of(task: Source, interval?: number): Job;
    original: Source;
    task: Source;
    interval: number;
    isStart: boolean;
    constructor(task: Source, interval?: number);
    process(leaf?: any): any;
    start(): void;
    pasue(): void;
    resume(): void;
    cancel(): void;
    restart(): void;
}

export declare const map: (this: any, ...args: any[]) => any;

export declare class Maybe extends AMonad {
    static of(value: any): Maybe;
    map(fn: Function): Maybe;
    toString(): string;
    isNothing(): boolean;
    isJust(): boolean;
    valueOf(other?: any): any;
}

export declare const memoize: (func: Function, reslover?: Function) => Function;

export declare class Monad extends AMonad {
    static of(value: any): Monad;
    map(fn: Function): Monad;
    toString(): string;
}

declare type Multiply = (arg1: number, arg2: number) => number;

export declare const multiply: Multiply;

export declare class Parallel extends ATask {
    static of(task: Source_2, concurrency?: number, options?: any): Parallel;
    original: Source_2;
    task: Source_2;
    isStart: boolean;
    target: any;
    _target: any;
    tasks: Array<Promise<any> | Task>;
    concurrency: number;
    options: any;
    constructor(task: Source_2, concurrency?: number, options?: any);
    setConcurrency(value: number): number;
    process(): void;
    onFulfilled: (e: any) => void;
    onRejected: (e: any) => void;
    start(): Promise<any>;
    cancel(): Promise<void>;
    pasue(): Promise<void>;
    resume(): void;
    restart(): Promise<any>;
}

export declare const partial: {
    (fn: (...args: any[]) => any, ...partialArgs: any[]): (this: any, ...nextArgs: any[]) => any;
    placeholder: any;
};

export declare const pipe: (...funcs: Function[]) => Function;

export declare class Pointed extends APointed {
    static of(value: any): Pointed;
    map(fn: Function): Pointed;
    toString(): string;
}

export declare const reduce: (this: any, ...args: any[]) => any;

export declare const reverse: (v: any[] | string) => string | any[];

export declare const sequence: (...funcs: Function[]) => (x?: any) => void;

declare type Source = Task | (() => Promise<any>);

declare type Source_2 = Task | Func | (Func | Task)[];

declare type Subtract = (arg1: number, arg2: number) => number;

export declare const subtract: Subtract;

export declare const tap: (this: any, ...args: any[]) => any;

export declare class Task extends AMonad {
    static of(v: any, parent?: any): Task;
    result: any;
    cancelHooks: Function[];
    isCancel: boolean;
    isComplete: boolean;
    isStart: boolean;
    parent: Task | null;
    child: Task | null;
    record: [string, Function] | null;
    ready: Promise<any>;
    _ready: Function;
    pasuer: Promise<void>;
    _pasuer: Function;
    constructor(value: any, parent?: any);
    map(this: any, fn: Function): Task;
    flatMap(fn: Function): any;
    reduce(collection: any[] | ((...args: any[]) => (Promise<any[]> | any[])), done: Function): Task;
    start(): this;
    pasue(): this;
    resume(): this;
    cancel(): this;
    end(): this;
    immediate(): this;
    restart(this: any, v?: any): any;
    toPromise(): any;
    toString(): string;
    valueOf(): any;
}

export declare const then$: (this: any, ...args: any[]) => any;

export { }