/**
 * Ontology Reasoner for AIQL v2.5.0
 * Provides semantic-level reasoning capabilities for contradiction detection
 *
 * Features:
 * - Class hierarchy management (is_a, subclass_of, instance_of)
 * - Transitive closure reasoning
 * - Semantic conflict detection (taxonomy, property, cardinality, type)
 * - Property constraint validation
 */
import * as AST from '@aiql-org/core';
export type ConflictType = 'taxonomy' | 'property' | 'cardinality' | 'type' | 'disjoint_values';
export type ConflictSeverity = 'critical' | 'major' | 'minor' | 'informational';
export interface ConflictResult {
    hasConflict: boolean;
    conflictType?: ConflictType;
    reason?: string;
    severity?: ConflictSeverity;
    details?: Record<string, unknown>;
}
export interface PropertyConstraint {
    relation: string;
    domain?: string;
    range?: string;
    cardinality?: 'one' | 'many';
    disjointWith?: string[];
    symmetric?: boolean;
    transitive?: boolean;
}
/**
 * OntologyReasoner: Provides semantic understanding of knowledge base
 * Learns hierarchies from statements, performs transitive reasoning, detects semantic conflicts
 */
export declare class OntologyReasoner {
    private hierarchies;
    private instances;
    private constraints;
    private disjointClasses;
    constructor();
    /**
     * Initialize common-sense property constraints
     */
    private initializeDefaultConstraints;
    /**
     * Add a property constraint
     */
    addConstraint(constraint: PropertyConstraint): void;
    /**
     * Mark two classes as disjoint (mutually exclusive)
     */
    addDisjointPair(class1: string, class2: string): void;
    /**
     * Check if two classes are disjoint
     */
    areDisjoint(class1: string, class2: string): boolean;
    /**
     * Learn class hierarchies from knowledge base statements
     * Processes [is_a], [subclass_of], [instance_of] relations
     */
    learnHierarchy(statements: AST.Statement[]): void;
    /**
     * Strip angle brackets from concepts and square brackets from relations
     */
    private stripBrackets;
    /**
     * Compute transitive closure of class hierarchies
     * If A is_a B and B is_a C, then A is_a C
     */
    private computeTransitiveClosure;
    /**
     * Check if concept1 is a subclass of concept2 (transitively)
     */
    isSubclassOf(concept1: string, concept2: string): boolean;
    /**
     * Get all superclasses of a concept (transitively)
     */
    getSuperclasses(concept: string): Set<string>;
    /**
     * Check if an instance belongs to a class (considering hierarchy)
     */
    isInstanceOf(instance: string, className: string): boolean;
    /**
     * Detect semantic conflicts between two statements
     */
    detectSemanticConflict(stmt1: AST.Statement, stmt2: AST.Statement): ConflictResult;
    /**
     * Detect all semantic conflicts in a set of statements
     */
    detectAllConflicts(statements: AST.Statement[]): ConflictResult[];
    /**
     * Get ontology statistics (for debugging/monitoring)
     */
    getStatistics(): {
        hierarchyCount: number;
        instanceCount: number;
        constraintCount: number;
        disjointPairCount: number;
    };
}
//# sourceMappingURL=ontology-reasoner.d.ts.map