import { IMemoryUnit, MemoryFilter, MemoryType, IMemory } from './base';
import { IMemoryStorage, IMemoryIndex } from './storage';
import { Subject } from 'rxjs';
import * as z from 'zod';
/**
 * Cache for memory units
 */
declare class MemoryCache<T extends IMemoryUnit> {
    private cache;
    private maxSize;
    constructor(maxSize?: number);
    get(id: string): T | undefined;
    set(id: string, unit: T): void;
    delete(id: string): void;
    clear(): void;
}
/**
 * Base class for long-term memory implementations
 */
export declare abstract class LongTermMemory<T extends IMemoryUnit> implements IMemory<T> {
    protected storage: IMemoryStorage;
    protected index: IMemoryIndex;
    protected memoryType: MemoryType;
    protected cache: MemoryCache<T>;
    protected memoryEvents$: Subject<T>;
    constructor(storage: IMemoryStorage, index: IMemoryIndex, memoryType: MemoryType);
    /**
     * Create a memory unit with the appropriate type
     * This must be implemented by concrete classes to ensure type safety
     * @param content The content to store, can be either a string or an object of type C
     * @param schema Optional schema for validating object content
     * @param metadata Optional metadata for the memory unit
     */
    abstract createMemoryUnit<C>(content: C | string, schema?: z.ZodType<C>, metadata?: Map<string, any>): T;
    /**
     * Store a memory unit
     */
    store(content: Omit<T, 'memoryType'>): Promise<void>;
    /**
     * Retrieve a memory unit by ID
     */
    retrieve(id: string): Promise<T | null>;
    /**
     * Query memory units based on filter
     */
    query(filter: MemoryFilter): Promise<T[]>;
    /**
     * Delete a memory unit
     */
    delete(id: string): Promise<void>;
    /**
     * Clear all memory units
     */
    clear(): Promise<void>;
    /**
     * Subscribe to memory events
     */
    onEvent(callback: (unit: T) => void): void;
    /**
     * Type guard to ensure memory unit is of correct type
     */
    abstract isMemoryUnitOfType(unit: any): unit is T;
}
export {};