// Generated by dts-bundle-generator v5.5.0

declare class TsundereEventEmitter {
	protected e: Record<string, any[]>;
	/**
	 * Chainable function to add new event listener,
	 * available events are `start`, `end`, `error`. COnsider using `once`
	 */
	on: (event: string, fn: Function, ctx?: any) => this;
	/**
	 * Chainable function to add new event listener,
	 * which will happen only once then gets deleted from the task instance.
	 */
	once: (event: string, fn: Function, ctx?: any) => any;
	/**
	 * Internal function used by `<class>.once`
	 * in order to stop all listeners from a single event.
	 * @private
	 */
	private off;
	/**
	 * Emit new node-browser-compatible event.
	 */
	emit: (event: string, ...args: any) => void;
}
/**
 * Asynchrounous by default function with unsized props `K`,
 * returning a `T` typed value from a promise.
 */
export declare type TsundereCallback<T = any, K = Record<string, any>> = (props?: K) => Promise<T>;
/**
 * Task completion status report
 */
export declare type TsundereTaskReport<T = any> = {
	label: string | undefined;
	/**
	 * Task callback returned value, or sub-tasks report array (mostly relevant for tasks
	 * instanciated via `<TsundereRunner>.parallel` or `<TsundereRunner>.series`).
	 */
	result: T | TsundereTaskReport[];
	/**
	 * Task duration in milliseconds
	 */
	duration: number;
	list?: () => Array<any>;
};
/**
 * Nameless Tsundere compatible task object, which emits events
 * (`start`, `end`, `error`) you can subscribe to, using browser-compatible
 * event subscribers `<TsundereTask>.on('<event>', callback)`
 * or `<TsundereTask>.once('<event>', callback)`
 *
 * The `T` generic type (defaults to `any`) defines the expected returned
 * value type from the task callback promise.
 */
export declare class TsundereTask<T = any> extends TsundereEventEmitter {
	label: string | undefined;
	/**
	 * Hook function to be run by the task.
	 */
	callback: TsundereCallback;
	constructor(callback: TsundereCallback<T>);
	/**
	 * Runs the task and returns a task report with calculated duration and
	 * sub-tasks reports, if exists.
	 */
	run: (props?: Record<string, any> | undefined) => Promise<TsundereTaskReport<T>>;
}
/**
 * Shortcut method for creating a nameless `TsundereTask` instance
 */
export declare function task<T = any>(callback: TsundereCallback<T>): TsundereTask<T>;
/**
 * Label a `TsundereTask`-based task
 */
export declare function describe<T = any>(name: string, callback: TsundereCallback<T>): TsundereTask<T>;
export interface TsundereAction {
	type: string;
	payload: Record<string, any>;
}
declare class TsundereStore extends TsundereEventEmitter {
	private __state;
	private __commits;
	getState: () => Record<string, any>;
	private commit;
	dispatch(action: TsundereAction): Record<string, any>;
}
/**
 * Returns a standalone `TsundereTask` running registered sub-tasks in sequence.
 * @example
 * const suite = series([taskA, taskB])
 */
export declare function series(tasks: TsundereTask[], props?: any): Promise<TsundereTaskReport[]>;
/**
 * Returns a standalone `TsundereTask` running registered sub-tasks in parallel.
 * @example
 * const suite = parallel([taskA, taskB, taskC])
 */
export declare function parallel(tasks: TsundereTask[], props?: any): Promise<TsundereTaskReport[]>;
/**
 * Label a newly created concurrent `TsundereTask` suite
 */
export declare function describeParallel(name: string, tasks: TsundereTask[]): TsundereTask<any>;
/**
 * Label a newly created sequential `TsundereTask` suite
 */
export declare function describeSeries(name: string, tasks: TsundereTask[]): TsundereTask<any>;
/**
 * Stateful `TsundereTask` runner system, which provides a **Gulp**-like API
 * with `task`, `series` and `parallel` methods which register tasks to be run
 * in parallel via `<TsundereRunner>.run()`
 *
 * @example
 * import { TsundereRunner, task } from 'tsundere'
 *
 * const runner = new TsundereRunner()
 *
 * // Wait for milliseconds then resolve a Promise
 * function timeout(ms) {
 *   return new Promise(resolve => setTimeout(resolve, ms));
 * }
 *
 * // Promise callback
 * function log(char) {
 *   console.log(char)
 *   return () => char
 * }
 *
 * runner.task(async () => await timeout(1500).then(log('A')))
 *
 * runner.series([
 *   task(async () => await timeout(1000).then(log('B'))),
 *   task(async () => await timeout(3000).then(log('C')))
 * ])
 *
 * runner.parallel([
 *   task(async () => await timeout(700).then(log('D'))),
 *   task(async () => await timeout(1300).then(log('E')))
 * ])
 *
 * // This will log 'D' -> 'B' -> 'A' -> 'E' -> 'C' ...
 * runner.run().then(report => {
 *     // Then will display the task suite report.
 *     console.log(report)
 * })
 *
 */
