type ResolveFn<T> = (value?: T | PromiseLike<T>) => void;
type RejectFn = (reason?: any) => void;
export declare class SyncPromise<T = unknown> implements PromiseLike<T> {
    private state;
    private value;
    private handlers;
    constructor(executor: (resolve: ResolveFn<T>, reject: RejectFn) => void);
    private _resolve;
    private _reject;
    private _executeHandlers;
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): SyncPromise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): SyncPromise<T | TResult>;
    finally(onfinally?: (() => void) | null): SyncPromise<T>;
    static resolve<T>(value?: T | PromiseLike<T>): SyncPromise<T>;
    static reject(reason?: any): SyncPromise<never>;
    static all<T>(promises: (T | PromiseLike<T>)[]): SyncPromise<T[]>;
    static allSettled<T>(promises: (T | PromiseLike<T>)[]): SyncPromise<{
        status: "fulfilled" | "rejected";
        value?: T;
        reason?: any;
    }[]>;
    static race<T>(promises: (T | PromiseLike<T>)[]): SyncPromise<T>;
}
type SettledPromProps<T> = {
    settled: boolean;
    onSettled: Promise<void>;
    res: (t: T) => void;
    rej: (err: any) => void;
};
type ResablePromProps<T> = {
    res: (t: T) => void;
    rej: (err: any) => void;
};
type CancelAblePromProps<T, C, CT> = {
    cancel: (reason: C) => CT;
    cancelled: boolean;
    onCancel: Promise<{
        reason: C;
        cancelResult: CT;
    }>;
};
interface SettledPromiseConstructor {
    new <T = void>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): SettledPromise<T>;
    prototype: SettledPromise;
}
export declare const SettledPromise: SettledPromiseConstructor;
export type SettledPromise<T = unknown> = SettledPromProps<T> & {
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): SettledPromise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): SettledPromise<T | TResult>;
    finally(onfinally?: (() => void) | undefined | null): SettledPromise<T>;
} & Promise<T>;
export type ResablePromise<T = unknown> = SettledPromProps<T> & ResablePromProps<T> & {
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): ResablePromise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): ResablePromise<T | TResult>;
    finally(onfinally?: (() => void) | undefined | null): ResablePromise<T>;
} & Promise<T>;
interface ResablePromiseConstructor {
    new <T = void>(executor?: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): ResablePromise<T>;
    prototype: ResablePromise;
}
export declare const ResablePromise: ResablePromiseConstructor;
export type CancelFunc<C, CT> = (reason: C) => CT;
export type CancelAblePromise<T = unknown, C = void, CT = C> = SettledPromProps<T> & ResablePromProps<T> & CancelAblePromProps<T, C, CT> & {
    then<TResult1 = T, TResult2 = never, newC extends C = C, newCT extends CT = CT>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null, onCancelForward?: true): CancelAblePromise<TResult1 | TResult2, newC, newCT>;
    then<TResult1 = T, TResult2 = never, newC = void, newCT = newC>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null, onCancel?: (reason: newC) => newCT): CancelAblePromise<TResult1 | TResult2, newC, newCT>;
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): CancelAblePromise<T | TResult>;
    finally(onfinally?: (() => void) | undefined | null): CancelAblePromise<T>;
} & Promise<T>;
interface CancelAblePromiseConstructor {
    new <T = void, C = void, CT = C>(executor?: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => (CancelFunc<C, CT> | any), cancel?: (reason: C) => void): CancelAblePromise<T, C, CT>;
    prototype: CancelAblePromise;
}
export declare const CancelAblePromise: CancelAblePromiseConstructor;
export type SettledSyncPromise<T = unknown> = SettledPromProps<T> & {
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): SettledSyncPromise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): SettledSyncPromise<T | TResult>;
    finally(onfinally?: (() => void) | undefined | null): SettledSyncPromise<T>;
} & SyncPromise<T>;
interface SettledSyncPromiseConstructor {
    new <T = void>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): SettledSyncPromise<T>;
    prototype: SettledSyncPromise;
}
export declare const SettledSyncPromise: SettledSyncPromiseConstructor;
export type ResableSyncPromise<T = unknown> = SettledPromProps<T> & ResablePromProps<T> & {
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): ResableSyncPromise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): ResableSyncPromise<T | TResult>;
    finally(onfinally?: (() => void) | undefined | null): ResableSyncPromise<T>;
} & SyncPromise<T>;
interface ResableSyncPromiseConstructor {
    new <T = void>(executor?: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): ResableSyncPromise<T>;
    prototype: ResableSyncPromise;
}
export declare const ResableSyncPromise: ResableSyncPromiseConstructor;
export type CancelAbleSyncPromise<T = unknown, C = void, CT = C> = SettledPromProps<T> & ResablePromProps<T> & CancelAblePromProps<T, C, CT> & {
    then<TResult1 = T, TResult2 = never, newC extends C = C, newCT extends CT = CT>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null, onCancelForward?: true): CancelAblePromise<TResult1 | TResult2, newC, newCT>;
    then<TResult1 = T, TResult2 = never, newC = void, newCT = newC>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null, onCancel?: (reason: newC) => newCT): CancelAbleSyncPromise<TResult1 | TResult2, newC, newCT>;
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): CancelAbleSyncPromise<T | TResult>;
    finally(onfinally?: (() => void) | undefined | null): CancelAbleSyncPromise<T>;
} & SyncPromise<T>;
interface CancelAbleSyncPromiseConstructor {
    new <T = unknown, C = void, CT = C>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => (CancelFunc<C, CT> | any), cancel?: (reason: C) => void): CancelAbleSyncPromise<T, C, CT>;
    prototype: CancelAbleSyncPromise;
}
export declare const CancelAbleSyncPromise: CancelAbleSyncPromiseConstructor;
export {};