export type HookPriority = 'high' | 'normal' | 'low';
export interface RequestContext {
    method: string;
    params: Record<string, unknown> | undefined;
    url?: string;
    init?: RequestInit;
    response?: {
        status: number;
    };
    json?: unknown;
}
export type ErrorContext = Partial<RequestContext>;
export type Middleware<C> = (ctx: C, next: () => Promise<void>) => unknown;
export type ErrorHandler = (err: Error, ctx: ErrorContext) => Error | void | Promise<Error | void>;
export interface DispatchErrorContext {
    /** the raw update payload that failed to dispatch, as received from telegram */
    raw: Record<string, unknown>;
}
export type DispatchErrorHandler = (err: Error, ctx: DispatchErrorContext) => unknown;
export interface HookOptions {
    priority?: HookPriority;
}
export type RequestHookName = 'onBeforeRequest' | 'onRequestIntercept' | 'onResponseIntercept' | 'onAfterRequest';
export type LifecycleHookName = 'onInit' | 'onShutdown';
export declare class HookRegistry {
    private readonly request;
    private readonly apiCall;
    private readonly update;
    private readonly init;
    private readonly shutdown;
    private readonly error;
    private readonly dispatchError;
    /** drives the crash-by-default startup warning in `Telegram.bootstrap` */
    get hasDispatchErrorHandler(): boolean;
    add(name: RequestHookName, fn: Middleware<RequestContext>, opts?: HookOptions): void;
    add(name: 'onApiCall', fn: Middleware<RequestContext>, opts?: HookOptions): void;
    add(name: 'onUpdate', fn: Middleware<unknown>, opts?: HookOptions): void;
    add(name: 'onInit' | 'onShutdown', fn: Middleware<{
        tg: unknown;
    }>): void;
    add(name: 'onError', fn: ErrorHandler): void;
    add(name: 'onDispatchError', fn: DispatchErrorHandler): void;
    run(name: RequestHookName, ctx: RequestContext): Promise<void>;
    run(name: 'onUpdate', ctx: unknown): Promise<void>;
    run(name: 'onInit' | 'onShutdown', ctx: {
        tg: unknown;
    }): Promise<void>;
    runApiCall<R>(ctx: RequestContext, action: () => Promise<R>): Promise<R>;
    /** runs onUpdate chain with a fixed slot for `tg.on(...)` handlers between `normal` and `low` */
    runUpdate(ctx: unknown, userHandlers: Middleware<unknown>): Promise<void>;
    runError(err: Error, ctx: ErrorContext): Promise<Error>;
    /** returns true if any onDispatchError handler ran — caller treats the error as observed */
    runDispatchError(err: Error, ctx: DispatchErrorContext): Promise<boolean>;
}
//# sourceMappingURL=hooks.d.ts.map