/**
 * Multi-View Memory System for UAM
 *
 * Implements:
 * 1. Multi-view indexing (entity, temporal, semantic type views)
 * 2. ENGRAM-style memory typing (episodic, semantic, procedural)
 * 3. Async embedding generation
 * 4. Speculative cache integration with task classifier
 *
 * Based on SimpleMem (2026) and ENGRAM (2025) research
 */
/**
 * ENGRAM-style memory types
 */
export type ENGRAMMemoryType = 'episodic' | 'semantic' | 'procedural';
/**
 * Multi-view indexed memory entry
 */
export interface MultiViewMemory {
    id: string;
    content: string;
    memoryType: ENGRAMMemoryType;
    entities: string[];
    temporalBucket: string;
    semanticType: string;
    embedding?: number[];
    embeddingPending?: boolean;
    importance: number;
    accessCount: number;
    lastAccessed: Date;
    qualityScore: number;
}
/**
 * Multi-view index structure
 */
export interface MultiViewIndex {
    byEntity: Map<string, Set<string>>;
    byTemporal: Map<string, Set<string>>;
    bySemanticType: Map<string, Set<string>>;
    byENGRAMType: Map<ENGRAMMemoryType, Set<string>>;
}
/**
 * Classify memory into ENGRAM type
 */
export declare function classifyENGRAMType(content: string, context?: {
    type?: string;
}): ENGRAMMemoryType;
/**
 * Extract temporal bucket from content/timestamp
 */
export declare function extractTemporalBucket(content: string, timestamp?: string): string;
/**
 * Multi-View Memory Manager
 */
export declare class MultiViewMemoryManager {
    private memories;
    private index;
    private embeddingQueue;
    private isProcessingEmbeddings;
    /**
     * Add memory with multi-view indexing
     */
    add(content: string, options?: {
        id?: string;
        semanticType?: string;
        entities?: string[];
        timestamp?: string;
        importance?: number;
        generateEmbedding?: boolean;
    }): Promise<MultiViewMemory>;
    /**
     * Index memory in all views
     */
    private indexMemory;
    /**
     * Query by entity
     */
    queryByEntity(entity: string): MultiViewMemory[];
    /**
     * Query by ENGRAM type
     */
    queryByENGRAMType(type: ENGRAMMemoryType): MultiViewMemory[];
    /**
     * Query by temporal bucket
     */
    queryByTemporal(bucket: string): MultiViewMemory[];
    /**
     * Smart query using task classification to select best view
     */
    smartQuery(query: string, limit?: number): Promise<MultiViewMemory[]>;
    /**
     * Get retrieval strategy based on task classification
     */
    private getRetrievalStrategy;
    /**
     * Execute a single strategy step
     */
    private executeStrategyStep;
    /**
     * Semantic search using embeddings
     */
    semanticSearch(query: string, limit?: number): Promise<MultiViewMemory[]>;
    /**
     * Process embedding queue asynchronously
     */
    private processEmbeddingQueue;
    /**
     * Extract entities from content
     */
    private extractEntities;
    /**
     * Record memory access
     */
    recordAccess(memoryId: string): void;
    /**
     * Get statistics
     */
    getStats(): {
        totalMemories: number;
        byENGRAMType: Record<ENGRAMMemoryType, number>;
        pendingEmbeddings: number;
        entitiesIndexed: number;
    };
    /**
     * Export all memories
     */
    export(): MultiViewMemory[];
    /**
     * Import memories
     */
    import(memories: MultiViewMemory[]): Promise<void>;
}
export declare function getMultiViewMemoryManager(): MultiViewMemoryManager;
//# sourceMappingURL=multi-view-memory.d.ts.map