/**
 * Memory Hooks - Pre/post hooks for all memory operations
 *
 * Enables intercepting and modifying memory operations.
 *
 * @example
 * ```typescript
 * import { MemoryHooks, Memory } from 'praisonai';
 *
 * const hooks = new MemoryHooks({
 *   beforeStore: async (key, value) => {
 *     console.log(`Storing ${key}`);
 *     return { key, value }; // Can modify
 *   },
 *   afterRetrieve: async (key, value) => {
 *     console.log(`Retrieved ${key}`);
 *     return value;
 *   }
 * });
 *
 * const memory = new Memory({ hooks });
 * ```
 */
/**
 * Hook function types
 */
export type BeforeStoreHook = (key: string, value: any, metadata?: Record<string, any>) => Promise<{
    key: string;
    value: any;
    metadata?: Record<string, any>;
} | null> | {
    key: string;
    value: any;
    metadata?: Record<string, any>;
} | null;
export type AfterStoreHook = (key: string, value: any, metadata?: Record<string, any>) => Promise<void> | void;
export type BeforeRetrieveHook = (key: string) => Promise<string | null> | string | null;
export type AfterRetrieveHook = (key: string, value: any) => Promise<any> | any;
export type BeforeDeleteHook = (key: string) => Promise<boolean> | boolean;
export type AfterDeleteHook = (key: string, success: boolean) => Promise<void> | void;
export type BeforeSearchHook = (query: string, options?: Record<string, any>) => Promise<{
    query: string;
    options?: Record<string, any>;
} | null> | {
    query: string;
    options?: Record<string, any>;
} | null;
export type AfterSearchHook = (query: string, results: any[]) => Promise<any[]> | any[];
/**
 * Memory hooks configuration
 */
export interface MemoryHooksConfig {
    /** Called before storing a value (can modify or cancel) */
    beforeStore?: BeforeStoreHook;
    /** Called after storing a value */
    afterStore?: AfterStoreHook;
    /** Called before retrieving a value (can modify key or cancel) */
    beforeRetrieve?: BeforeRetrieveHook;
    /** Called after retrieving a value (can modify result) */
    afterRetrieve?: AfterRetrieveHook;
    /** Called before deleting a value (can cancel) */
    beforeDelete?: BeforeDeleteHook;
    /** Called after deleting a value */
    afterDelete?: AfterDeleteHook;
    /** Called before searching (can modify query) */
    beforeSearch?: BeforeSearchHook;
    /** Called after searching (can modify results) */
    afterSearch?: AfterSearchHook;
    /** Enable logging of all operations */
    logging?: boolean;
}
/**
 * MemoryHooks - Intercept and modify memory operations
 */
export declare class MemoryHooks {
    readonly id: string;
    private config;
    constructor(config?: MemoryHooksConfig);
    /**
     * Execute before store hook
     */
    beforeStore(key: string, value: any, metadata?: Record<string, any>): Promise<{
        key: string;
        value: any;
        metadata?: Record<string, any>;
    } | null>;
    /**
     * Execute after store hook
     */
    afterStore(key: string, value: any, metadata?: Record<string, any>): Promise<void>;
    /**
     * Execute before retrieve hook
     */
    beforeRetrieve(key: string): Promise<string | null>;
    /**
     * Execute after retrieve hook
     */
    afterRetrieve(key: string, value: any): Promise<any>;
    /**
     * Execute before delete hook
     */
    beforeDelete(key: string): Promise<boolean>;
    /**
     * Execute after delete hook
     */
    afterDelete(key: string, success: boolean): Promise<void>;
    /**
     * Execute before search hook
     */
    beforeSearch(query: string, options?: Record<string, any>): Promise<{
        query: string;
        options?: Record<string, any>;
    } | null>;
    /**
     * Execute after search hook
     */
    afterSearch(query: string, results: any[]): Promise<any[]>;
    /**
     * Enable or disable logging
     */
    setLogging(enabled: boolean): void;
    /**
     * Add a hook dynamically
     */
    addHook<K extends keyof MemoryHooksConfig>(hookName: K, handler: MemoryHooksConfig[K]): void;
    /**
     * Remove a hook
     */
    removeHook(hookName: keyof MemoryHooksConfig): void;
    /**
     * Get current hooks configuration
     */
    getConfig(): MemoryHooksConfig;
}
/**
 * Create memory hooks with common patterns
 */
export declare function createMemoryHooks(config?: MemoryHooksConfig): MemoryHooks;
/**
 * Create logging hooks that log all memory operations
 */
export declare function createLoggingHooks(logger?: (msg: string) => void): MemoryHooks;
/**
 * Create validation hooks that validate data before storage
 */
export declare function createValidationHooks(validator: (key: string, value: any) => boolean | {
    valid: boolean;
    reason?: string;
}): MemoryHooks;
/**
 * Create encryption hooks (placeholder - real implementation would use crypto)
 */
export declare function createEncryptionHooks(encrypt: (data: any) => any, decrypt: (data: any) => any): MemoryHooks;
export default MemoryHooks;