@odoo/o-spreadsheet 19.5.0-alpha.6 → 19.5.0-alpha.7

package/dist/types/formulas/compiler.d.ts

@@ -1,4 +1,5 @@
 import { CoreGetters } from "../types/core_getters";
+import { ComputeFunction } from "../types/functions";
 import { ApplyRangeChange, ApplyRenameNamedRange, FormulaToExecute, LiteralValues, NamedRange, UID } from "../types/misc";
 import { Range, RangeStringOptions } from "../types/range";
 import { AST } from "./parser";
@@ -25,6 +26,7 @@ export declare const UNARY_OPERATOR_MAP: {
 };
 interface ICompiledFormula {
     execute: FormulaToExecute;
+    computeFunctions: ComputeFunction[];
     tokens: Token[];
     dependencies: string[];
     isBadExpression: boolean;
@@ -35,6 +37,9 @@ interface ICompiledFormula {
 export declare const functionCache: {
     [key: string]: FormulaToExecute;
 };
+export declare const computeFunctionsCache: {
+    [key: string]: ComputeFunction[];
+};
 /**
  * A compiled formula is the result of the compilation of a formula string.
  * It contains all the information needed to execute the formula, as well as some metadata
@@ -49,6 +54,7 @@ export declare class CompiledFormula implements Omit<ICompiledFormula, "tokens"
     readonly isBadExpression: boolean;
     readonly normalizedFormula: string;
     readonly execute: FormulaToExecute;
+    readonly computeFunctions: ComputeFunction[];
     readonly rangeDependencies: Range[];
     hasDependencies: boolean;
     private constructor();

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

@@ -1,4 +1,4 @@
-import { ComputeFunction, EvalContext, FunctionDescription } from "../types/functions";
+import { ArgDefinition, ComputeFunction, EvalContext, FunctionDescription } from "../types/functions";
 import { Arg, FunctionResultObject, Matrix } from "../types/misc";
 /**
  * Enables a formula function to accept matrix or vector inputs instead of simple value, computing results across multiple dimensions.
@@ -36,7 +36,8 @@ import { Arg, FunctionResultObject, Matrix } from "../types/misc";
  * - For special behaviors (e.g. the `IF` function), you may declare all arguments
  *   as ranges and invoke this helper directly within your `compute` implementation.
  */
-export declare function applyVectorization(context: EvalContext, descr: FunctionDescription, args: Arg[], acceptToVectorize?: boolean[] | undefined): FunctionResultObject | Matrix<FunctionResultObject>;
-export declare function createComputeFunction(descr: FunctionDescription): ComputeFunction<Matrix<FunctionResultObject> | FunctionResultObject>;
+export declare function applyVectorization(context: EvalContext, descr: FunctionDescription, args: Arg[], argDefinitions: ArgDefinition[], vectorizedArgsIndices: number[]): FunctionResultObject | Matrix<FunctionResultObject>;
+export declare function getFunctionArgDefinitions(descr: FunctionDescription, argCount: number): ArgDefinition[];
+export declare function createComputeFunction(descr: FunctionDescription, argCount: number, vectorizedArgsIndices?: number[]): ComputeFunction;
 export declare function handleError(e: unknown, functionName: string): FunctionResultObject;
 export declare const implementationErrorMessage: string;

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

@@ -1,10 +1,6 @@
 import { Registry } from "../registries/registry";
-import { AddFunctionDescription, ComputeFunction, FunctionDescription } from "../types/functions";
-import { FunctionResultObject, Matrix } from "../types/misc";
+import { AddFunctionDescription, FunctionDescription } from "../types/functions";
 export declare class FunctionRegistry extends Registry<FunctionDescription> {
-    mapping: {
-        [key: string]: ComputeFunction<Matrix<FunctionResultObject> | FunctionResultObject>;
-    };
     add(name: string, addDescr: AddFunctionDescription): this;
     replace(name: string, addDescr: AddFunctionDescription): this;
 }

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

@@ -22,3 +22,4 @@ export declare function multiplyMatrices(matrix1: Matrix<number>, matrix2: Matri
  */
 export declare function toScalar<T>(arg: Matrix<T> | T): T;
 export declare function isMultipleElementMatrix(arg: any): boolean;
+export declare function getMatrixArgIndices(args: unknown[]): number[];

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

@@ -19,3 +19,9 @@ export declare function expM(M: Matrix<number>): Matrix<number>;
 export declare function logM(M: Matrix<number>): Matrix<number>;
 export declare function predictLinearValues(Y: Matrix<number>, X: Matrix<number>, newX: Matrix<number>, computeIntercept: boolean): Matrix<number>;
 export declare function getMovingAverageValues(dataset: number[], labels: number[], windowSize?: number): Point[];
+export declare function lnGamma(z: number): number;
+export declare function regularizedGammaUpper(a: number, x: number): number;
+export declare function regularizedBeta(x: number, a: number, b: number): number;
+export declare function normInv(p: number): number;
+export declare function tDistTwoTail(t: number, df: number): number;
+export declare function tInv2T(alpha: number, df: number): number;

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

@@ -3,135 +3,151 @@ import { Arg, FunctionResultObject, Matrix, Maybe } from "../types/misc";
 export declare const ARRAY_CONSTRAIN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, array: Arg, rows: Maybe<FunctionResultObject>, columns: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, array: Arg, rows: Maybe<FunctionResultObject>, columns: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: false;
 };
 export declare const ARRAY_LITERAL: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: false;
     hidden: true;
 };
 export declare const ARRAY_ROW: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: false;
     hidden: true;
 };
 export declare const CHOOSECOLS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, array: Arg, ...columns: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, array: Arg, ...columns: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const CHOOSEROWS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, array: Arg, ...rows: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, array: Arg, ...rows: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const EXPAND: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, arg: Arg, rows: Maybe<FunctionResultObject>, columns?: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, arg: Arg, rows: Maybe<FunctionResultObject>, columns?: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const FLATTEN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...ranges: Arg[]) => Matrix<FunctionResultObject>;
