@ricsam/formula-engine 0.0.1

package/dist/types/evaluator/evaluate-scalar-operator.d.ts

@@ -0,0 +1,12 @@
+import type { FormulaEvaluator } from "src/evaluator/formula-evaluator";
+import { type ArethmeticEvaluator, type FunctionEvaluationResult } from "../core/types";
+import type { EvaluationContext } from "./evaluation-context";
+export type EvaluateScalarOperatorOptions = {
+    evaluateScalar: ArethmeticEvaluator;
+    context: EvaluationContext;
+    /**
+     * for debugging messages
+     */
+    name: string;
+};
+export declare function evaluateScalarOperator(this: FormulaEvaluator, left: FunctionEvaluationResult, right: FunctionEvaluationResult, options: EvaluateScalarOperatorOptions): FunctionEvaluationResult;

package/dist/types/evaluator/evaluation-context.d.ts

@@ -0,0 +1,66 @@
+import type { TableManager } from "src/core/managers";
+import type { DependencyNode } from "src/core/managers/dependency-node";
+import type { CellAddress } from "src/core/types";
+export declare class EvaluationContext {
+    private _cellAddress;
+    private _tableName;
+    /**
+     * Can be a range or a cell
+     */
+    private _dependencyNode;
+    constructor(tableManager: TableManager, dependencyNode: DependencyNode, cellAddress: CellAddress);
+    get dependencyNode(): DependencyNode;
+    private _contextDependency;
+    getContextDependency(): ContextDependency;
+    /**
+     * The cell context, the address of the cell being evaluated
+     * and the context in which results should be stored
+     */
+    get cellAddress(): CellAddress;
+    get tableName(): string | undefined;
+    addContextDependency(...types: ContextDependencyType[]): void;
+    /**
+     * When evaluating an AST node,
+     * we need to append the subtree context
+     * dependencies to the current context dependency
+     */
+    appendContextDependency(contextDependency: ContextDependency): void;
+}
+/**
+ * Each value has the same value as the origin cell
+ * the defined keys are the ones the ast node is dependent on
+ * e.g. A3=ROW() will have a context dependency of { rowIndex: 3 }
+ *
+ * The keys are ANDed together, e.g. { workbookName: "Sheet1", sheetName: "Sheet2" }
+ * means the ast node is dependent on the workbook "Sheet1" and the sheet "Sheet2"
+ */
+export type ContextDependency = {
+    workbookName?: string;
+    sheetName?: string;
+    tableName?: string;
+    rowIndex?: number;
+    colIndex?: number;
+};
+export declare const contextDependencyKeys: readonly ["workbookName", "sheetName", "tableName", "rowIndex", "colIndex"];
+/**
+ * These are some distinct scenarios where context dependencies are added
+ */
+export type ContextDependencyType = "row" | "col" | "workbook" | "sheet" | "table";
+/** Build the canonical cache key string for a dependency. */
+export declare function keyFromDependency(dep: ContextDependency): string;
+type Context = {
+    workbookName: string;
+    sheetName: string;
+    tableName?: string;
+    rowIndex: number;
+    colIndex: number;
+};
+/** True if `dep` matches `ctx` (i.e., every specified field equals the context’s field). */
+export declare function dependencyMatchesContext(ctx: Context, dep: ContextDependency): boolean;
+/**
+ * Generate every cache key that would be eligible for `ctx`.
+ * By default returns keys ordered from most-specific to least-specific.
+ */
+export declare function eligibleKeysForContext(ctx: Context): string[];
+export declare function getContextDependencyKey(contextDependency: ContextDependency): string;
+export {};

package/dist/types/evaluator/evaluation-error.d.ts

@@ -0,0 +1,20 @@
+import type { DependencyNode } from "src/core/managers/dependency-node";
+import type { FormulaError } from "src/core/types";
+export declare class EvaluationError extends Error {
+    readonly type: FormulaError;
+    readonly errAddress?: DependencyNode | undefined;
+    constructor(type: FormulaError, message: string, errAddress?: DependencyNode | undefined);
+}
+export declare class AwaitingEvaluationError extends Error {
+    readonly errAddress: DependencyNode;
+    readonly waitingFor: DependencyNode;
+    constructor(errAddress: DependencyNode, waitingFor: DependencyNode);
+}
+export declare class SheetNotFoundError extends Error {
+    readonly sheetName: string;
+    constructor(sheetName: string);
+}
+export declare class WorkbookNotFoundError extends Error {
+    readonly workbookName: string;
+    constructor(workbookName: string);
+}

