/**
 * @file src/application/services/SimpleRuleLoaderService.ts
 * @description Simple rule loader service (SOLID SRP + Functional Programming)
 */
import { SimpleRuleConfig, SimpleRuleLoadResult } from '../../shared/types/simple-rules';
/**
 * @interface SimpleRuleLoaderOptions
 * @description Options for the simple rule loader
 */
interface SimpleRuleLoaderOptions {
    /** Working directory for relative paths */
    workingDirectory?: string;
    /** Whether to include core rules by default */
    includeCoreRules?: boolean;
    /** Whether to validate loaded rules */
    validateRules?: boolean;
}
/**
 * @class SimpleRuleLoaderService
 * @description Service for loading simple rules (SOLID SRP)
 */
export declare class SimpleRuleLoaderService {
    private readonly workingDirectory;
    private readonly includeCoreRules;
    private readonly validateRules;
    constructor(options?: SimpleRuleLoaderOptions);
    /**
     * Loads simple rules from a configuration (Main Orchestrator Method)
     * @param config - Rule configuration
     * @returns Promise with loaded rules and any errors/warnings
     */
    loadRules(config: SimpleRuleConfig): Promise<SimpleRuleLoadResult>;
    /**
     * Gets base rules to start with (Pure Function)
     * @returns Base rules
     */
    private getBaseRules;
    /**
     * Loads multiple rule sets (Pure Function with Guard Clauses)
     * @param ruleSetPaths - Array of rule set paths
     * @returns Array of rule load results
     */
    private loadRuleSets;
    /**
     * Loads a single rule set (Pure Function with Guard Clauses)
     * @param ruleSetPath - Path to rule set
     * @returns Rule load result
     */
    private loadRuleSet;
    /**
     * Loads a core rule set (Pure Function)
     * @param corePath - Core rule set path
     * @returns Rule load result
     */
    private loadCoreRuleSet;
    /**
     * Loads rule set from local file (Pure Function with Guard Clauses)
     * @param filePath - Path to rule file
     * @returns Rule load result
     */
    private loadRuleSetFromFile;
    /**
     * Loads rule set from URL (Placeholder - Pure Function)
     * @param url - URL to load from
     * @returns Rule load result
     */
    private loadRuleSetFromUrl;
    /**
     * Parses content by file extension (Pure Function)
     * @param content - File content
     * @param extension - File extension
     * @returns Rule load result
     */
    private parseContentByExtension;
    /**
     * Extracts rules from parsed content (Pure Function)
     * @param content - Parsed content
     * @returns Rule load result
     */
    private extractRulesFromContent;
    private createEmptyResult;
    private extractRulesFromResults;
    private extractErrorsFromResults;
    private extractWarningsFromResults;
    private isUrl;
    private validateLoadedRules;
}
export {};
//# sourceMappingURL=SimpleRuleLoaderService.d.ts.map