/**
 * Built-in logical functions: IF, IFS, AND, OR, NOT, XOR, plus the error-handling
 * IFERROR/IFNA.
 *
 * Arguments arrive already evaluated (the engine evaluates eagerly, matching
 * Excel's argument semantics), so `IF` selecting a branch simply returns that
 * branch's value and never propagates an error from the untaken branch.
 *
 * @packageDocumentation
 */
import type { FormulaFunction } from './formula-function';
import { FunctionCategory } from './formula-function';
import type { FormulaArgument, FormulaValue } from '../types/formula.types';
/** `IF(condition, valueIfTrue, [valueIfFalse])`. */
export declare class IfFunction implements FormulaFunction {
    readonly name = "IF";
    readonly category = FunctionCategory.Logical;
    readonly minArgs = 2;
    readonly maxArgs = 3;
    readonly description = "Returns one value if a condition is TRUE and another if FALSE.";
    evaluate(args: readonly FormulaArgument[]): FormulaValue;
}
/** `IFS(cond1, val1, cond2, val2, …)` — first truthy condition wins; else `#N/A`. */
export declare class IfsFunction implements FormulaFunction {
    readonly name = "IFS";
    readonly category = FunctionCategory.Logical;
    readonly minArgs = 2;
    readonly maxArgs: number;
    readonly description = "Checks multiple conditions and returns the first match.";
    evaluate(args: readonly FormulaArgument[]): FormulaValue;
}
/** `NOT(logical)` — logical negation. */
export declare class NotFunction implements FormulaFunction {
    readonly name = "NOT";
    readonly category = FunctionCategory.Logical;
    readonly minArgs = 1;
    readonly maxArgs = 1;
    readonly description = "Reverses the logic of its argument.";
    evaluate(args: readonly FormulaArgument[]): FormulaValue;
}
/**
 * Shared reduction for boolean aggregators (AND/OR/XOR). Flattens every
 * argument, ignoring blanks (per Excel), coercing the rest to booleans, and
 * short-circuiting on any error or non-coercible value.
 */
declare abstract class BooleanAggregateFunction implements FormulaFunction {
    abstract readonly name: string;
    readonly category = FunctionCategory.Logical;
    readonly minArgs = 1;
    readonly maxArgs: number;
    evaluate(args: readonly FormulaArgument[]): FormulaValue;
    /** Derives the result from the count of TRUE values and total values seen. */
    protected abstract reduce(trueCount: number, total: number): boolean;
}
/** `AND(logical1, …)` — TRUE when every value is TRUE. */
export declare class AndFunction extends BooleanAggregateFunction {
    readonly name = "AND";
    readonly description = "Returns TRUE if all arguments are TRUE.";
    protected reduce(trueCount: number, total: number): boolean;
}
/** `OR(logical1, …)` — TRUE when at least one value is TRUE. */
export declare class OrFunction extends BooleanAggregateFunction {
    readonly name = "OR";
    readonly description = "Returns TRUE if any argument is TRUE.";
    protected reduce(trueCount: number): boolean;
}
/** `XOR(logical1, …)` — TRUE when an odd number of values are TRUE. */
export declare class XorFunction extends BooleanAggregateFunction {
    readonly name = "XOR";
    readonly description = "Returns TRUE if an odd number of arguments are TRUE.";
    protected reduce(trueCount: number): boolean;
}
/** `IFERROR(value, valueIfError)` — substitutes a fallback for any error. */
export declare class IfErrorFunction implements FormulaFunction {
    readonly name = "IFERROR";
    readonly category = FunctionCategory.Logical;
    readonly minArgs = 2;
    readonly maxArgs = 2;
    readonly description = "Returns a fallback value if the first argument is an error.";
    evaluate(args: readonly FormulaArgument[]): FormulaValue;
}
/** `IFNA(value, valueIfNa)` — substitutes a fallback only for `#N/A`. */
export declare class IfNaFunction implements FormulaFunction {
    readonly name = "IFNA";
    readonly category = FunctionCategory.Logical;
    readonly minArgs = 2;
    readonly maxArgs = 2;
    readonly description = "Returns a fallback value only if the first argument is #N/A.";
    evaluate(args: readonly FormulaArgument[]): FormulaValue;
}
export {};
//# sourceMappingURL=logical-functions.d.ts.map