+    computeArray: (...ranges: Arg[]) => Matrix<FunctionResultObject>;
     isExported: false;
 };
 export declare const FREQUENCY: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (data: Matrix<FunctionResultObject>, classes: Matrix<FunctionResultObject>) => Matrix<number>;
+    computeArray: (data: Matrix<FunctionResultObject>, classes: Matrix<FunctionResultObject>) => {
+        value: number;
+    }[][];
     isExported: true;
 };
 export declare const HSTACK: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const MDETERM: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (matrix: Arg) => number | EvaluationError;
+    compute: (matrix: Arg) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const MINVERSE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (matrix: Arg) => EvaluationError | Matrix<number>;
+    computeArray: (matrix: Arg) => EvaluationError | Matrix<{
+        value: number;
+    }>;
     isExported: true;
 };
 export declare const MMULT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (matrix1: Arg, matrix2: Arg) => EvaluationError | Matrix<number>;
+    computeArray: (matrix1: Arg, matrix2: Arg) => EvaluationError | Matrix<{
+        value: number;
+    }>;
     isExported: true;
 };
 export declare const SUMPRODUCT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number | EvaluationError;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const SUMX2MY2: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (arrayX: Arg, arrayY: Arg) => number | EvaluationError;
+    compute: (arrayX: Arg, arrayY: Arg) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const SUMX2PY2: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (arrayX: Arg, arrayY: Arg) => number | EvaluationError;
+    compute: (arrayX: Arg, arrayY: Arg) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const SUMXMY2: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (arrayX: Arg, arrayY: Arg) => number | EvaluationError;
+    compute: (arrayX: Arg, arrayY: Arg) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const TOCOL: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, array: Arg, ignore?: Maybe<FunctionResultObject>, scanByColumn?: Maybe<FunctionResultObject>) => NotAvailableError | FunctionResultObject[][];
+    computeArray: (this: import("..").EvalContext, array: Arg, ignore?: Maybe<FunctionResultObject>, scanByColumn?: Maybe<FunctionResultObject>) => NotAvailableError | FunctionResultObject[][];
     isExported: true;
 };
 export declare const TOROW: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, array: Arg, ignore?: Maybe<FunctionResultObject>, scanByColumn?: Maybe<FunctionResultObject>) => NotAvailableError | FunctionResultObject[][];
+    computeArray: (this: import("..").EvalContext, array: Arg, ignore?: Maybe<FunctionResultObject>, scanByColumn?: Maybe<FunctionResultObject>) => NotAvailableError | FunctionResultObject[][];
     isExported: true;
 };
 export declare const TRANSPOSE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (arg: Arg) => Matrix<FunctionResultObject>;
+    computeArray: (arg: Arg) => Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const VSTACK: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const WRAPCOLS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, range: Arg, wrapCount: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, range: Arg, wrapCount: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const WRAPROWS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, range: Arg, wrapCount: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, range: Arg, wrapCount: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const ARRAYTOTEXT: {
@@ -139,6 +155,8 @@ export declare const ARRAYTOTEXT: {
     args: import("..").ArgDefinition[];
     compute: (this: import("..").EvalContext, array: Matrix<{
         value: string;
-    }>, format?: Maybe<FunctionResultObject>) => string | EvaluationError;
+    }>, format?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };

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

