/**
 * Agentic QE v3 - Pattern Store with HNSW Indexing
 * ADR-021: QE ReasoningBank for Pattern Learning
 *
 * Provides persistent pattern storage with HNSW vector indexing for
 * O(log n) approximate nearest neighbor search.
 */
import type { MemoryBackend } from '../kernel/interfaces.js';
import type { Result } from '../shared/types/index.js';
import { QEPattern, QEPatternContext, QEPatternType, QEDomain, CreateQEPatternOptions } from './qe-patterns.js';
/**
 * Pattern store configuration
 */
export interface PatternStoreConfig {
    /** Namespace for pattern storage keys */
    namespace: string;
    /** Dimension of embedding vectors */
    embeddingDimension: number;
    /** HNSW configuration */
    hnsw: {
        M: number;
        efConstruction: number;
        efSearch: number;
        maxElements: number;
    };
    /** Promotion threshold (successful uses required) */
    promotionThreshold: number;
    /** Minimum confidence for storage */
    minConfidence: number;
    /** Maximum patterns per domain */
    maxPatternsPerDomain: number;
    /** Enable automatic cleanup of low-quality patterns */
    autoCleanup: boolean;
    /** Cleanup interval in milliseconds */
    cleanupIntervalMs: number;
}
/**
 * Default pattern store configuration
 */
export declare const DEFAULT_PATTERN_STORE_CONFIG: PatternStoreConfig;
/**
 * Pattern store statistics
 */
export interface PatternStoreStats {
    /** Total patterns stored */
    totalPatterns: number;
    /** Patterns by tier */
    byTier: {
        shortTerm: number;
        longTerm: number;
    };
    /** Patterns by domain */
    byDomain: Record<QEDomain, number>;
    /** Patterns by type */
    byType: Record<QEPatternType, number>;
    /** Average confidence score */
    avgConfidence: number;
    /** Average quality score */
    avgQualityScore: number;
    /** Average success rate */
    avgSuccessRate: number;
    /** Search operations count */
    searchOperations: number;
    /** Average search latency (ms) */
    avgSearchLatencyMs: number;
    /** HNSW index stats */
    hnswStats: {
        nativeAvailable: boolean;
        vectorCount: number;
        indexSizeBytes: number;
    };
}
/**
 * Options for pattern search
 */
export interface PatternSearchOptions {
    /** Maximum number of results */
    limit?: number;
    /** Filter by pattern type */
    patternType?: QEPatternType;
    /** Filter by QE domain */
    domain?: QEDomain;
    /** Filter by tier */
    tier?: 'short-term' | 'long-term';
    /** Minimum confidence threshold */
    minConfidence?: number;
    /** Minimum quality score */
    minQualityScore?: number;
    /** Context to match against */
    context?: Partial<QEPatternContext>;
    /** Include vector similarity search */
    useVectorSearch?: boolean;
}
/**
 * Pattern search result
 */
export interface PatternSearchResult {
    pattern: QEPattern;
    score: number;
    matchType: 'vector' | 'exact' | 'context';
}
/**
 * Interface for pattern store operations
 */
export interface IPatternStore {
    /** Initialize the store */
    initialize(): Promise<void>;
    /** Store a new pattern */
    store(pattern: QEPattern): Promise<Result<string>>;
    /** Create and store a pattern from options */
    create(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;
    /** Get pattern by ID */
    get(id: string): Promise<QEPattern | null>;
    /** Search for patterns */
    search(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
    /** Update pattern after use */
    recordUsage(id: string, success: boolean): Promise<Result<void>>;
    /** Promote pattern from short-term to long-term */
    promote(id: string): Promise<Result<void>>;
    /** Delete a pattern */
    delete(id: string): Promise<Result<void>>;
    /** Get store statistics */
    getStats(): Promise<PatternStoreStats>;
    /** Run cleanup to remove low-quality patterns */
    cleanup(): Promise<{
        removed: number;
        promoted: number;
    }>;
    /** Dispose the store */
    dispose(): Promise<void>;
}
/**
 * Pattern Store with HNSW indexing
 *
 * Provides O(log n) pattern search using HNSW approximate nearest neighbor.
 */
export declare class PatternStore implements IPatternStore {
    private readonly memory;
    private readonly config;
    private initialized;
    private cleanupTimer?;
    private patternCache;
    private domainIndex;
    private typeIndex;
    private tierIndex;
    private hnswIndex;
    private hnswAvailable;
    private stats;
    constructor(memory: MemoryBackend, config?: Partial<PatternStoreConfig>);
    /**
     * Initialize the pattern store
     */
    initialize(): Promise<void>;
    /**
     * Initialize HNSW index
     */
    private initializeHNSW;
    /**
     * Load existing patterns from memory
     */
    private loadPatterns;
    /**
     * Index a pattern in local caches
     */
    private indexPattern;
    /**
     * Remove pattern from local indices
     */
    private unindexPattern;
    /**
     * Store a new pattern
     */
    store(pattern: QEPattern): Promise<Result<string>>;
    /**
     * Create and store a pattern from options
     */
    create(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;
    /**
     * Detect QE domain from pattern type
     */
    private detectDomainFromType;
    /**
     * Get pattern by ID
     */
    get(id: string): Promise<QEPattern | null>;
    /**
     * Search for patterns
     */
    search(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
    /**
     * Search patterns by text query
     */
    private searchByText;
    /**
     * Check if pattern matches search filters
     */
    private matchesFilters;
    /**
     * Record pattern usage and update stats
     */
    recordUsage(id: string, success: boolean): Promise<Result<void>>;
    /**
     * Promote pattern from short-term to long-term storage
     */
    promote(id: string): Promise<Result<void>>;
    /**
     * Delete a pattern
     */
    delete(id: string): Promise<Result<void>>;
    /**
     * Get store statistics
     */
    getStats(): Promise<PatternStoreStats>;
    /**
     * Cleanup low-quality patterns
     */
    cleanup(): Promise<{
        removed: number;
        promoted: number;
    }>;
    /**
     * Cleanup patterns for a specific domain
     */
    private cleanupDomain;
    /**
     * Record search latency
     */
    private recordSearchLatency;
    /**
     * Calculate average search latency
     */
    private calculateAvgLatency;
    /**
     * Dispose the pattern store
     */
    dispose(): Promise<void>;
}
/**
 * Create a new pattern store instance
 */
export declare function createPatternStore(memory: MemoryBackend, config?: Partial<PatternStoreConfig>): PatternStore;
//# sourceMappingURL=pattern-store.d.ts.map