export declare type CallbackGroup = {
    /**
     * add callback into the group and return `remove` function
     * @param callback
     */
    add(callback: Function): VoidFunction;
    called(): number;
    /**
     * call all callbacks with specified args
     * @param args
     */
    call(...args: any[]): void;
    /**
     * remove all callbacks
     */
    clear(): void;
    size(): number;
};
export declare type Payload<T> = T | Promise<T> | ((context: EffectContext) => T | Promise<T>);
export declare type Signal<TPayload, TDefaultPayload = TPayload | undefined> = {
    (payload: Payload<TPayload>): void;
    (payload: Payload<TPayload>, noDispose: boolean): void;
    key: string | undefined;
    payload(): TDefaultPayload;
    onEmit(listener: VoidFunction): VoidFunction;
    onLoading(listener: (promise: Promise<void>) => void): VoidFunction;
    onError(listener: (error: any) => void): VoidFunction;
    error(): any;
    cancel(): void;
    async(): Promise<void> | undefined;
    cancelled(): boolean;
    reset(): void;
    reset(removeAllListeners: boolean): void;
};
export declare type CreateSignal = {
    <T = void>(): Signal<T>;
    <T>(options: SignalOptionsWithPayload<T>): Signal<T, T>;
    <T = void>(options: SignalOptions): Signal<T>;
};
export declare type SignalList<T = any> = Signal<T> | (Signal<T> | SignalList<T>)[];
export declare type SignalOptions = {
    key?: string;
    onError?: (error: any) => void;
    onCancel?: VoidFunction;
};
export declare type SignalOptionsWithPayload<T> = SignalOptions & {
    payload: T;
};
export declare type UseSignalOptions = {
    suspense?: boolean;
    errorBoundary?: boolean;
};
export declare type AnySignal = Signal<any>;
export declare type ChainOptions = {};
export declare type WaitOptions = {
    onError?: (...signal: AnySignal[]) => void;
    onDone?: (...signal: AnySignal[]) => void;
};
export declare type EffectContext = {
    promise?: CancellablePromise<any>;
    abortController(): AbortController | undefined;
    /**
     * cancel current execution
     */
    cancel(): void;
    /**
     *
     */
    cancelled(): boolean;
    /**
     *
     * @param listener
     */
    onCancel(listener: VoidFunction): VoidFunction;
    /**
     *
     */
    dispose(): void;
    /**
     *
     * @param promise
     */
    when<T>(promise: Promise<T>): Promise<T>;
    /**
     *
     * @param signal
     * @param options
     */
    when<T>(signal: Signal<T>, options?: WaitOptions): Promise<T>;
    /**
     *
     * @param signals
     * @param options
     */
    all<T extends Record<string, AnySignal | Promise<any>>>(signals: T, options?: WaitOptions): Promise<{
        [key in keyof T]: T[key] extends Promise<infer V> ? Signal<V, V> : T[key];
    }>;
    /**
     *
     * @param signal
     * @param callback
     */
    on<T extends AnySignal>(signal: T, callback: (signal: T) => void): VoidFunction;
    /**
     *
     * @param signals
     * @param callback
     */
    on(signals: SignalList, callback: (signal: AnySignal) => void): VoidFunction;
    /**
     *
     * @param signals
     * @param options
     */
    race<T extends Record<string, AnySignal | Promise<any>>>(signals: T, options?: WaitOptions): Promise<Partial<{
        [key in keyof T]: T[key] extends Promise<infer V> ? Signal<V, V> : T[key];
    }>>;
    /**
     *
     * @param fn
     * @param args
     */
    call<A extends any[], R>(fn: (context: EffectContext, ...args: A) => R, ...args: A): R;
    /**
     * create a promise that awaits signal chain
     * @param signals
     */
    chain(signals: ChainItem[]): Promise<AnySignal>;
    /**
     *
     * @param effect
     * @param args
     */
    fork<T, A extends any[]>(effect: (context: EffectContext, ...args: A) => Exclude<Payload<T>, Function>, ...args: A): Signal<T>;
    /**
     *
     * @param payload
     */
    fork<T>(payload: Exclude<Payload<T>, Function>): Signal<T>;
};
export declare type CancellablePromise<T = unknown> = Promise<T> & {
    cancel(): void;
};
export declare type NoInfer<T> = [T][T extends any ? 0 : never];
export declare type ChainItemResult = AnySignal | SignalList | void | "restart";
export declare type ChainItem = AnySignal | SignalList | ((prev: AnySignal) => ChainItemResult | Promise<ChainItemResult>);
export declare const isSignal: <T = any>(value: any) => value is Signal<T, T | undefined>;
export declare const isPromiseLike: <T>(value: any) => value is Promise<T>;
export declare const delay: <T>(ms?: number, value?: T | undefined) => CancellablePromise<T>;
/**
 *
 * @param payload
 * @param args
 * @returns
 */
export declare const spawn: <T, A extends any[]>(payload: (context: EffectContext, ...args: A) => Promise<T> | Exclude<T, Function>, ...args: A) => Signal<T, T | undefined>;
export declare const cancelAll: (...signals: AnySignal[]) => void;
export declare const signal: CreateSignal;
export declare const useSignal: (signals: SignalList, { suspense, errorBoundary }?: UseSignalOptions) => void;