@comake/skl-js-engine/dist/hooks/globalHooks.d.ts

Standard Knowledge Language Javascript Engine

import type { CapabilityMapping, Entity } from '../util/Types';
import type { SklHookContext } from './types';
export declare const HookTypes: {
    CREATE: symbol;
    READ: symbol;
    UPDATE: symbol;
    DELETE: symbol;
    EXECUTE_CAPABILITY_MAPPING: symbol;
};
export declare const HookStages: {
    BEFORE: symbol;
    AFTER: symbol;
    ERROR: symbol;
};
export declare type GlobalBeforeHook = (context: SklHookContext) => Promise<void> | void;
export declare type GlobalAfterHook = (context: SklHookContext, result: any) => Promise<any> | any;
export declare type GlobalErrorHook = (context: SklHookContext, error: Error) => Promise<void> | void;
export declare type GlobalExecuteCapabilityHook = (context: SklHookContext, capabilityMapping: CapabilityMapping) => Promise<void> | void;
declare class GlobalHooksRegistry {
    private readonly hooks;
    constructor();
    /**
     * Register a hook with optional priority (higher runs first)
     */
    register(type: symbol, stage: symbol, hook: GlobalBeforeHook | GlobalAfterHook | GlobalErrorHook, priority?: number): symbol;
    /**
     * Unregister a hook by its ID
     */
    unregister(hookId: symbol): boolean;
    /**
     * Execute hooks for a specific operation and stage
     */
    execute(type: symbol, stage: symbol, context: SklHookContext, resultOrError?: any): Promise<any>;
    registerBeforeCreate(hook: GlobalBeforeHook, priority?: number): symbol;
    registerAfterCreate(hook: GlobalAfterHook, priority?: number): symbol;
    registerErrorCreate(hook: GlobalErrorHook, priority?: number): symbol;
    registerBeforeRead(hook: GlobalBeforeHook, priority?: number): symbol;
    registerBeforeExecuteCapabilityMapping(hook: GlobalExecuteCapabilityHook, priority?: number): symbol;
    registerAfterExecuteCapabilityMapping(hook: GlobalAfterHook, priority?: number): symbol;
    registerErrorExecuteCapabilityMapping(hook: GlobalErrorHook, priority?: number): symbol;
    executeBeforeCreate(entities: Entity[], extras?: Partial<SklHookContext>): Promise<void>;
    executeAfterCreate(entities: Entity | Entity[], extras?: Partial<SklHookContext>): Promise<any>;
    executeErrorCreate(entities: Entity[], error: Error, extras?: Partial<SklHookContext>): Promise<void>;
    executeBeforeExecuteCapabilityMapping(entities: Entity[], capabilityMapping: CapabilityMapping, extras?: Partial<SklHookContext>): Promise<void>;
    executeAfterExecuteCapabilityMapping(entities: Entity[], capabilityMapping: CapabilityMapping, result: any, extras?: Partial<SklHookContext>): Promise<any>;
    executeErrorExecuteCapabilityMapping(entities: Entity[], capabilityMapping: CapabilityMapping, error: Error, extras?: Partial<SklHookContext>): Promise<void>;
}
export declare const globalHooks: GlobalHooksRegistry;
export {};
//# sourceMappingURL=globalHooks.d.ts.map