import { RuleManagerInterface } from './interfaces/rule-manager';
import { Config, RuleElement, RuleObject } from '../../types';
import { LogManagerInterface } from '../../logger';
import { RuleError } from '../../enums';
/**
 * Provides rule processing calculations with corresponding comparisons methods
 * @category Modules
 * @constructor
 * @implements {RuleManagerInterface}
 */
export declare class RuleManager implements RuleManagerInterface {
    private _comparisonProcessor;
    private readonly _negation;
    private readonly _keys_case_sensitive;
    private _loggerManager;
    private _mapper;
    /**
     * @param {Config=} config
     * @param {Object=} dependencies
     * @param {LogManagerInterface=} dependencies.loggerManager
     */
    constructor(config?: Config, { loggerManager }?: {
        loggerManager?: LogManagerInterface;
    });
    /**
     * Setter for comparison processor
     * @param {Record<string, any>} comparisonProcessor
     */
    set comparisonProcessor(comparisonProcessor: Record<string, any>);
    /**
     * Getter for comparison processor
     */
    get comparisonProcessor(): Record<string, any>;
    /**
     * Retrieve comparison methods from comparison processor
     * @return {Array<string>} List of methods of comparison processor
     */
    getComparisonProcessorMethods(): Array<string>;
    /**
     * Check input data matching to rule set
     * @param {Record<string, any>} data Single value or key-value data set to compare
     * @param {RuleObject} ruleSet
     * @return {boolean | RuleError}
     */
    isRuleMatched(data: Record<string, any>, ruleSet: RuleObject, logEntry?: string): boolean | RuleError;
    /**
     * Check is rule object valid
     * @param {RuleElement} rule
     * @return {boolean}
     */
    isValidRule(rule: RuleElement): boolean;
    /**
     * Process AND block of rule set. Return first false if found
     * @param {Record<string, any>} data Single value or key-value data set to compare
     * @param {RuleAnd} rulesSubset
     * @return {boolean | RuleError}
     * @private
     */
    private _processAND;
    /**
     * Process OR block of rule set. Return first true if found
     * @param {Record<string, any>} data Single value or key-value data set to compare
     * @param {RuleOrWhen} rulesSubset
     * @return {boolean | RuleError}
     * @private
     */
    private _processORWHEN;
    /**
     * Process single rule item
     * @param {Record<string, any>} data Single value or key-value data set to compare
     * @param {RuleElement} rule A single rule to compare
     * @return {boolean | RuleError} Comparison result
     * @private
     */
    private _processRuleItem;
    /**
     * Check is rule data object is a custom interface instead of a literal object
     * @param {Record<string, any>} data Single value or key-value data set to compare
     * @return {boolean}
     */
    isUsingCustomInterface(data: Record<string, any>): boolean;
}