/**
 * Rule Loader for V3.1 Inference Engine
 * Loads and validates inference rules from JSON configuration files
 *
 * Supports both legacy and domain-specific rule formats:
 * - Legacy: logical_inference wrapper (v3.1 pattern-based, v3.4 object-based)
 * - Domain-specific: ruleFileType discriminator (pattern-inference, configuration, expansion-template)
 */
import { InferenceRule, RuleSet, ValidationResult, ModelDefinition, ControllerSpec, ServiceSpec, EventSpec, ViewSpec, LogicalComponentSpec, LogicalInstance, LogicalChannel, LogicalBinding } from './types.js';
import { RuleFile, RuleFileType } from './rule-file-types.js';
export declare class RuleLoader {
    private debug;
    private loadedRules;
    private loadedDomainSpecificFiles;
    constructor(debug?: boolean);
    /**
     * Load rules from the entity registry (runtime approach).
     * Each entity module with inference rules provides loader functions that
     * return the parsed JSON rule content directly — no filesystem needed.
     *
     * Returns true if rules were loaded from registry, false if registry
     * is unavailable (caller should fall back to loadRulesFromDirectory).
     */
    loadRulesFromRegistry(): Promise<{
        loaded: boolean;
        ruleSets: RuleSet[];
        validation: ValidationResult;
    }>;
    /**
     * Load rule set from a JSON file
     * Supports both legacy and domain-specific formats with automatic detection
     */
    loadRuleSet(filePath: string): Promise<{
        ruleSet: RuleSet;
        validation: ValidationResult;
    }>;
    /**
     * Load legacy format rule set (logical_inference wrapper)
     */
    private loadLegacyRuleSet;
    /**
     * Load domain-specific format rule set (ruleFileType discriminator)
     */
    private loadDomainSpecificRuleSet;
    /**
     * Load deployment rule set directly without migration
     */
    private loadDeploymentRuleSet;
    /**
     * Convert domain-specific file to legacy format structure
     */
    private convertDomainSpecificToLegacy;
    /**
     * Load multiple rule sets from a directory
     */
    loadRulesFromDirectory(directoryPath: string): Promise<{
        ruleSets: RuleSet[];
        validation: ValidationResult;
    }>;
    /**
     * Get logical inference rules from loaded rule sets
     */
    getLogicalRules(): {
        controllers: InferenceRule<ModelDefinition, ControllerSpec>[];
        services: InferenceRule<ModelDefinition, ServiceSpec>[];
        events: InferenceRule<ModelDefinition, EventSpec>[];
        views: InferenceRule<ModelDefinition, ViewSpec>[];
    };
    /**
     * Get deployment inference rules from loaded rule sets
     */
    getDeploymentRules(): {
        instances: InferenceRule<LogicalComponentSpec, LogicalInstance>[];
        channels: InferenceRule<LogicalComponentSpec, LogicalChannel>[];
        bindings: InferenceRule<LogicalComponentSpec, LogicalBinding>[];
    };
    /**
     * Clear all loaded rules
     */
    clearLoadedRules(): void;
    /**
     * Get loaded domain-specific files by type
     */
    getDomainSpecificFiles(fileType?: RuleFileType): RuleFile[];
    private createEmptyRuleSet;
    private validateRuleSetStructure;
    private validateAllRules;
    private validateLogicalRules;
    private validateDeploymentRules;
    private validateIndividualRule;
    private logRuleSetSummary;
}
//# sourceMappingURL=rule-loader.d.ts.map