@@ -8,13 +8,17 @@ export declare const DAVERAGE: {
 export declare const DCOUNT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DCOUNTA: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DGET: {
@@ -44,13 +48,17 @@ export declare const DPRODUCT: {
 export declare const DSTDEV: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DSTDEVP: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DSUM: {
@@ -62,12 +70,16 @@ export declare const DSUM: {
 export declare const DVAR: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DVARP: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };

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

@@ -12,79 +12,107 @@ export declare const DATE: {
 export declare const DATEDIF: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, endDate: Maybe<FunctionResultObject>, unit: Maybe<FunctionResultObject>) => number | EvaluationError;
+    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, endDate: Maybe<FunctionResultObject>, unit: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DATEVALUE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, dateString: Maybe<FunctionResultObject>) => number | EvaluationError;
+    compute: (this: import("..").EvalContext, dateString: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DAY: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DAYS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, endDate: Maybe<FunctionResultObject>, startDate: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, endDate: Maybe<FunctionResultObject>, startDate: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DAYS360: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, endDate: Maybe<FunctionResultObject>, method?: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, endDate: Maybe<FunctionResultObject>, method?: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const EDATE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, months: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, months: Maybe<FunctionResultObject>) => {
+        value: number;
+        format: string;
+    };
     isExported: true;
 };
 export declare const EOMONTH: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, months: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, months: Maybe<FunctionResultObject>) => {
+        value: number;
+        format: string;
+    };
     isExported: true;
 };
 export declare const HOUR: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const ISOWEEKNUM: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const MINUTE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const MONTH: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const NETWORKDAYS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, endDate: Maybe<FunctionResultObject>, holidays: Arg) => number;
+    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, endDate: Maybe<FunctionResultObject>, holidays: Arg) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const NETWORKDAYS_INTL: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, endDate: Maybe<FunctionResultObject>, weekend: Maybe<FunctionResultObject>, holidays: Arg) => number;
+    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, endDate: Maybe<FunctionResultObject>, weekend: Maybe<FunctionResultObject>, holidays: Arg) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const NOW: {
@@ -96,7 +124,9 @@ export declare const NOW: {
 export declare const SECOND: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const TIME: {
@@ -111,7 +141,9 @@ export declare const TIME: {
 export declare const TIMEVALUE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, timeString: Maybe<FunctionResultObject>) => number | EvaluationError;
+    compute: (this: import("..").EvalContext, timeString: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const TODAY: {
@@ -123,13 +155,17 @@ export declare const TODAY: {
 export declare const WEEKDAY: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>, type?: Maybe<FunctionResultObject>) => number | EvaluationError;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>, type?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const WEEKNUM: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>, type?: Maybe<FunctionResultObject>) => number | EvaluationError;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>, type?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const WORKDAY: {
@@ -153,13 +189,17 @@ export declare const WORKDAY_INTL: {
 export declare const YEAR: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const YEARFRAC: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, endDate: Maybe<FunctionResultObject>, dayCountConvention?: Maybe<FunctionResultObject>) => number | EvaluationError;
+    compute: (this: import("..").EvalContext, startDate: Maybe<FunctionResultObject>, endDate: Maybe<FunctionResultObject>, dayCountConvention?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+    };
 };
 export declare const MONTH_START: {
     description: string;
@@ -169,17 +209,25 @@ export declare const MONTH_START: {
 export declare const MONTH_END: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => {
+        value: number;
+        format: string;
+    };
 };
 export declare const QUARTER: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
 };
 export declare const QUARTER_START: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    compute: (this: import("..").EvalContext, date: Maybe<FunctionResultObject>) => {
+        value: number;
+        format: string;
+    };
 };
 export declare const QUARTER_END: {
     description: string;

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

@@ -2,6 +2,8 @@ import { FunctionResultObject, Maybe } from "../types/misc";
 export declare const DELTA: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, number1: Maybe<FunctionResultObject>, number2?: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, number1: Maybe<FunctionResultObject>, number2?: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };

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

@@ -4,7 +4,7 @@ import { Arg, FunctionResultObject, Matrix, Maybe } from "../types/misc";
 export declare const FILTER: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (range: Arg, ...conditions: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (range: Arg, ...conditions: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: false;
 };
 export declare const SORT: AddFunctionDescription;
@@ -12,6 +12,6 @@ export declare const SORTN: AddFunctionDescription;
 export declare const UNIQUE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (range: Arg, byColumn: Maybe<FunctionResultObject>, exactlyOnce: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (range: Arg, byColumn: Maybe<FunctionResultObject>, exactlyOnce: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };