import type { CancelCallback, CancelablePromiseCallback, OnProgressCallback, PromiseStatus, SubscriptionParams } from './types';
import { promise_identifier } from './isCancelablePromise';
/**
 * A Promise that can be canceled with lifecycle and progress tracking.
 *
 * CancelablePromise extends the native Promise with additional capabilities:
 * - Cancellation support via `cancel()` method
 * - Status tracking: 'pending', 'resolved', 'rejected', or 'canceled'
 * - Progress reporting through `reportProgress()` and `onProgress()`
 * - Event subscription for cancellation via `onCancel()`
 *
 * @template TResult - The type of value the promise resolves to
 *
 * @example
 * ```ts
 * const promise = new CancelablePromise((resolve, reject, { onCancel, reportProgress }) => {
 *   const timeoutId = setTimeout(() => resolve('Done!'), 5000);
 *
 *   onCancel(() => {
 *     clearTimeout(timeoutId);
 *     console.log('Canceled!');
 *   });
 *
 *   // Report progress
 *   reportProgress(50);
 * });
 *
 * promise
 *   .then(console.log)
 *   .onProgress((progress) => console.log(`${progress}% complete`))
 *   .onCancel((reason) => console.log('Canceled:', reason));
 *
 * // Cancel after 1 second
 * setTimeout(() => promise.cancel('User canceled'), 1000);
 * ```
 *
 * @example
 * ```ts
 * // Canceling from within the executor
 * const promise = new CancelablePromise((resolve, reject, { cancel }) => {
 *   // Some condition triggers cancellation
 *   if (shouldCancel) {
 *     cancel('Canceled internally');
 *     return;
 *   }
 *   resolve('Success');
 * });
 * ```
 */
