import type { OptionalField, Resolvable } from './common-types.js';
import type { Result, Tx } from '../database-layer/db.js';
import type { ODataRequest, ParsedODataRequest } from './uri-parser.js';
import type { AnyObject } from 'pinejs-client-core';
import { type User, type ApiKey, api, type Response } from './sbvr-utils.js';
export interface HookReq {
    user?: User;
    apiKey?: ApiKey;
    method: string;
    url: string;
    query: AnyObject;
    params: AnyObject;
    body: AnyObject;
    custom?: AnyObject;
    tx?: Tx;
    hooks?: InstantiatedHooks;
    is?: (type: string | string[]) => string | false | null;
}
export interface HookArgs<Vocab extends string = string> {
    req: HookReq;
    request: ODataRequest;
    api: (typeof api)[Vocab];
    tx?: Tx | undefined;
}
export type HookResponse = PromiseLike<any> | null | void;
export interface Hooks<Vocab extends string = string> {
    PREPARSE?: (options: Omit<HookArgs<Vocab>, 'request' | 'api'>) => HookResponse;
    POSTPARSE?: (options: HookArgs<Vocab>) => HookResponse;
    PRERUN?: (options: HookArgs<Vocab> & {
        tx: Tx;
    }) => HookResponse;
    POSTRUN?: (options: HookArgs<Vocab> & {
        tx: Tx;
        result: Result | number | undefined;
    }) => HookResponse;
    PRERESPOND?: (options: HookArgs<Vocab> & {
        tx: Tx;
        result?: Result | number | AnyObject;
        response: Response;
    }) => HookResponse;
    'POSTRUN-ERROR'?: (options: HookArgs<Vocab> & {
        tx: Tx;
        error: unknown;
    }) => HookResponse;
}
export type HookBlueprints = {
    [key in keyof Hooks]: Array<HookBlueprint<NonNullable<Hooks[key]>>>;
};
export type RollbackAction = () => Resolvable<void>;
export type HookFn = (...args: any[]) => any;
export interface HookBlueprint<T extends HookFn> {
    hookFn: T;
    sideEffects: boolean;
    readOnlyTx: boolean;
}
export type InstantiatedHooks = {
    [key in keyof Hooks]: Array<Hook<NonNullable<Hooks[key]>>>;
};
declare class Hook<T extends HookFn> {
    private hookFn;
    readOnlyTx: HookBlueprint<T>['readOnlyTx'];
    constructor(hook: HookBlueprint<T>);
    run(...args: any[]): Promise<void>;
}
export declare const rollbackRequestHooks: <T extends InstantiatedHooks>(hooksList: Array<[modelName: string, hooks: T]> | undefined) => void;
export type HookMethod = keyof typeof apiHooks;
export declare const getHooks: {
    (request: Pick<OptionalField<ParsedODataRequest, "resourceName">, "resourceName" | "method" | "vocabulary">, includeAllVocab: boolean): InstantiatedHooks;
    clear(): void;
};
interface VocabHooks {
    [resourceName: string]: HookBlueprints;
}
interface MethodHooks {
    [vocab: string]: VocabHooks;
}
declare const apiHooks: {
    all: MethodHooks;
    GET: MethodHooks;
    PUT: MethodHooks;
    POST: MethodHooks;
    PATCH: MethodHooks;
    MERGE: MethodHooks;
    DELETE: MethodHooks;
    OPTIONS: MethodHooks;
};
export declare const addHook: <Vocab extends string>(method: keyof typeof apiHooks, vocabulary: Vocab, resourceName: string, hooks: { [key in keyof Hooks]: HookBlueprint<NonNullable<Hooks[key]>>; } | ({ [key in keyof Hooks]: NonNullable<Hooks[key]>; } & {
    sideEffects: HookBlueprint<HookFn>["sideEffects"];
    readOnlyTx: HookBlueprint<HookFn>["readOnlyTx"];
})) => void;
export declare const addSideEffectHook: <Vocab extends string>(method: HookMethod, apiRoot: Vocab, resourceName: string, hooks: Hooks<NoInfer<Vocab>>) => void;
export declare const addPureHook: <Vocab extends string>(method: HookMethod, apiRoot: Vocab, resourceName: string, hooks: Hooks<NoInfer<Vocab>>) => void;
type RunHookArgs<T extends keyof Hooks> = Omit<Parameters<NonNullable<Hooks[T]>>[0], 'api'>;
export declare const runHooks: <T extends keyof Hooks>(hookName: T, hooksList: Array<[modelName: string, hooks: InstantiatedHooks]> | undefined, args: RunHookArgs<T>) => Promise<void>;
export {};