export declare class TsundereRunner extends TsundereStore {
	/**
	 * Registered findable tasks inside the task runner
	 */
	tasks: TsundereTask[];
	private __seq;
	private __auto_sub;
	private __auto_sub_task;
	private __auto_sub_end;
	private __group_task;
	private __group_auto_sub_task;
	/**
	 * Register a newly created nameless task and set up
	 * and bind events to the task runner instance.
	 */
	task: (callback: TsundereCallback) => this;
	/**
	 * Label and register a newly created single task and
	 * bind events to the task runner instance.
	 */
	describe: (name: string, callback: TsundereCallback) => Promise<this>;
	/**
	 * Label and register a newly created task including sequential sub-tasks.
	 * Can be used to explicitly tell the task runner to be aware of its
	 * sub-tasks when returning the final report.
	 *
	 * @example
	 * ```js
	 * import { TsundereRunner, describeParallel, describe, parallel } from 'tsundere'
	 * const runner = new TsundereRunner()
	 *
	 * runner.describe("my-suite", async () => await parallel[  // ✅ Registered
	 *   describe('task-A', ... ),                              // ❌ Not registered
	 *   describe('task-B', ... )                               // ❌ Not registered
	 * ])
	 *
	 * runner.describeParallel("my-suite", [    // ✅ Registered
	 *   describe('task-C', ... ),              // ✅ Registered
	 *   describe('task-D', ... ),              // ✅ Registered
	 * ])
	 * ```
	 */
	describeParallel: (name: string, tasks: TsundereTask[]) => Promise<this>;
	/**
	 * Label and register a newly created task  including sequential sub-tasks.
	 * Can be used to explicitly tell the task runner to be aware of its
	 * sub-tasks when returning the final report.
	 *
	 * @example
	 * ```js
	 * import { TsundereRunner, describeParallel, describe, series } from 'tsundere'
	 * const runner = new TsundereRunner()
	 *
	 * runner.describe("my-suite", async () => await series[  // ✅ Registered
	 *   describe('task-A', ... ),                            // ❌ Not registered
	 *   describe('task-B', ... )                             // ❌ Not registered
	 * ])
	 *
	 * runner.describeSeries("my-suite", [    // ✅ Registered
	 *   describe('task-C', ... ),            // ✅ Registered
	 *   describe('task-D', ... ),            // ✅ Registered
	 * ])
	 * ```
	 */
	describeSeries: (name: string, tasks: TsundereTask[]) => Promise<this>;
	/**
	 * Register newly created task including concurrent sub-tasks.
	 * Can be used to explicitly tell the task runner to be aware of its
	 * sub-tasks when returning the final report.
	 *
	 * @example
	 * ```js
	 * import { TsundereRunner, describe, parallel, task } from 'tsundere'
	 * const runner = new TsundereRunner()
	 *
	 * runner.task(async () => await parallel([   // ✅ Registered
	 *   describe('task-A', ... ),                // ❌ Not registered
	 *   describe('task-B', ... )                 // ❌ Not registered
	 * ])
	 *
	 * runner.parallel([               // ✅ Registered
	 *   describe('task-C', ... ),     // ✅ Registered
	 *   describe('task-D', ... ),     // ✅ Registered
	 * ])
	 * ```
	 */
	parallel: (tasks: TsundereTask[]) => Promise<this>;
	/**
	 * Register newly created task including sequential sub-tasks.
	 * Can be used to explicitly tell the task runner to be aware of its
	 * sub-tasks when returning the final report.
	 *
	 * @example
	 * ```js
	 * import { TsundereRunner, describe, series, task } from 'tsundere'
	 * const runner = new TsundereRunner()
	 *
	 * runner.task(async () => await series[   // ✅ Registered
	 *   describe('task-A', ... ),             // ❌ Not registered
	 *   describe('task-B', ... )              // ❌ Not registered
	 * ])
	 *
	 * runner.series([               // ✅ Registered
	 *   describe('task-C', ... ),   // ✅ Registered
	 *   describe('task-D', ... ),   // ✅ Registered
	 * ])
	 * ```
	 */
	series: (tasks: TsundereTask[]) => Promise<this>;
	/**
	 * Run registered tasks in parallel
	 */
	run: () => Promise<TsundereTaskReport<any>[]>;
}
declare const _default: {
	TsundereRunner: typeof TsundereRunner;
	TsundereTask: typeof TsundereTask;
	Runner: typeof TsundereRunner;
	series: typeof series;
	parallel: typeof parallel;
	task: typeof task;
	describe: typeof describe;
	Task: typeof TsundereTask;
	describeParallel: typeof describeParallel;
	describeSeries: typeof describeSeries;
};
export default _default;

export {
	TsundereCallback as Callback,
	TsundereRunner as Runner,
	TsundereTask as Task,
	TsundereTaskReport as TaskReport,
};

export {};