@odoo/o-spreadsheet 19.2.11 → 19.4.0-alpha.4

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

@@ -0,0 +1,59 @@
+import { EvaluationError } from "../types/errors";
+import { AddFunctionDescription } from "../types/functions";
+import { Arg, FunctionResultObject, Maybe } from "../types/misc";
+export declare const AND: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...logicalExpressions: Arg[]) => boolean | EvaluationError;
+    isExported: true;
+};
+export declare const FALSE: AddFunctionDescription;
+export declare const IF: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, logicalExpression: Arg, valueIfTrue: Arg, valueIfFalse: Arg) => FunctionResultObject | import("..").Matrix<FunctionResultObject>;
+    isExported: true;
+};
+export declare const IFERROR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Arg, valueIfError: Arg) => FunctionResultObject | import("..").Matrix<FunctionResultObject>;
+    isExported: true;
+};
+export declare const IFNA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Arg, valueIfError: Arg) => FunctionResultObject | import("..").Matrix<FunctionResultObject>;
+    isExported: true;
+};
+export declare const IFS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => FunctionResultObject | EvaluationError | import("..").Matrix<FunctionResultObject>;
+    isExported: true;
+};
+export declare const NOT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (logicalExpression: Maybe<FunctionResultObject>) => boolean;
+    isExported: true;
+};
+export declare const OR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...logicalExpressions: Arg[]) => boolean | EvaluationError;
+    isExported: true;
+};
+export declare const SWITCH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (expression: Maybe<FunctionResultObject>, ...casesAndValues: Maybe<FunctionResultObject>[]) => FunctionResultObject;
+    isExported: true;
+};
+export declare const TRUE: AddFunctionDescription;
+export declare const XOR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...logicalExpressions: Arg[]) => false | EvaluationError;
+    isExported: true;
+};

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

@@ -0,0 +1,121 @@
+import { EvaluationError, InvalidReferenceError, NotAvailableError } from "../types/errors";
+import { AddFunctionDescription } from "../types/functions";
+import { Arg, FunctionResultObject, Matrix, Maybe } from "../types/misc";
+export declare const ADDRESS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, row: Maybe<FunctionResultObject>, column: Maybe<FunctionResultObject>, absoluteRelativeMode: Maybe<FunctionResultObject>, useA1Notation: Maybe<FunctionResultObject>, sheet: Maybe<FunctionResultObject> | undefined) => string | EvaluationError;
+    isExported: true;
+};
+export declare const COLUMN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, cellReference: Arg) => number | EvaluationError | Matrix<{
+        value: number;
+    }>;
+    isExported: true;
+};
+export declare const COLUMNS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (range: Arg) => number | FunctionResultObject | EvaluationError;
+    isExported: true;
+};
+export declare const HLOOKUP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, searchKey: Maybe<FunctionResultObject>, range: Arg, index: Maybe<FunctionResultObject>, isSorted?: Maybe<FunctionResultObject>) => FunctionResultObject;
+    isExported: true;
+};
+export declare const INDEX: AddFunctionDescription;
+export declare const INDIRECT: AddFunctionDescription;
+export declare const LOOKUP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (searchKey: Maybe<FunctionResultObject>, searchArray: Arg, resultRange: Arg) => FunctionResultObject;
+    isExported: true;
+};
+export declare const MATCH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, searchKey: Maybe<FunctionResultObject>, range: Arg, searchType?: Maybe<FunctionResultObject>) => number | FunctionResultObject | EvaluationError;
+    isExported: true;
+};
+export declare const ROW: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, cellReference: Arg) => number | EvaluationError | Matrix<{
+        value: number;
+    }>;
+    isExported: true;
+};
+export declare const ROWS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (range: Arg) => number | FunctionResultObject | EvaluationError;
+    isExported: true;
+};
+export declare const VLOOKUP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, searchKey: Maybe<FunctionResultObject>, range: Arg, index: Maybe<FunctionResultObject>, isSorted?: Maybe<FunctionResultObject>) => FunctionResultObject;
+    isExported: true;
+};
+export declare const XLOOKUP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, searchKey: Maybe<FunctionResultObject>, lookupRange: Arg, returnRange: Arg, defaultValue: Maybe<FunctionResultObject>, matchMode?: Maybe<FunctionResultObject>, searchMode?: Maybe<FunctionResultObject>) => FunctionResultObject | EvaluationError | FunctionResultObject[][];
+    isExported: true;
+};
+export declare const PIVOT_VALUE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, formulaId: Maybe<FunctionResultObject>, measureName: Maybe<FunctionResultObject>, ...domainArgs: Maybe<FunctionResultObject>[]) => FunctionResultObject;
+};
+export declare const PIVOT_HEADER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, pivotId: Maybe<FunctionResultObject>, ...domainArgs: Maybe<FunctionResultObject>[]) => FunctionResultObject;
+};
+export declare const PIVOT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, pivotFormulaId: Maybe<FunctionResultObject>, rowCount: Maybe<FunctionResultObject>, includeTotal: Maybe<FunctionResultObject>, includeColumnHeaders: Maybe<FunctionResultObject>, columnCount: Maybe<FunctionResultObject>, includeMeasureTitles: Maybe<FunctionResultObject>) => FunctionResultObject | EvaluationError | Matrix<FunctionResultObject>;
+};
+export declare const OFFSET: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, cellReference: Arg, offsetRows: Maybe<FunctionResultObject>, offsetColumns: Maybe<FunctionResultObject>, height: Maybe<FunctionResultObject>, width: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
+};
+export declare const CHOOSE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, index: Maybe<FunctionResultObject>, ...choices: Arg[]) => FunctionResultObject | EvaluationError | Matrix<FunctionResultObject>;
+    isExported: true;
+};
+export declare const DROP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, array: Matrix<{
+        value: string;
+    }>, rows: Maybe<FunctionResultObject>, columns: Maybe<FunctionResultObject>) => EvaluationError | Matrix<{
+        value: string;
+    }>;
+    isExported: true;
+};
+export declare const TAKE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, array: Matrix<{
+        value: string;
+    }>, rows: Maybe<FunctionResultObject>, columns: Maybe<FunctionResultObject>) => EvaluationError | Matrix<{
+        value: string;
+    }>;
+    isExported: true;
+};
+export declare const FORMULATEXT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, cellReference: Maybe<FunctionResultObject>) => string | InvalidReferenceError | NotAvailableError;
+    isExported: true;
+};

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

