/**
 * KnowledgeStoreManager - Facade for all knowledge operations
 */
import type { IndividualKnowledge, Philosophy, Principle, Pattern, UserContext } from '../types/knowledge.js';
import type { StorageProvider, VersionInfo, KnowledgeStoreConfig } from '../types/storage.js';
import type { ExportedKnowledge, ImportResult, PortabilityLevel } from '../types/portability.js';
import { PhilosophyManager } from './PhilosophyManager.js';
import { PrincipleManager, CreatePrincipleInput, UpdatePrincipleInput } from './PrincipleManager.js';
import { PatternManager, CreatePatternInput } from './PatternManager.js';
import { ContextManager } from './ContextManager.js';
/**
 * Version history entry
 */
export interface VersionHistory {
    philosophy: VersionInfo[];
    principles: VersionInfo[];
    patterns: VersionInfo[];
}
/**
 * Main facade for all knowledge store operations
 */
export declare class KnowledgeStoreManager {
    private readonly config;
    private readonly storage;
    private readonly philosophyManager;
    private readonly principleManager;
    private readonly patternManager;
    private readonly contextManager;
    constructor(config?: KnowledgeStoreConfig);
    /**
     * Get complete knowledge for a user
     */
    getKnowledge(userId: string): Promise<IndividualKnowledge>;
    /**
     * Get a user's philosophy
     */
    getPhilosophy(userId: string): Promise<Philosophy>;
    /**
     * Update a user's philosophy
     */
    updatePhilosophy(userId: string, update: Partial<Philosophy>): Promise<void>;
    /**
     * Get principles for a user, optionally filtered by domains
     */
    getPrinciples(userId: string, domains?: string[]): Promise<Principle[]>;
    /**
     * Add a new principle
     */
    addPrinciple(userId: string, principle: CreatePrincipleInput): Promise<string>;
    /**
     * Update a principle
     */
    updatePrinciple(userId: string, principleId: string, update: UpdatePrincipleInput): Promise<void>;
    /**
     * Deprecate a principle
     */
    deprecatePrinciple(userId: string, principleId: string, reason: string): Promise<void>;
    /**
     * Get patterns for a user, optionally filtered by status
     */
    getPatterns(userId: string, status?: Pattern['status']): Promise<Pattern[]>;
    /**
     * Add a new pattern
     */
    addPattern(userId: string, pattern: CreatePatternInput): Promise<string>;
    /**
     * Promote a pattern to a principle
     */
    promoteToAnciple(userId: string, patternId: string): Promise<string>;
    /**
     * Get a user's context
     */
    getContext(userId: string): Promise<UserContext>;
    /**
     * Update a user's context
     */
    updateContext(userId: string, update: Partial<UserContext>): Promise<void>;
    /**
     * Get version history for all stores
     */
    getHistory(userId: string, store?: 'philosophy' | 'principles' | 'patterns'): Promise<VersionHistory | VersionInfo[]>;
    /**
     * Revert a store to a specific version
     */
    revertTo(userId: string, store: 'philosophy' | 'principles', version: number): Promise<void>;
    /**
     * Export knowledge at specified portability level
     */
    exportKnowledge(userId: string, level: PortabilityLevel): Promise<ExportedKnowledge>;
    /**
     * Import knowledge with merge strategy
     */
    importKnowledge(userId: string, data: ExportedKnowledge): Promise<ImportResult>;
    /**
     * Validate integrity of a user's knowledge store
     */
    validateIntegrity(userId: string): Promise<{
        valid: boolean;
        issues: string[];
    }>;
    /**
     * Detect circular or conflicting principles
     */
    detectCircularConflicts(userId: string): Promise<{
        hasConflicts: boolean;
        conflicts: Array<{
            principle1: string;
            principle2: string;
            reason: string;
        }>;
    }>;
    /**
     * Get the underlying storage provider (for testing)
     */
    getStorage(): StorageProvider;
    /**
     * Get individual managers (for advanced usage)
     */
    getManagers(): {
        philosophy: PhilosophyManager;
        principles: PrincipleManager;
        patterns: PatternManager;
        context: ContextManager;
    };
}
export type { CreatePrincipleInput, UpdatePrincipleInput } from './PrincipleManager.js';
export type { CreatePatternInput, UpdatePatternInput } from './PatternManager.js';
//# sourceMappingURL=KnowledgeStoreManager.d.ts.map