import {
	Transform,
	AsyncMemberNP,
	PromiseArray,
} from '../functions/asyncFlatMap';
export interface FutureOptions<T> {
	/** Should the executor only be called when this Future is awaited? */
	lazy?: boolean;
	/** how often .poll() is called */
	interval?: number;
	/** @returns a value which resolves this Future, or undefined */
	poll?: () => undefined | PromiseLike<T | undefined>;
	timeout?: number;
}
export declare const TIMEOUT: unique symbol;
export type Executor<T> = (
	resolve: (value: T | PromiseLike<T>) => void,
	reject: (reason?: any) => void
) => any;
export declare const VoidExecutor: Executor<void>;
export type ErrorHandler = (_error: unknown) => any;
export type FutureCallback<T> = (_value: Awaited<T>) => any;
export type Then<T> = (_cb: FutureCallback<T>, _err: ErrorHandler) => any;
export type Thennable<T> = {
	then: Then<T>;
};
export declare class Future<T> implements Promise<T> {
	value: Awaited<T> | undefined;
	reason: any;
	resolved: boolean;
	rejected: boolean;
	callbacks: Set<(self: this) => any>;
	then<TResult1 = T, TResult2 = never>(
		onfulfilled?:
			| ((value: Awaited<T>) => TResult1 | PromiseLike<TResult1>)
			| null
			| undefined,
		onrejected?:
			| ((reason: any) => TResult2 | PromiseLike<TResult2>)
			| null
			| undefined
	): Future<TResult1 | TResult2>;
	catch<TResult = never>(
		onrejected?:
			| ((reason: any) => TResult | PromiseLike<TResult>)
			| null
			| undefined
	): Future<Awaited<T> | TResult>;
	finally(
		onfinally?: ((value?: T) => void | Promise<void | T>) | null | undefined
	): Future<T>;
	await<X>(
		executor_or_promise: Executor<X> | PromiseLike<X> | null | undefined
	): Future<T>;
	asyncFlatMap<R>(
		transform: Transform<T[keyof T & number], AsyncMemberNP<Awaited<R>>>
	): Promise<AsyncMemberNP<Awaited<R>>[]>;
	[Symbol.toStringTag]: string;
	constructor(
		executor_or_promise: Executor<T> | PromiseLike<T>,
		options?: FutureOptions<T>
	);
	protected init_with_executor(executor: Executor<T>): Promise<void>;
	protected init_with_promise(promise: PromiseLike<T>): Promise<void>;
	flush(): void;
	protected resolve(value: T | PromiseLike<T>): Promise<void>;
	protected reject(reason: any): void;
	static resolve<T>(value: T | PromiseLike<T>): Future<T>;
	static reject<T>(reason: any): Future<T>;
	static all<T>(...items: Array<PromiseArray<T>>): Future<T[]>;
	static race<T>(items: Array<T | PromiseLike<T>>): Future<T>;
	/** calls a callback with an awaited value */
	static callback<T>(
		value: T,
		callback?: FutureCallback<T>,
		errorHandler?: ErrorHandler
	): void;
	/** calls a callback after awaiting a Future */
	static callback<T>(
		value: Future<T>,
		callback?: FutureCallback<T>,
		errorHandler?: ErrorHandler
	): void;
	/** calls a callback after awaiting a Promise */
	static callback<T>(
		value: Promise<T>,
		callback?: FutureCallback<T>,
		errorHandler?: ErrorHandler
	): void;
	/**
	 * Transforms a callback consumer call into a `Future`.
	 * # Usage
	 * ```js
	 * function myFunction(callback) {
	 *   if (condition) {
	 *     callback(null, "Success")
	 *   } else {
	 *     callback("Error")
	 *   }
	 * }
	 *
	 * const future = Future.fromCallback(myFunction)
	 * ```
	 * Many [Node APIs](https://docs.nodejs.org/) and [old npm packages](https://npmjs.com/package/imap) behave like this.
	 */
	static fromCallback<T, E = unknown>(
		callback: (callback: (err: E, val: T) => void) => void
	): Future<T>;
	/**
	 * Transforms a callback consumer call into a `Future`.
	 * # Usage
	 * ```js
	 * const myObject = {
	 *   condition: sky.color === blue,
	 *   myMethod(callback) {
	 *     if (this.condition) {
	 *       callback(null, "Success")
	 *     } else {
	 *       callback("Error")
	 *     }
	 *   }
	 * }
	 *
	 * const future = Future.fromCallback(myObject, myObject.myMethod)
	 * ```
	 * Many [Node APIs](https://docs.nodejs.org/) and [old npm packages](https://npmjs.com/package/imap) behave like this.
	 */
	static fromCallback<T, E = unknown>(
		thisArg: object,
		callback: (callback: (err: E, val: T) => void) => void
	): Future<T>;
	_interval?: number;
	_poll?: FutureOptions<T>['poll'];
	_poll_timeout?: ReturnType<typeof setTimeout>;
	/**
	 * calls this Future's poll callback
	 * @returns a Future that resolves to this Future, or undefined
	 */
	poll(): Future<T | undefined>;
	schedule_poll(): void;
}
export declare class LazyFuture<T> extends Future<T> {
	protected init: () => Future<T>;
	callbacks: Set<(self: Future<T>) => any>;
	constructor(
		executor_or_promise: Executor<T> | PromiseLike<T>,
		options?: FutureOptions<T>
	);
	then<TResult1 = T, TResult2 = never>(
		onfulfilled?:
			| ((value: Awaited<T>) => TResult1 | PromiseLike<TResult1>)
			| null
			| undefined,
		onrejected?:
			| ((reason: any) => TResult2 | PromiseLike<TResult2>)
			| null
			| undefined
	): Future<TResult1 | TResult2>;
	/**
	 * Transforms a callback consumer call into a `LazyFuture`.
	 * # Usage
	 * ```js
	 * function myFunction(callback) {
	 *   if (condition) {
	 *     callback(null, "Success")
	 *   } else {
	 *     callback("Error")
	 *   }
	 * }
	 *
	 * const future = LazyFuture.fromCallback(myFunction)
	 * ```
	 * Many [Node APIs](https://docs.nodejs.org/) and [old npm packages](https://npmjs.com/package/imap) behave like this.
	 */
	static fromCallback<T, E = unknown>(
		callback: (callback: (err: E, val: T) => void) => void
	): LazyFuture<T>;
	/**
	 * Transforms a callback consumer call into a `LazyFuture`.
	 * # Usage
	 * ```js
	 * const myObject = {
	 *   condition: sky.color === blue,
	 *   myMethod(callback) {
	 *     if (this.condition) {
	 *       callback(null, "Success")
	 *     } else {
	 *       callback("Error")
	 *     }
	 *   }
	 * }
	 *
	 * const future = LazyFuture.fromCallback(myObject, myObject.myMethod)
	 * ```
	 * Many [Node APIs](https://docs.nodejs.org/) and [old npm packages](https://npmjs.com/package/imap) behave like this.
	 */
	static fromCallback<T, E = unknown>(
		thisArg: object,
		callback: (callback: (err: E, val: T) => void) => void
	): LazyFuture<T>;
}
export default Future;