package/dist/types/evaluator/formula-evaluator.d.ts

@@ -0,0 +1,67 @@
+import { type CellAddress, type CellValue, type FunctionEvaluationResult, type SpreadsheetRange } from "../core/types";
+import type { DependencyManager } from "src/core/managers/dependency-manager";
+import type { TableManager } from "src/core/managers/table-manager";
+import { type EvaluateScalarOperatorOptions } from "src/evaluator/evaluate-scalar-operator";
+import type { ArrayNode, ASTNode, BinaryOpNode, FunctionNode, NamedExpressionNode, RangeNode, ReferenceNode, StructuredReferenceNode, ThreeDRangeNode, UnaryOpNode, ValueNode } from "src/parser/ast";
+import type { NamedExpressionManager } from "src/core/managers/named-expression-manager";
+import { EvaluationContext } from "./evaluation-context";
+export declare class FormulaEvaluator {
+    private tableManager;
+    private dependencyManager;
+    private namedExpressionManager;
+    constructor(tableManager: TableManager, dependencyManager: DependencyManager, namedExpressionManager: NamedExpressionManager);
+    evaluateFormula(
+    /**
+     * formula is the formula to evaluate, without the leading =
+     */
+    formula: string, context: EvaluationContext): FunctionEvaluationResult;
+    evaluateNode(node: ASTNode, context: EvaluationContext): FunctionEvaluationResult;
+    evaluateStructuredReference(node: StructuredReferenceNode, context: EvaluationContext): FunctionEvaluationResult;
+    /**
+     * Evaluates a value node
+     */
+    evaluateValue(node: ValueNode): CellValue;
+    evaluate3DRange(node: ThreeDRangeNode, context: EvaluationContext): FunctionEvaluationResult;
+    evaluateRange(node: RangeNode, context: EvaluationContext): FunctionEvaluationResult;
+    evaluateArray(node: ArrayNode, context: EvaluationContext): FunctionEvaluationResult;
+    /**
+     * Evaluates a unary operation
+     */
+    evaluateUnaryOp(node: UnaryOpNode, context: EvaluationContext): FunctionEvaluationResult;
+    /**
+     * Evaluates a unary scalar operation
+     */
+    private evaluateUnaryScalar;
+    /**
+     * Evaluates a binary operation
+     */
+    evaluateBinaryOp(node: BinaryOpNode, context: EvaluationContext): FunctionEvaluationResult;
+    /**
+     * Evaluates a reference node
+     */
+    evaluateReference(node: ReferenceNode, context: EvaluationContext): FunctionEvaluationResult;
+    /**
+     * Evaluates a named expression node
+     */
+    evaluateNamedExpression(node: NamedExpressionNode, context: EvaluationContext): FunctionEvaluationResult;
+    /**
+     * Binary scalar operations
+     */
+    evaluateBinaryScalar(operator: string, left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    evaluateFunction(node: FunctionNode, context: EvaluationContext): FunctionEvaluationResult;
+    add(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    multiply(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    divide(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    evaluateScalarOperator(left: FunctionEvaluationResult, right: FunctionEvaluationResult, options: EvaluateScalarOperatorOptions): FunctionEvaluationResult;
+    subtract(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    power(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    equalsOp(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    notEqualsOp(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    lessThanOp(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    lessThanOrEqualOp(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    greaterThanOp(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    greaterThanOrEqualOp(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    concatenateOp(left: FunctionEvaluationResult, right: FunctionEvaluationResult, context: EvaluationContext): FunctionEvaluationResult;
+    projectRange(range: SpreadsheetRange, originCellAddress: CellAddress): SpreadsheetRange;
+    unionRanges(range1: SpreadsheetRange, range2: SpreadsheetRange): SpreadsheetRange;
+}

package/dist/types/evaluator/open-range-evaluator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/evaluator/range-evaluation-node.d.ts

@@ -0,0 +1,16 @@
+import type { DependencyManager } from "src/core/managers/dependency-manager";
+import { FrontierDependencyManager } from "src/core/managers/frontier-dependency-manager";
+import type { WorkbookManager } from "src/core/managers/workbook-manager";
+import type { EvaluateAllCellsResult, RangeAddress } from "src/core/types";
+export declare class RangeEvaluationNode extends FrontierDependencyManager {
+    rangeKey: string;
+    key: string;
+    address: RangeAddress;
+    private _result;
+    constructor(rangeKey: string, dependencyManager: DependencyManager, workbookManager: WorkbookManager);
+    setResult(result: EvaluateAllCellsResult): void;
+    get result(): EvaluateAllCellsResult;
+    canResolve(): boolean;
+    toJSON(visitor?: Set<string>): any;
+    toString(): string;
+}

package/dist/types/functions/_template/template.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * TEMPLATE function implementation
+ */
+export declare const TEMPLATE: FunctionDefinition;

package/dist/types/functions/_template/template.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/array/sequence/performance-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/array/sequence/sequence.d.ts

@@ -0,0 +1,14 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * SEQUENCE(rows, [columns], [start], [step])
+ * Generates a sequence of numbers in an array.
+ *
+ * @param rows - The number of rows to return (can be array - uses origin value)
+ * @param columns - [Optional] The number of columns to return (default: 1, can be array - uses origin value)
+ * @param start - [Optional] The first number in the sequence (default: 1, can be array - uses origin value)
+ * @param step - [Optional] The amount to increment each subsequent value (default: 1, can be array - uses origin value)
+ *
+ * Returns a spilled array of sequential numbers.
+ * When any argument is an array, the result is broadcast over the largest input spill area.
+ */
+export declare const SEQUENCE: FunctionDefinition;

package/dist/types/functions/array/sequence/sequence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/criteria-parser.d.ts

@@ -0,0 +1,27 @@
+import { type CellValue } from "src/core/types";
+/**
+ * Parsed criteria result
+ */
+export type ParsedCriteria = {
+    type: "exact";
+    value: CellValue;
+} | {
+    type: "comparison";
+    operator: ">" | "<" | ">=" | "<=" | "<>";
+    value: CellValue;
+} | {
+    type: "wildcard";
+    pattern: string;
+} | {
+    type: "error";
+    message: string;
+};
+/**
+ * Simple criteria parser for COUNTIF
+ * Handles: exact values, comparisons (>5, <=10, <>0), and wildcards (*app, ?at)
+ */
+export declare function parseCriteria(criteria: CellValue): ParsedCriteria;
+/**
+ * Check if a cell value matches the parsed criteria
+ */
+export declare function matchesParsedCriteria(cellValue: CellValue, parsedCriteria: ParsedCriteria): boolean;

package/dist/types/functions/criteria-utils.d.ts

@@ -0,0 +1,61 @@
+import { type FunctionEvaluationResult, type SingleEvaluationResult, type CellInfinity, type ErrorEvaluationResult } from "src/core/types";
+import type { EvaluationContext } from "src/evaluator/evaluation-context";
+import type { FormulaEvaluator } from "src/evaluator/formula-evaluator";
+import type { FunctionNode, ASTNode } from "src/parser/ast";
+import { type ParsedCriteria } from "./criteria-parser";
+import type { LookupOrder } from "src/core/managers";
+/**
+ * Criteria pair for criteria-based functions
+ */
+export interface CriteriaPair {
+    rangeResult: FunctionEvaluationResult;
+    parsedCriteria: ParsedCriteria;
+}
+/**
+ * Parse criteria pairs from function arguments
+ * @param node - The function node
+ * @param context - Evaluation context
+ * @param evaluateNode - Node evaluation function
+ * @param startIndex - Index to start parsing criteria pairs from (1 for IFS functions, 0 for COUNTIFS)
+ * @returns Array of criteria pairs or error
+ */
+export declare function parseCriteriaPairs(this: FormulaEvaluator, node: FunctionNode, context: EvaluationContext, evaluateNode: (node: ASTNode, context: EvaluationContext) => FunctionEvaluationResult, startIndex?: number): CriteriaPair[] | ErrorEvaluationResult;
+/**
+ * Check if any criteria involves empty/non-empty cell matching
+ */
+export declare function hasEmptyCriteria(criteriaPairs: CriteriaPair[]): boolean;
+/**
+ * Returns matching values from ranges based on criteria
+ * @param evaluator - The function evaluator context
+ * @param valueRangeResult - The range of values to process
+ * @param criteriaPairs - Array of criteria pairs to match against
+ * @param context - Evaluation context
+ * @returns Array of SingleEvaluationResult for each matching cell - includes both values and errors
+ * Consuming functions decide whether to skip errors or propagate them
+ */
+export declare function processMultiCriteriaValues(evaluator: FormulaEvaluator, valueRangeResult: FunctionEvaluationResult, criteriaPairs: CriteriaPair[], context: EvaluationContext, lookupOrder: LookupOrder): {
+    type: "values";
+    values: SingleEvaluationResult[];
+} | ErrorEvaluationResult;
+/**
+ * Validate multi-criteria function arguments (odd number, min 3)
+ */
+export declare function validateMultiCriteriaArgs(functionName: string, argCount: number, context: EvaluationContext): ErrorEvaluationResult | null;
+/**
+ * Validate COUNTIFS function arguments (even number, min 2)
+ */
+export declare function validateCountifsArgs(argCount: number, context: EvaluationContext): ErrorEvaluationResult | null;
+/**
+ * Validate single criteria function arguments (2 or 3)
+ */
+export declare function validateSingleCriteriaArgs(functionName: string, argCount: number, context: EvaluationContext): ErrorEvaluationResult | null;
+/**
+ * Result type for processInfinity - either return infinity immediately or continue with updated state
+ */
+export type ProcessInfinityResult<T> = {
+    type: "infinity";
+    infinity: CellInfinity;
+} | {
+    type: "state";
+    state: T;
+};

package/dist/types/functions/function-utils.d.ts

@@ -0,0 +1,21 @@
+import type { LookupOrder } from "src/core/managers";
+import { type ErrorEvaluationResult, type SingleEvaluationResult } from "src/core/types";
+import type { EvaluationContext } from "src/evaluator/evaluation-context";
+import type { FormulaEvaluator } from "src/evaluator/formula-evaluator";
+import type { FunctionNode } from "src/parser/ast";
+/**
+ * Creates an array of all values from arguments of a function node
+ * Returns SingleEvaluationResult for each value found in the arguments
+ *
+ * This is a shared utility used by all basic aggregation functions (SUM, MIN, MAX, AVERAGE)
+ * to iterate over their arguments in a consistent way.
+ *
+ * @param evaluator - The formula evaluator instance
+ * @param node - The function node containing arguments
+ * @param context - The evaluation context
+ * @returns Array of SingleEvaluationResult for each value in the arguments
+ */
+export declare function createArgumentIterator(evaluator: FormulaEvaluator, node: FunctionNode, context: EvaluationContext, lookupOrder: LookupOrder): {
+    type: "values";
+    values: SingleEvaluationResult[];
+} | ErrorEvaluationResult;

package/dist/types/functions/index.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionDefinition } from "src/core/types";
+export declare const functions: Record<string, FunctionDefinition>;

package/dist/types/functions/information/cell/cell.d.ts

@@ -0,0 +1,24 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * CELL function - Returns information about the formatting, location, or contents of a cell
+ *
+ * Usage: CELL(info_type, [reference])
+ *
+ * info_type: Text value that specifies what type of cell information you want
+ * reference: The cell or range to get information about (defaults to current cell if omitted)
+ *
+ * Supported info_types:
+ * - "address" - Returns the reference of the first cell in reference, as text
+ * - "col" - Returns the column number of the cell
+ * - "row" - Returns the row number of the cell
+ * - "contents" - Returns the value of the upper-left cell
+ * - "type" - Returns "b" for blank, "l" for label (text), "v" for value (number)
+ * - "width" - Returns the column width
+ * - "filename" - Returns the filename (including full path) of the file
+ *
+ * Examples:
+ * - CELL("address", A1) returns "$A$1"
+ * - CELL("row", B5) returns 5
+ * - CELL("col", C3) returns 3
+ */
+export declare const CELL: FunctionDefinition;

package/dist/types/functions/information/cell/cell.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/information/column/column.d.ts

@@ -0,0 +1,14 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * COLUMN function - Returns the column number of a reference
+ *
+ * Usage: COLUMN([reference])
+ *
+ * If reference is omitted, returns the column number of the cell in which the formula appears.
+ *
+ * Examples:
+ * - COLUMN() returns the column number of the current cell
+ * - COLUMN(C5) returns 3
+ * - COLUMN(A1:E1) returns an array of column numbers {1,2,3,4,5}
+ */
+export declare const COLUMN: FunctionDefinition;

package/dist/types/functions/information/column/column.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/information/row/row.d.ts

@@ -0,0 +1,14 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * ROW function - Returns the row number of a reference
+ *
+ * Usage: ROW([reference])
+ *
+ * If reference is omitted, returns the row number of the cell in which the formula appears.
+ *
+ * Examples:
+ * - ROW() returns the row number of the current cell
+ * - ROW(A5) returns 5
+ * - ROW(A5:A10) returns an array of row numbers {5;6;7;8;9;10}
+ */
+export declare const ROW: FunctionDefinition;

package/dist/types/functions/information/row/row.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/logical/and/and.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * AND function implementation
+ */
+export declare const AND: FunctionDefinition;

package/dist/types/functions/logical/and/and.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/logical/if/if.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * IF function implementation
+ */
+export declare const IF: FunctionDefinition;

package/dist/types/functions/logical/if/if.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/logical/iferror/iferror.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * IFERROR function implementation
+ */
+export declare const IFERROR: FunctionDefinition;

package/dist/types/functions/logical/iferror/iferror.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/logical/or/or.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * OR function implementation
+ */
+export declare const OR: FunctionDefinition;

package/dist/types/functions/logical/or/or.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/lookup/count/count-utils.d.ts

@@ -0,0 +1,14 @@
+import { type CellAddress, type FunctionEvaluationResult, type SingleEvaluationResult } from "src/core/types";
+import type { ParsedCriteria } from "src/functions/criteria-parser";
+/**
+ * Performs counting of numeric values from an iterable of SingleEvaluationResult values
+ * Handles numbers and infinities according to Excel's COUNT behavior
+ * - Propagates errors immediately
+ * - Only counts numeric values (numbers and infinities)
+ * - Ignores non-numeric values (strings, booleans, empty cells)
+ *
+ * @param results - Iterable of SingleEvaluationResult to count
+ * @returns FunctionEvaluationResult with the count
+ */
+export declare function performCount(results: Iterable<SingleEvaluationResult>): FunctionEvaluationResult;
+export declare function countEmptyCells(criteriaRangeResult: FunctionEvaluationResult, parsedCriteria: ParsedCriteria, currentCell: CellAddress): FunctionEvaluationResult | undefined;

package/dist/types/functions/lookup/count/count.d.ts

@@ -0,0 +1,21 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * COUNT function - Counts the number of cells that contain numbers
+ *
+ * Usage: COUNT(value1, [value2], ...)
+ *
+ * Examples:
+ *   COUNT(1, 2, 3) - returns 3
+ *   COUNT(A1:A10) - counts numeric values in the range A1:A10
+ *   COUNT(A1:A5, B1:B5) - counts numeric values in both ranges
+ *
+ * Note:
+ * - Only numeric values are counted (numbers and infinities)
+ * - Text, logical values, and empty cells are ignored
+ * - Errors propagate immediately
+ *
+ * From Excel documentation:
+ * "The COUNT function counts the number of cells that contain numbers,
+ * and counts numbers within the list of arguments."
+ */
+export declare const COUNT: FunctionDefinition;

package/dist/types/functions/lookup/count/count.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/lookup/count/countif.d.ts

@@ -0,0 +1,26 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * COUNTIF function - Counts cells in a range that meet a criteria
+ *
+ * Usage: COUNTIF(range, criteria)
+ *
+ * range: The range of cells to evaluate
+ * criteria: The criteria to match against. Can be:
+ *   - Exact value: "Apple", 42
+ *   - Comparison: ">10", "<=5", "<>0"
+ *   - Wildcards: "App*", "?ruit"
+ *
+ * Examples:
+ *   COUNTIF(A1:A10, "Apple") - counts cells containing "Apple"
+ *   COUNTIF(B1:B10, ">10") - counts cells with values greater than 10
+ *   COUNTIF(C1:C10, "App*") - counts cells starting with "App"
+ *
+ * Note:
+ * - Supports type coercion for comparisons
+ * - Case-sensitive string matching
+ * - Wildcards: * matches any sequence, ? matches any single character
+ */
+/**
+ * COUNTIF function implementation
+ */
+export declare const COUNTIF: FunctionDefinition;

package/dist/types/functions/lookup/count/countif.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/lookup/count/countifs.d.ts

@@ -0,0 +1,21 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * COUNTIFS function - Counts cells that meet multiple criteria
+ *
+ * Usage: COUNTIFS(criteria_range1, criteria1, [criteria_range2, criteria2], ...)
+ *
+ * criteria_range1: The first range to evaluate against criteria1
+ * criteria1: The first criteria to match against
+ * criteria_range2, criteria2: Optional additional criteria pairs
+ *
+ * Examples:
+ *   COUNTIFS(A1:A10, "Apple") - counts cells in A1:A10 that equal "Apple"
+ *   COUNTIFS(A1:A10, "Apple", B1:B10, ">10") - counts where A1:A10 = "Apple" AND B1:B10 > 10
+ *
+ * Note:
+ * - All criteria must be satisfied for a cell to be counted
+ * - Counts all matching cells, not just numeric ones
+ * - Returns 0 if no cells match all criteria
+ * - Unlike other IFS functions, COUNTIFS counts the first criteria range itself
+ */
+export declare const COUNTIFS: FunctionDefinition;

package/dist/types/functions/lookup/count/countifs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/lookup/index-lookup/index-lookup.d.ts

@@ -0,0 +1,2 @@
+import { type FunctionDefinition } from "src/core/types";
+export declare const INDEX: FunctionDefinition;

package/dist/types/functions/lookup/index-lookup/index-lookup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/lookup/match/match.d.ts

@@ -0,0 +1,2 @@
+import { type FunctionDefinition } from "src/core/types";
+export declare const MATCH: FunctionDefinition;

package/dist/types/functions/lookup/match/match.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/lookup/xlookup/xlookup.d.ts

@@ -0,0 +1,2 @@
+import { type FunctionDefinition } from "src/core/types";
+export declare const XLOOKUP: FunctionDefinition;

package/dist/types/functions/lookup/xlookup/xlookup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/math/average/average-utils.d.ts

@@ -0,0 +1,10 @@
+import { type FunctionEvaluationResult, type SingleEvaluationResult } from "src/core/types";
+import type { EvaluationContext } from "src/evaluator/evaluation-context";
+/**
+ * Performs averaging of an iterable of SingleEvaluationResult values
+ * Handles numbers, infinities, and errors according to Excel's AVERAGE behavior
+ *
+ * @param results - Iterable of SingleEvaluationResult to average
+ * @returns FunctionEvaluationResult with the average or appropriate error
+ */
+export declare function performAverage(results: SingleEvaluationResult[], context: EvaluationContext): FunctionEvaluationResult;

package/dist/types/functions/math/average/average.d.ts

@@ -0,0 +1,18 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * AVERAGE function - Calculates the arithmetic mean of all numbers in the arguments
+ *
+ * Usage: AVERAGE(value1, [value2], ...)
+ *
+ * Examples:
+ *   AVERAGE(1, 2, 3) - returns 2
+ *   AVERAGE(A1:A10) - averages all numbers in the range A1:A10
+ *   AVERAGE(A1:A5, B1:B5) - averages all numbers in both ranges
+ *
+ * Note:
+ * - Only numeric values are included in the calculation
+ * - Text, logical values, and empty cells are ignored in ranges
+ * - Direct text/logical arguments cause errors
+ * - Returns #DIV/0! if no numeric values are found
+ */
+export declare const AVERAGE: FunctionDefinition;

package/dist/types/functions/math/average/average.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/functions/math/average/averageif.d.ts

@@ -0,0 +1,23 @@
+import { type FunctionDefinition } from "src/core/types";
+/**
+ * AVERAGEIF function - Calculates the average of cells in a range that meet a criteria
+ *
+ * Usage: AVERAGEIF(range, criteria, [average_range])
+ *
+ * range: The range of cells to evaluate against the criteria
+ * criteria: The criteria to match against. Can be:
+ *   - Exact value: "Apple", 42
+ *   - Comparison: ">10", "<=5", "<>0"
+ *   - Wildcards: "App*", "?ruit"
+ * average_range: Optional. The range to average. If omitted, uses the range parameter
+ *
+ * Examples:
+ *   AVERAGEIF(A1:A10, "Apple") - averages cells in A1:A10 that contain "Apple"
+ *   AVERAGEIF(B1:B10, ">10") - averages cells in B1:B10 with values greater than 10
+ *   AVERAGEIF(A1:A10, "Apple", B1:B10) - averages B1:B10 where A1:A10 contains "Apple"
+ *
+ * Note:
+ * - Only numeric values are included in the average calculation
+ * - Returns error if no values match the criteria
+ */
+export declare const AVERAGEIF: FunctionDefinition;

package/dist/types/functions/math/average/averageif.test.d.ts

@@ -0,0 +1 @@
+export {};