/**
 * HooksManager - Cascade Hooks System for PraisonAI TypeScript
 *
 * Provides event hooks similar to Python HooksManager, allowing custom actions
 * before/after agent operations.
 *
 * Features:
 * - Pre/post hooks for read, write, command, prompt, LLM, and tool operations
 * - JSON configuration support
 * - Async/sync hook execution
 * - Multi-agent safe
 *
 * @example
 * ```typescript
 * import { HooksManager, createHooksManager } from 'praisonai';
 *
 * const hooks = createHooksManager();
 *
 * hooks.register('pre_llm_call', async (context) => {
 *   console.log('Before LLM call:', context.prompt);
 *   return context; // Can modify
 * });
 *
 * hooks.register('post_tool_call', async (context) => {
 *   console.log('Tool result:', context.result);
 * });
 * ```
 */
/**
 * Hook event types - matching Python HooksManager + industry standard additions
 */
export type HookEvent = 'pre_read_code' | 'post_read_code' | 'pre_write_code' | 'post_write_code' | 'pre_run_command' | 'post_run_command' | 'pre_user_prompt' | 'post_user_prompt' | 'pre_mcp_tool_use' | 'post_mcp_tool_use' | 'pre_llm_call' | 'post_llm_call' | 'pre_tool_call' | 'post_tool_call' | 'agent_start' | 'agent_complete' | 'run_started' | 'run_completed';
/**
 * Hook handler function type
 */
export type HookHandler<T = any> = (context: T) => Promise<T | null | void> | T | null | void;
/**
 * Result of hook execution
 */
export interface HookResult {
    success: boolean;
    blocked: boolean;
    modifiedContext?: any;
    error?: string;
    duration: number;
}
/**
 * Single hook configuration
 */
export interface HookConfig {
    id: string;
    event: HookEvent;
    handler: HookHandler;
    enabled: boolean;
    priority: number;
    timeout: number;
    blockOnFailure: boolean;
}
/**
 * HooksManager configuration
 */
export interface HooksManagerConfig {
    /** Global timeout in ms */
    timeout?: number;
    /** Enable all hooks */
    enabled?: boolean;
    /** Enable logging */
    logging?: boolean;
    /** Workspace path for config file discovery */
    workspacePath?: string;
}
/**
 * HooksManager - Central hook orchestration
 */
export declare class HooksManager {
    readonly id: string;
    private hooks;
    private config;
    private loaded;
    constructor(config?: HooksManagerConfig);
    /**
     * Register a hook handler for an event
     */
    register(event: HookEvent, handler: HookHandler, options?: Partial<Omit<HookConfig, 'id' | 'event' | 'handler'>>): string;
    /**
     * Unregister a hook by ID
     */
    unregister(hookId: string): boolean;
    /**
     * Execute all hooks for an event
     */
    execute<T = any>(event: HookEvent, context: T): Promise<HookResult>;
    /**
     * Execute with timeout
     */
    private executeWithTimeout;
    /**
     * Check if any hooks are registered for an event
     */
    hasHooks(event: HookEvent): boolean;
    /**
     * Get all registered hooks for an event
     */
    getHooks(event: HookEvent): readonly HookConfig[];
    /**
     * Get all registered events
     */
    getEvents(): HookEvent[];
    /**
     * Enable/disable a specific hook
     */
    setEnabled(hookId: string, enabled: boolean): boolean;
    /**
     * Enable/disable all hooks
     */
    setGlobalEnabled(enabled: boolean): void;
    /**
     * Clear all hooks for an event or all events
     */
    clear(event?: HookEvent): void;
    /**
     * Get statistics
     */
    getStats(): {
        enabled: boolean;
        totalHooks: number;
        events: string[];
        hooksByEvent: Record<string, number>;
    };
    /**
     * Load hooks from JSON config file
     */
    loadConfig(configPath?: string): Promise<void>;
    private log;
}
/**
 * Create a HooksManager instance
 */
export declare function createHooksManager(config?: HooksManagerConfig): HooksManager;
/**
 * Create pre-configured hooks for common patterns
 */
export declare function createLoggingHooks(logger?: (event: string, context: any) => void): HooksManager;
/**
 * Create hooks with validation
 */
export declare function createValidationHooks(validator: (event: HookEvent, context: any) => boolean | {
    valid: boolean;
    reason?: string;
}): HooksManager;
export default HooksManager;