/**
 * Domain Group Learner (LI-005)
 *
 * Learns domain groups dynamically from:
 * 1. Successful cross-domain pattern transfers
 * 2. Pattern similarity analysis
 *
 * Groups are learned automatically and can be persisted to survive restarts.
 */
/**
 * Aggregated relationship between two domains
 */
interface DomainRelationship {
    domainA: string;
    domainB: string;
    transferCount: number;
    successCount: number;
    successRate: number;
    avgSimilarity: number;
    lastTransfer: number;
}
/**
 * A learned domain group with provenance
 */
export interface LearnedDomainGroup {
    /** Auto-generated name */
    name: string;
    /** Domains in this group */
    domains: string[];
    /** Confidence in this grouping (0-1) */
    confidence: number;
    /** When this group was first created */
    createdAt: number;
    /** When this group was last updated */
    lastUpdated: number;
    /** How this group was learned */
    source: 'transfer_learning' | 'similarity_suggestion' | 'merged';
    /** Evidence supporting this grouping */
    evidence: {
        totalTransfers: number;
        successfulTransfers: number;
        avgSimilarity: number;
    };
    /** Whether this group has been registered with heuristics config */
    registered: boolean;
}
/**
 * Suggestion for a new domain group
 */
export interface GroupSuggestion {
    domains: string[];
    confidence: number;
    reason: string;
    evidence: {
        totalTransfers: number;
        transferSuccesses: number;
        avgSimilarity: number;
    };
}
export declare class DomainGroupLearner {
    private transfers;
    private learnedGroups;
    private store;
    private nextGroupId;
    private successfulTransferCount;
    private uniqueDomains;
    constructor(filePath?: string);
    /**
     * Initialize by loading persisted data
     */
    initialize(): Promise<void>;
    /**
     * Record a pattern transfer outcome
     * Called when a pattern from one domain is applied to another
     */
    recordTransfer(sourceDomain: string, targetDomain: string, success: boolean, options?: {
        patternId?: string;
        similarity?: number;
    }): void;
    /**
     * Get aggregated relationships between domains
     */
    getRelationships(): DomainRelationship[];
    /**
     * Analyze transfer history to identify and create domain groups
     */
    analyzeForGroups(): GroupSuggestion[];
    /**
     * Calculate confidence for a potential group
     */
    private calculateGroupConfidence;
    /**
     * Check if domains already form an existing group
     */
    private findExistingGroup;
    /**
     * Create a new learned domain group from a suggestion
     */
    private createLearnedGroup;
    /**
     * Register a learned group with the heuristics config
     */
    registerGroup(group: LearnedDomainGroup): void;
    /**
     * Get all learned domain groups
     */
    getLearnedGroups(): LearnedDomainGroup[];
    /**
     * Get suggestions for domain groups based on current data
     */
    getSuggestions(): GroupSuggestion[];
    /**
     * Get statistics about the learner
     */
    getStats(): {
        totalTransfers: number;
        successfulTransfers: number;
        uniqueDomains: number;
        relationships: number;
        learnedGroups: number;
        registeredGroups: number;
    };
    /**
     * Suggest domains that might belong to a group with an existing domain
     * Uses transfer history and pattern similarity
     */
    suggestRelatedDomains(domain: string): string[];
    /**
     * Merge domains into an existing learned group
     */
    mergeIntoGroup(groupName: string, newDomains: string[]): boolean;
    /**
     * Normalize a domain for consistent comparison
     */
    private normalizeDomain;
    /**
     * Load persisted data
     */
    private load;
    /**
     * Save data to disk
     */
    private save;
    /**
     * Flush pending writes
     */
    flush(): Promise<void>;
    /**
     * Clear all learned data (for testing)
     */
    clear(): void;
    /**
     * Subscribe to pattern registry events for automatic learning
     * Call this to wire the learner to an ApiPatternRegistry instance
     */
    subscribeToRegistry(subscribe: (listener: (event: import('../types/api-patterns.js').PatternLearningEvent) => void) => () => void): () => void;
}
export declare const domainGroupLearner: DomainGroupLearner;
export {};
//# sourceMappingURL=domain-group-learner.d.ts.map