@@ -0,0 +1,383 @@
+import { DivisionByZeroError, EvaluationError } from "../types/errors";
+import { Arg, FunctionResultNumber, FunctionResultObject, Matrix, Maybe } from "../types/misc";
+export declare const ABS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const ACOS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number | EvaluationError;
+    isExported: true;
+};
+export declare const ACOSH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number | EvaluationError;
+    isExported: true;
+};
+export declare const ACOT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const ACOTH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number | EvaluationError;
+    isExported: true;
+};
+export declare const ASIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number | EvaluationError;
+    isExported: true;
+};
+export declare const ASINH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const ATAN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const ATAN2: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, x: Maybe<FunctionResultObject>, y: Maybe<FunctionResultObject>) => number | DivisionByZeroError;
+    isExported: true;
+};
+export declare const ATANH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number | EvaluationError;
+    isExported: true;
+};
+export declare const CEILING: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, factor?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+        format: import("..").Format | undefined;
+    };
+    isExported: true;
+};
+export declare const CEILING_MATH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, significance?: Maybe<FunctionResultObject>, mode?: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const CEILING_PRECISE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, significance?: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const COS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, angle: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const COSH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const COT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, angle: Maybe<FunctionResultObject>) => number | DivisionByZeroError;
+    isExported: true;
+};
+export declare const COTH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number | DivisionByZeroError;
+    isExported: true;
+};
+export declare const COUNTBLANK: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const COUNTIF: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const COUNTIFS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const COUNTUNIQUE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...args: Arg[]) => number;
+};
+export declare const COUNTUNIQUEIFS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, range: Matrix<FunctionResultObject>, ...args: Arg[]) => number;
+};
+export declare const CSC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, angle: Maybe<FunctionResultObject>) => number | DivisionByZeroError;
+    isExported: true;
+};
+export declare const CSCH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number | DivisionByZeroError;
+    isExported: true;
+};
+export declare const DECIMAL: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, base: Maybe<FunctionResultObject>) => number | EvaluationError;
+    isExported: true;
+};
+export declare const DEGREES: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, angle: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const EXP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const FLOOR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, factor?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+        format: import("..").Format | undefined;
+    };
+    isExported: true;
+};
+export declare const FLOOR_MATH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, significance?: Maybe<FunctionResultObject>, mode?: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const FLOOR_PRECISE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, significance?: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const ISEVEN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => boolean;
+    isExported: true;
+};
+export declare const ISO_CEILING: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, significance?: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const ISODD: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => boolean;
+    isExported: true;
+};
+export declare const LN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number | EvaluationError;
+    isExported: true;
+};
+export declare const LOG: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, base?: Maybe<FunctionResultObject>) => number | EvaluationError;
+    isExported: true;
+};
+export declare const MOD: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, dividend: Maybe<FunctionResultObject>, divisor: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MUNIT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, n: Maybe<FunctionResultObject>) => EvaluationError | Matrix<number>;
+    isExported: true;
+};
+export declare const ODD: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const PI: {
+    description: string;
+    args: never[];
+    compute: () => number;
+    isExported: true;
+};
+export declare const POWER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, base: Maybe<FunctionResultObject>, exponent: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+        format: import("..").Format | undefined;
+    };
+    isExported: true;
+};
+export declare const PRODUCT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...factors: Arg[]) => FunctionResultObject;
+    isExported: true;
+};
+export declare const RAND: {
+    description: string;
+    args: never[];
+    compute: () => number;
+    isExported: true;
+};
+export declare const RANDARRAY: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, rows?: Maybe<FunctionResultObject>, columns?: Maybe<FunctionResultObject>, min?: Maybe<FunctionResultObject>, max?: Maybe<FunctionResultObject>, wholeNumber?: Maybe<FunctionResultObject>) => number[][] | EvaluationError;
+    isExported: true;
+};
+export declare const RANDBETWEEN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, low: Maybe<FunctionResultObject>, high: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+        format: import("..").Format | undefined;
+    };
+    isExported: true;
+};
+export declare const ROUND: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, places?: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const ROUNDDOWN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, places?: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const ROUNDUP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, places?: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const SEC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, angle: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const SECH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const SEQUENCE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, rows: Maybe<FunctionResultObject>, columns?: FunctionResultObject, start?: FunctionResultObject, step?: FunctionResultObject) => EvaluationError | Matrix<{
+        value: number;
+    }>;
+    isExported: true;
+};
+export declare const SIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, angle: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const SINH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const SQRT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+        format: import("..").Format | undefined;
+    };
+    isExported: true;
+};
+export declare const SUBTOTAL: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, functionCode: Maybe<FunctionResultObject>, ...refs: Arg[]) => any;
+    isExported: true;
+};
+export declare const SUM: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const SUMIF: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, criteriaRange: Matrix<FunctionResultObject>, criterion: Maybe<FunctionResultObject>, sumRange: Matrix<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const SUMIFS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, sumRange: Matrix<FunctionResultObject>, ...criters: Arg[]) => number;
+    isExported: true;
+};
+export declare const TAN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, angle: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const TANH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const TRUNC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, places?: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const INT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};

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

