supa-seed/dist/features/detection/domain-analyzers.d.ts

A constraint-aware, framework-agnostic database seeding framework with deep PostgreSQL business logic discovery and MakerKit integration support

/**
 * Domain Pattern Recognition Engines for Epic 2: Smart Platform Detection Engine
 * Specialized analyzers for each content domain with confidence scoring
 * Part of Task 2.2.2: Create domain pattern recognition engine with confidence scoring
 */
import { ContentDomainType, DomainEvidence, DomainPattern, DomainAnalysisContext } from './detection-types';
/**
 * Pattern matching result for a single domain
 */
export interface DomainPatternMatchResult {
    /** Domain analyzed */
    domain: ContentDomainType;
    /** Patterns that matched */
    matchedPatterns: Array<{
        pattern: DomainPattern;
        confidence: number;
        matchDetails: PatternMatchDetails;
    }>;
    /** Overall confidence for this domain */
    overallConfidence: number;
    /** Evidence collected for this domain */
    evidence: DomainEvidence[];
    /** Reasoning for domain classification */
    reasoning: string[];
}
/**
 * Details about what matched in a pattern
 */
export interface PatternMatchDetails {
    /** Tables that matched */
    matchedTables: string[];
    /** Columns that matched */
    matchedColumns: string[];
    /** Relationships that matched */
    matchedRelationships: string[];
    /** Business logic that matched */
    matchedBusinessLogic: string[];
    /** Total number of matches */
    totalMatches: number;
}
/**
 * Base class for domain-specific analyzers
 */
declare abstract class BaseDomainAnalyzer {
    protected domain: ContentDomainType;
    constructor(domain: ContentDomainType);
    /**
     * Analyze patterns for this domain
     */
    analyzeDomainPatterns(context: DomainAnalysisContext): Promise<DomainPatternMatchResult>;
    /**
     * Analyze a single pattern against the schema
     */
    private analyzePattern;
    /**
     * Match table name patterns
     */
    private matchTablePatterns;
    /**
     * Match column patterns across all tables
     */
    private matchColumnPatterns;
    /**
     * Check if a column pattern is commonly found in this type of schema
     */
    private isCommonColumnPattern;
    /**
     * Match relationship patterns
     */
    private matchRelationshipPatterns;
    /**
     * Match business logic patterns
     */
    private matchBusinessLogicPatterns;
    /**
     * Calculate confidence for a single pattern match
     */
    private calculatePatternConfidence;
    /**
     * Calculate overall confidence for the domain
     */
    private calculateOverallConfidence;
    /**
     * Create evidence objects from pattern matches
     */
    private createEvidenceFromMatch;
}
/**
 * Outdoor Domain Analyzer
 */
export declare class OutdoorDomainAnalyzer extends BaseDomainAnalyzer {
    constructor();
}
/**
 * SaaS Domain Analyzer
 */
export declare class SaaSDomainAnalyzer extends BaseDomainAnalyzer {
    constructor();
}
/**
 * E-commerce Domain Analyzer
 */
export declare class EcommerceDomainAnalyzer extends BaseDomainAnalyzer {
    constructor();
}
/**
 * Social Domain Analyzer
 */
export declare class SocialDomainAnalyzer extends BaseDomainAnalyzer {
    constructor();
}
/**
 * Generic Domain Analyzer
 */
export declare class GenericDomainAnalyzer extends BaseDomainAnalyzer {
    constructor();
}
/**
 * Domain Pattern Analysis Orchestrator
 * Coordinates analysis across all domain analyzers
 */
export declare class DomainPatternAnalysisOrchestrator {
    private analyzers;
    constructor();
    /**
     * Analyze patterns for all domains
     */
    analyzeAllDomains(context: DomainAnalysisContext): Promise<DomainPatternMatchResult[]>;
    /**
     * Analyze patterns for specific domains only
     */
    analyzeSpecificDomains(domains: ContentDomainType[], context: DomainAnalysisContext): Promise<DomainPatternMatchResult[]>;
    /**
     * Get quick domain analysis (high-priority patterns only)
     */
    getQuickDomainAnalysis(context: DomainAnalysisContext): Promise<DomainPatternMatchResult[]>;
}
/**
 * Default domain pattern analysis orchestrator instance
 */
export declare const domainPatternOrchestrator: DomainPatternAnalysisOrchestrator;
export {};
//# sourceMappingURL=domain-analyzers.d.ts.map