export declare class CancelablePromise<TResult = void> extends Promise<TResult> {
    protected [promise_identifier]: boolean;
    /**
     * The current status of the promise.
     */
    status: PromiseStatus;
    private cancelCallbacks;
    private ownCancelCallbacks;
    private onProgressCallbacks;
    private disposeCallbacks;
    private _resolve;
    private _reject;
    constructor(callback: CancelablePromiseCallback<TResult>);
    private subscribeToOwnCancelEvent;
    /**
     * Cancel the promise and all the chained promises.
     * @param {unknown} [reason] the reason of the cancellation
     * @returns {CancelablePromise} the promise itself
     * */
    cancel(reason?: unknown): CancelablePromise<TResult>;
    /**
     * Subscribe to the cancel event of the promise.
     * @param {CancelCallback} [callback] the callback to be called when the promise is canceled
     * @returns {CancelablePromise} the promise itself
     * */
    onCancel(callback: CancelCallback, { signal }?: SubscriptionParams): CancelablePromise<TResult>;
    /**
     * This method allows to report the progress across the chain of promises.
     * */
    onProgress(callback: OnProgressCallback, { signal }?: SubscriptionParams): CancelablePromise<TResult>;
    /**
     * This allows to report progress across the chain of promises,
     * this is useful when you have an async operation that could take a long time and you want to report the progress to the user.
     */
    reportProgress(percentage: number, metadata?: unknown): this;
    private createChildPromise;
    /**
     * Returns a Promise that resolves or rejects as soon as the previous promise is resolved or rejected,
     * with cancelable promise you can call the cancel method on the child promise to cancel all the parent promises.
     * @param {((value: TResult) => TResult1 | PromiseLike<TResult1>) | undefined | null} [onfulfilled] the callback to be called when the promise is resolved
     * @param {((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null} [onrejected] the callback to be called when the promise is rejected
     * @returns {CancelablePromise<TResult1 | TResult2>} the cancelable promise
     * @example
     * const promise = new CancelablePromise((resolve, reject, utils) => {
     *  setTimeout(() => {
     *   resolve('resolved');
     *  }, 1000);
     * });
     *
     * const childPromise = promise.then((value) => {
     *  console.log(value); // 'resolved'
     * });
     *
     * childPromise.cancel();
     * console.log(childPromise.status); // 'canceled'
     * console.log(promise.status); // 'canceled'
     */
    then: <TResult1 = TResult, TResult2 = never>(onfulfilled?: ((value: TResult) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null) => CancelablePromise<TResult1 | TResult2>;
    /**
     * Returns a Promise that resolves when the previous promise is rejected,
     * with cancelable promise you can call the cancel method on the child promise to cancel all the parent promises.
     * @param {((reason: any) => T | PromiseLike<T>) | undefined | null} [onrejected] the callback to be called when the promise is rejected
     * @returns {CancelablePromise<T>} the cancelable promise
     * @example
     * const promise = new CancelablePromise((resolve, reject, utils) => {
     *  setTimeout(() => {
     *    reject('rejected');
     *  }, 1000);
     * });
     *
     * const childPromise = promise.catch(() => {
     *  console.log(childPromise.status); // 'canceled'
     *  console.log(promise.status); // 'canceled'
     * });
     *
     * childPromise.cancel();
     * */
    catch: <T = unknown>(onrejected?: (reason: unknown) => T | PromiseLike<T>) => CancelablePromise<TResult | T>;
    /**
     * Subscribe a callback to be called when the promise is resolved or rejected,
     */
    finally: (onfinally?: (() => void) | undefined | null) => CancelablePromise<TResult>;
    /**
     * Statics
     */
    static resolve(): CancelablePromise<void>;
    static resolve<TResult>(value: TResult): CancelablePromise<Awaited<TResult>>;
    static resolve<TResult>(value: TResult | PromiseLike<TResult>): CancelablePromise<Awaited<TResult>>;
    static reject: (reason?: unknown) => CancelablePromise<never>;
    /**
     * Returns a Promise object with status 'canceled'.
     */
    static canceled: (reason?: unknown) => CancelablePromise<never>;
    /**
     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved or rejected.
     * If the race is canceled, all the promises are canceled.
     */
    static race: <TResult_1>(values: (TResult_1 | PromiseLike<TResult_1> | CancelablePromise<TResult_1>)[]) => CancelablePromise<Awaited<TResult_1>>;
    /**
     * Creates a Promise that is resolved with an array of results when all of the provided Promises resolve, or rejected when any Promise is rejected.
     * If the all is canceled, all the promises are canceled.
     */
    static all: <TSource extends [] | readonly unknown[]>(values: TSource) => CancelablePromise<{ -readonly [P in keyof TSource]: Awaited<TSource[P]>; }>;
    /**
     * Creates a Promise that is resolved with an array of results when all
     * of the provided Promises resolve or reject.
     * If the allSettled is canceled, all the promises are canceled.
     * @param values An array of Promises.
     * @returns A new Promise.
     */
    static allSettled: <TResult_1 extends [] | readonly unknown[]>(values: TResult_1) => CancelablePromise<{ -readonly [P in keyof TResult_1]: PromiseSettledResult<Awaited<TResult_1[P]>>; }>;
}
/**
 * Convert a value to a CancelablePromise, the value can be a Promise/CancellablePromise or a value.
 * @param {unknown} source the value to convert
 * @returns {TCancelablePromise<T>} the CancelablePromise
 * @example
 * const promise = new Promise((resolve) => {
 * setTimeout(() => {
 * resolve('hello world');
 * }, 1000);
 * });
 * const cancelablePromise = toCancelablePromise(promise);
 * cancelablePromise.onCancel(() => {
 * console.log('promise canceled');
 * });
 * cancelablePromise.cancel();
 * // promise canceled
 * */
export declare const toCancelablePromise: <T = unknown, TResult = T extends Promise<unknown> ? CancelablePromise<Awaited<T>> : CancelablePromise<T>>(source: T) => CancelablePromise<TResult>;
export default CancelablePromise;