@@ -0,0 +1,96 @@
+import { DivisionByZeroError, EvaluationError } from "../types/errors";
+import { Arg, FunctionResultNumber, FunctionResultObject, Maybe } from "../types/misc";
+export declare const ADD: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => FunctionResultNumber;
+};
+export declare const CONCAT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const DIVIDE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, dividend: Maybe<FunctionResultObject>, divisor: Maybe<FunctionResultObject>) => DivisionByZeroError | {
+        value: number;
+        format: import("..").Format | undefined;
+    };
+};
+export declare const EQ: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => FunctionResultObject;
+};
+export declare const GT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => FunctionResultObject;
+};
+export declare const GTE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => FunctionResultObject;
+};
+export declare const LT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => FunctionResultObject;
+};
+export declare const LTE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => FunctionResultObject;
+};
+export declare const MINUS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => FunctionResultNumber;
+};
+export declare const MULTIPLY: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, factor1: Maybe<FunctionResultObject>, factor2: Maybe<FunctionResultObject>) => FunctionResultNumber;
+};
+export declare const NE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => FunctionResultObject;
+};
+export declare const POW: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, base: Maybe<FunctionResultObject>, exponent: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+        format: import("..").Format | undefined;
+    };
+};
+/**
+ * Internal formula implementing the # operator.
+ * It allows to get the spilled range of an array formula from any reference, including
+ * references returned by other functions.
+ * e.g. =IF(condition, A1, H10)#
+ **/
+export declare const SPILLED_RANGE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ref: Arg | undefined) => FunctionResultObject | EvaluationError | import("..").Matrix<FunctionResultObject>;
+    hidden: true;
+};
+export declare const UMINUS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => FunctionResultNumber;
+};
+export declare const UNARY_PERCENT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, percentage: Maybe<FunctionResultObject>) => number;
+};
+export declare const UPLUS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (value?: Maybe<FunctionResultObject>) => FunctionResultObject;
+};

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

@@ -0,0 +1,7 @@
+import { FunctionResultObject, Maybe } from "../types/misc";
+export declare const CONVERT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, startUnit: Maybe<FunctionResultObject>, endUnit: Maybe<FunctionResultObject>) => FunctionResultObject;
+    isExported: true;
+};