import { AsyncSeriesBailHook, AsyncSeriesHook } from './tapable/index';
import { LifecycleFns, LifecycleFn, AppTimeouts, LifecycleOptions } from './Def';
import type { AppError } from './AppError';
import { ProtectedEventEmitter } from './utils/ProtectedEventEmitter';
import { Debugger } from './utils/Debugger';
export interface LifecycleEvent {
    beforeload: void;
    afterload: void;
    loaderror: AppError;
    beforebootstrap: void;
    afterbootstrap: void;
    bootstraperror: AppError;
    beforemount: void;
    aftermount: void;
    mounterror: AppError;
    beforeunmount: void;
    afterunmount: void;
    unmounterror: AppError;
    beforeupdate: void;
    afterupdate: void;
    updateerror: AppError;
}
export declare type LifecycleHooks<CustomProps> = {
    beforeload: AsyncSeriesHook<void>;
    afterload: AsyncSeriesHook<void>;
    loaderror: AsyncSeriesHook<AppError>;
    beforebootstrap: AsyncSeriesHook<void>;
    afterbootstrap: AsyncSeriesHook<void>;
    bootstraperror: AsyncSeriesHook<AppError>;
    beforemount: AsyncSeriesHook<void>;
    aftermount: AsyncSeriesHook<void>;
    mounterror: AsyncSeriesHook<AppError>;
    beforeunmount: AsyncSeriesHook<void>;
    afterunmount: AsyncSeriesHook<void>;
    unmounterror: AsyncSeriesHook<AppError>;
    beforeupdate: AsyncSeriesHook<void>;
    afterupdate: AsyncSeriesHook<void>;
    updateerror: AsyncSeriesHook<AppError>;
    load: AsyncSeriesBailHook<void, LifecycleFns<CustomProps> | void>;
    bootstrap: AsyncSeriesBailHook<void, unknown>;
    mount: AsyncSeriesBailHook<void, unknown>;
    unmount: AsyncSeriesBailHook<void, unknown>;
    update: AsyncSeriesBailHook<{
        params: CustomProps;
    }, unknown>;
};
export interface LifecycleShadow<CustomProps> {
    rootDOM: Element | null;
    hooks: LifecycleHooks<CustomProps>;
    customProps: CustomProps;
    readonly fns: {
        call: (fnName: keyof LifecycleFns<CustomProps>, arg: CustomProps, allowUndefined?: boolean, each?: (index: number, total: number) => void) => ReturnType<LifecycleFn<CustomProps>>;
    };
    readonly on: <T extends keyof LifecycleEvent>(event: T, listener: (event: LifecycleEvent[T]) => unknown, context?: unknown) => this;
    readonly once: <T extends keyof LifecycleEvent>(event: T, listener: (event: LifecycleEvent[T]) => unknown, context?: unknown) => this;
    readonly off: <T extends keyof LifecycleEvent>(event: T, listener: (event: LifecycleEvent[T]) => unknown, context?: unknown) => this;
}
export declare class Lifecycle<CustomProps> extends Debugger implements ProtectedEventEmitter<LifecycleEvent> {
    #private;
    hooks: LifecycleHooks<CustomProps>;
    constructor(def: LifecycleOptions<CustomProps>, rootDOM: string | Element);
    protected get debugName(): string;
    get customProps(): CustomProps;
    get options(): LifecycleOptions<CustomProps>;
    get timeouts(): AppTimeouts;
    get name(): string;
    get [Symbol.toStringTag](): string;
    toString(): string;
    get rootDOM(): Element | null;
    on<T extends keyof LifecycleEvent>(event: T, listener: (event: LifecycleEvent[T]) => unknown, context?: unknown): this;
    once<T extends keyof LifecycleEvent>(event: T, listener: (event: LifecycleEvent[T]) => unknown, context?: unknown): this;
    off<T extends keyof LifecycleEvent>(event: T, listener: (event: LifecycleEvent[T]) => unknown, context?: unknown): this;
    get export(): LifecycleShadow<CustomProps>;
    /**
     * Load lifecycle function from lifecycle, assetsMap or entry.
     *
     * This function is concurrency-safe, for independent preload.
     * @returns void
     */
    load(): Promise<void>;
    mount(): Promise<void>;
    bootstrap(): Promise<void>;
    unmount(): Promise<void>;
    update(customProps: CustomProps): Promise<void>;
    /**
     * Clear all states.
     * @returns Promise<void>
     */
    clear(): Promise<unknown> | unknown;
}