/**
 * MARIA Memory System - Dual Memory Engine
 *
 * Core integration logic for System 1 (fast, intuitive) and System 2 (deliberate, analytical) memory
 * Orchestrates memory operations, layer selection, and cross-system optimization
 */
import { System1MemoryManager } from "./system1-memory";
import { System2MemoryManager } from "./system2-memory";
import type { CodePattern, CoordinatorConfig, Enhancement, KnowledgeNode, MemoryEvent, PerformanceConfig, QualityMetrics, ReasoningTrace, System1Config, System2Config, UserPreferenceSet } from "./types/memory-interfaces";
export interface DualMemoryEngineConfigV2 {
    system1: System1Config;
    system2: System2Config;
    coordinator: CoordinatorConfig;
    performance: PerformanceConfig;
}
export interface DualMemoryEngineConfigV1 {
    system1: {
        maxSize: number;
        ttl: number;
        compressionThreshold?: number;
    };
    system2: {
        maxSize: number;
        persistencePath: string;
        compressionEnabled?: boolean;
        indexingEnabled?: boolean;
    };
    coordinationRules: {
        autoPromoteToSystem2: boolean;
        autoArchive: boolean;
        conflictResolution: "latest" | "system1_priority" | "system2_priority" | "balanced";
    };
}
export type DualMemoryEngineConfig = DualMemoryEngineConfigV2 | DualMemoryEngineConfigV1;
export interface MemoryQuery {
    type: "knowledge" | "pattern" | "reasoning" | "quality" | "preference";
    query: string;
    context?: Record<string, unknown>;
    urgency?: "low" | "medium" | "high" | "critical";
    embedding?: number[];
    limit?: number;
}
export interface MemoryResponse<T = unknown> {
    _data: T;
    source: "system1" | "system2" | "both";
    confidence: number;
    latency: number;
    cached: boolean;
    suggestions?: Enhancement[];
}
export interface MemoryOperationMetrics {
    totalOperations: number;
    system1Operations: number;
    system2Operations: number;
    averageLatency: number;
    cacheHitRate: number;
    errorRate: number;
    lastReset: Date;
}
export interface DualMemoryUpdate {
    operation: "add" | "update" | "remove";
    target: string;
    _data: unknown;
    metadata?: Record<string, unknown>;
}
export declare class DualMemoryEngine {
    private system1;
    private system2;
    private config;
    private operationMetrics;
    private eventQueue;
    private processingLock;
    private eventDrivenUpdateStore;
    private performanceCache;
    private legacyMode;
    private legacyConfig;
    private kvSystem1;
    private kvSystem2;
    private backgroundTimers;
    private persistenceFilePath;
    private legacyCleanupOperations;
    constructor(_config: DualMemoryEngineConfig);
    private normalizeConfig;
    /**
     * System accessors for coordination/monitoring layers.
     * Avoid reaching into private fields via `any` casts.
     */
    getSystem1(): System1MemoryManager;
    getSystem2(): System2MemoryManager;
    /**
     * Back-compat helper for sync/export systems.
     * The real implementation should return a normalized list of memory records.
     */
    getAllMemories(_options?: Record<string, unknown>): Promise<unknown[]>;
    query<T = unknown>(memoryQuery: MemoryQuery): Promise<MemoryResponse<T>>;
    store(event: MemoryEvent): Promise<void>;
    store(id: string, data: unknown): Promise<void>;
    /**
     * Apply event-driven updates to System 1 projections.
     * Note: This is a lightweight adapter used by the event-driven memory pipeline.
     */
    updateSystem1(update: DualMemoryUpdate): Promise<void>;
    /**
     * Apply event-driven updates to System 2 projections.
     * Note: This is a lightweight adapter used by the event-driven memory pipeline.
     */
    updateSystem2(update: DualMemoryUpdate): Promise<void>;
    private applyEventDrivenUpdate;
    learn(input: string, output: string, context: Record<string, unknown>, success: boolean): Promise<void>;
    findKnowledge(query: string, embedding?: number[], limit?: number): Promise<MemoryResponse<KnowledgeNode[]>>;
    findPatterns(language?: string, framework?: string, useCase?: string, limit?: number): Promise<MemoryResponse<CodePattern[]>>;
    getReasoning(domain?: string, complexity?: string, minQuality?: number): Promise<MemoryResponse<ReasoningTrace[]>>;
    getQualityInsights(): Promise<MemoryResponse<QualityMetrics>>;
    getUserPreferences(): Promise<MemoryResponse<UserPreferenceSet>>;
    recall(id: string): Promise<{
        id: string;
        data: unknown;
    } | null>;
    recall(options: {
        query: string;
        type: string;
        limit?: number;
    }): Promise<unknown[]>;
    search(criteria: {
        type?: string;
        content?: string;
        fuzzy?: boolean;
    }): Promise<Array<{
        id: string;
        data: any;
    }>>;
    getStats(): Promise<{
        system1: {
            totalMemories: number;
        };
        system2: {
            totalMemories: number;
        };
        coordination: {
            mode: "legacy" | "v2";
            cleanupOperations?: number;
        };
    }>;
    /**
     * Legacy cleanup hook used by integration tests.
     * Removes expired memories from both tiers.
     */
    cleanup(): Promise<void>;
    clearMemory(): Promise<void>;
    private selectMemoryStrategy;
    private getUrgencyScore;
    private assessQueryComplexity;
    private getTypePreference;
    private getCacheStatus;
    private calculateSystem1Score;
    private calculateSystem2Score;
    private executeMemoryOperation;
    private executeSystem1Operation;
    private executeSystem2Operation;
    private executeCombinedOperation;
    private combineResults;
    private generateCombinedSuggestions;
    processEvent(event: MemoryEvent): Promise<void>;
    private determineEventRouting;
    private adaptFromEvent;
    private startBackgroundProcessing;
    private processEventQueue;
    private cleanupCache;
    private optimizeMemory;
    private generateCacheKey;
    private isCacheValid;
    private updateOperationMetrics;
    private initializeMetrics;
    getMetrics(): MemoryOperationMetrics;
    resetMetrics(): void;
    getCacheSize(): number;
    getQueueSize(): number;
    initialize(): Promise<void>;
    shutdown(): Promise<void>;
    updateConfig(newConfig: Partial<DualMemoryEngineConfig>): void;
    getConfig(): DualMemoryEngineConfig;
    getStatistics(): Promise<{
        system1: {
            totalNodes: number;
            patterns: number;
            preferences: number;
            cacheHitRate: number;
        };
        system2: {
            reasoningTraces: number;
            decisionTrees: number;
            activeSessions: number;
            memoryUsage: number;
        };
        performance: {
            avgResponseTime: number;
            memoryUsage: number;
        };
    }>;
}