/**
 * Recognized paradigm families.
 */
export type ParadigmFamily = 'imperative' | 'declarative' | 'reactive' | 'distributed' | 'specialized';
/**
 * Known programming paradigm identifiers.
 */
export type Paradigm = 'oop' | 'functional' | 'pure-functional' | 'procedural' | 'reactive' | 'event-driven' | 'actor-model' | 'data-oriented' | 'domain-driven' | 'component-based' | 'service-oriented' | 'microservices' | 'serverless' | 'pipeline' | 'concurrent' | 'logic' | 'hybrid/pragmatic';
/**
 * Type of signal used for paradigm detection.
 */
export type SignalType = 'keyword' | 'dependency' | 'structure' | 'naming';
/**
 * A single detected signal contributing to paradigm scoring.
 */
export interface DetectedSignal {
    /** The paradigm this signal supports. */
    paradigmId: string;
    /** How the signal was detected. */
    signalType: SignalType;
    /** The specific value found (e.g. dependency name, keyword, directory name). */
    value: string;
    /** Weight of this signal in the scoring (0-1). */
    weight: number;
    /** Where in the project this signal was found (file path, directory, manifest). */
    location: string;
}
/**
 * Score for a single paradigm after aggregating all its signals.
 */
export interface ParadigmScore {
    /** The paradigm identifier. */
    paradigmId: string;
    /** Human-readable display name. */
    name: string;
    /** Aggregated confidence in the range 0-1. */
    confidence: number;
    /** Signals that contributed to this score. */
    signals: DetectedSignal[];
}
/**
 * Classification of paradigm mixing patterns detected in a codebase.
 */
export type MixPattern = 'coherent' | 'inconsistent' | 'none';
/**
 * Full paradigm analysis report for a project.
 */
export interface ParadigmReport {
    /** The paradigm with the highest confidence. */
    dominant: ParadigmScore | null;
    /** All detected paradigms sorted by confidence (descending). */
    all: ParadigmScore[];
    /** Whether multiple paradigms are mixed and how coherently. */
    mixPattern: MixPattern;
    /** Overall coherence of the paradigm mix (0-1). */
    coherenceScore: number;
    /** Human-readable explanation of the detected paradigm. */
    summary: string;
    /** ISO timestamp when the detection was run. */
    detectedAt: string;
}
/**
 * Signal definition used in the paradigm registry.
 */
export interface ParadigmSignalDef {
    /** Keywords to scan for in source files. */
    keywords?: string[];
    /** Dependencies (packages/modules) to look for. */
    dependencies?: string[];
    /** Directory names indicative of this paradigm. */
    directories?: string[];
    /** Naming patterns (camelCase, snake_case, etc.). */
    namingPatterns?: string[];
}
/**
 * A single paradigm entry in the registry.
 */
export interface ParadigmEntry {
    id: string;
    name: string;
    family: ParadigmFamily;
    signals: ParadigmSignalDef;
    /** Frameworks/libraries commonly associated with this paradigm. */
    frameworks?: string[];
    /** Paradigm IDs that are known to be incompatible with this one. */
    incompatibilities?: string[];
}
/**
 * Shape of the paradigm-registry.json config file.
 */
export interface ParadigmRegistry {
    paradigms: ParadigmEntry[];
}
export interface ParadigmReportInput {
    /** Project ID to analyse. */
    projectId: string;
}
/** A recommendation for a specific paradigm pattern. */
export interface ParadigmRecommendation {
    /** Dominant paradigm this recommendation applies to. */
    type: string;
    /** Human-readable recommendation message. */
    message: string;
    /** Alternative approaches the user may consider. */
    alternatives: string[];
    /** How urgent this recommendation is. */
    urgency: 'low' | 'medium' | 'high';
}
/** Detected inconsistency between expected and observed paradigm patterns. */
export interface ParadigmDrift {
    /** The paradigm the codebase is established in. */
    expectedParadigm: string;
    /** The paradigm detected in the spec/code under review. */
    detectedParadigm: string;
    /** Specific keywords or patterns that triggered the drift detection. */
    evidence: string[];
    /** How severe the drift is. */
    severity: 'info' | 'warning' | 'blocker';
}
/** Step-by-step plan to migrate from one paradigm to another. */
export interface ParadigmMigrationPlan {
    /** Source paradigm the project is currently using. */
    origin: string;
    /** Target paradigm the project wants to adopt. */
    destination: string;
    /** Ordered migration phases. */
    phases: string[];
    /** Risks involved in the migration. */
    risks: string[];
    /** Human-readable effort estimate. */
    estimatedEffort: string;
}
/** Input spec entry for batch paradigm drift detection. */
export interface SpecEntry {
    id: string;
    content: string;
}
/** Drift detection result for a single spec. */
export interface SpecDriftResult {
    specId: string;
    drift: ParadigmDrift | null;
}
//# sourceMappingURL=paradigm.d.ts.map