@odoo/o-spreadsheet 19.5.0-alpha.2 → 19.5.0-alpha.20

package/dist/types/constants.d.ts

@@ -12,6 +12,7 @@ export declare const FROZEN_PANE_BORDER_COLOR = "#DADFE8";
 export declare const COMPOSER_ASSISTANT_COLOR = "light-dark(#9B359B, #B972A6)";
 export declare const COLOR_TRANSPARENT = "#00000000";
 export declare const TABLE_HOVER_BACKGROUND_COLOR = "#017E8414";
+export declare const DEFAULT_CHART_BACKGROUND_COLOR = "#FFFFFF";
 export declare const CHART_WATERFALL_POSITIVE_COLOR = "#4EA7F2";
 export declare const CHART_WATERFALL_NEGATIVE_COLOR = "#EA6175";
 export declare const CHART_WATERFALL_SUBTOTAL_COLOR = "#AAAAAA";
@@ -64,6 +65,9 @@ export declare const MENU_SEPARATOR_BORDER_WIDTH = 1;
 export declare const MENU_SEPARATOR_PADDING = 5;
 export declare const MENU_SEPARATOR_HEIGHT: number;
 export declare const ZOOM_VALUES: number[];
+export declare const MIN_ZOOM = 0.5;
+export declare const MAX_ZOOM = 2;
+export declare const DEFAULT_ZOOM = 1;
 export declare const DEFAULT_STYLE: {
     align: "default";
     verticalAlign: "bottom";
@@ -96,7 +100,7 @@ export declare const DEFAULT_NUMBER_STYLE: {
 export declare const DEFAULT_VERTICAL_ALIGN: "bottom";
 export declare const DEFAULT_WRAPPING_MODE: "overflow";
 export declare const DEFAULT_TEXT_HIGHLIGHT_PERCENT = 0.25;
-export declare const DEFAULT_FONT_WEIGHT = "400";
+export declare const DEFAULT_FONT_WEIGHT = 400;
 export declare const DEFAULT_FONT_SIZE: number;
 export declare const HEADER_FONT_SIZE = 11;
 export declare const DEFAULT_FONT = "'Roboto', arial, 'Liberation Sans'";
@@ -106,9 +110,10 @@ export declare const MAX_HISTORY_STEPS = 99;
 export declare const DEFAULT_REVISION_ID = "START_REVISION";
 export declare const DEFAULT_FIGURE_HEIGHT = 335;
 export declare const DEFAULT_FIGURE_WIDTH = 536;
+export declare const DEFAULT_SCORECARD_HEIGHT = 101;
+export declare const DEFAULT_SCORECARD_WIDTH = 213;
 export declare const FIGURE_BORDER_WIDTH = 1;
 export declare const ACTIVE_BORDER_WIDTH = 2;
-export declare const MIN_FIG_SIZE = 80;
 export declare const MAX_CHAR_LABEL = 20;
 export declare const FIGURE_ID_SPLITTER = "??";
 export declare const DEFAULT_GAUGE_LOWER_COLOR = "#EA6175";
@@ -122,6 +127,7 @@ export declare const DEFAULT_SCORECARD_BASELINE_FONT_SIZE = 16;
 export declare const LINE_FILL_TRANSPARENCY = 0.4;
 export declare const LINE_DATA_POINT_RADIUS = 3;
 export declare const DEFAULT_WINDOW_SIZE = 2;
+export declare const MAX_CHART_PREVIEW_DATA_POINTS = 20;
 export declare const MESSAGE_VERSION = 1;
 export declare const FORBIDDEN_SHEETNAME_CHARS: readonly ["'", "*", "?", "/", "\\", "[", "]"];
 export declare const FORBIDDEN_SHEETNAME_CHARS_IN_EXCEL_REGEX: RegExp;
@@ -158,6 +164,14 @@ export declare const DEFAULT_CAROUSEL_TITLE_STYLE: {
     fontSize: number;
     color: string;
 };
+export declare const CAROUSEL_LAYOUT: {
+    readonly paddingX: 24;
+    readonly paddingY: 8;
+    readonly headerPaddingTop: 4;
+    readonly separatorWidth: 1;
+    readonly headerLineHeight: 1.5;
+    readonly minHeaderHeight: 25;
+};
 export declare const DEFAULT_TOKEN_COLOR: Color;
 export declare const tokenColors: {
     readonly OPERATOR: "#3da4ab";
@@ -171,3 +185,4 @@ export declare const tokenColors: {
     readonly ORPHAN_RIGHT_PAREN: "#ff0000";
 };
 export declare const DRAG_THRESHOLD = 5;
+export declare const PRINT_DPR = 3;

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

@@ -3,6 +3,7 @@
  */
 export interface FunctionCode {
     readonly returnExpression: JsString;
+    readonly returnsMatrix: boolean;
     /**
      * Return the same function code but with the return expression assigned to a variable.
      */
@@ -26,7 +27,7 @@ export declare class FunctionCodeBuilder {
     private code;
     constructor(scope?: Scope);
     append(...lines: (JsString | FunctionCode)[]): void;
-    return(expression: JsString): FunctionCode;
+    return(expression: JsString, returnsMatrix?: boolean): FunctionCode;
     toString(): string;
 }
 export declare class Scope {

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

@@ -1,4 +1,5 @@
-import { CoreGetters } from "../types/core_getters";
+import { ComputeFunction } from "../types/functions";
+import { CoreGetters } from "../types/getters";
 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();
@@ -92,6 +98,7 @@ export declare class CompiledFormula implements Omit<ICompiledFormula, "tokens"
      * Make a new instance of CompiledFormula by compiling the formula string as input by the user.
      * */
     static Compile(formula: string, sheetId: UID, getters: CoreGetters): CompiledFormula;
+    areRangeShapesInLineWithNormalizedFormula(): boolean;
 }
 /**
  * A compiled formula serialized

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,11 +1,10 @@
 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;
 }
 export declare const functionRegistry: FunctionRegistry;
+/** Formulas using one of these functions are never squished: they are always exported
+ * as a full formula string, and they don't become the base formula of the next cells. */
+export declare const NonSquishableFunctionRegistry: Registry<string>;

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

@@ -1,5 +1,5 @@
-import { CoreGetters } from "../types/core_getters";
 import { EvalContext } from "../types/functions";
+import { CoreGetters } from "../types/getters";
 import { FunctionResultObject, Maybe, UID } from "../types/misc";
 import { PivotCoreMeasure } from "../types/pivot";
 /**

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/helpers.d.ts

@@ -17,6 +17,10 @@ export declare function strictToNumber(data: FunctionResultObject | CellValue |
 export declare function toInteger(value: FunctionResultObject | CellValue | undefined, locale: Locale): number;
 export declare function strictToInteger(value: FunctionResultObject | CellValue | undefined, locale: Locale): number;
 export declare function toString(data: FunctionResultObject | CellValue | undefined): string;
+/**
+ * Only converts the decimal separator, ignore number format such as % or dates
+ */
+export declare function toLocaleString(data: FunctionResultObject | CellValue | undefined, locale: Locale): string;
 /**
  * Normalize range by setting all the string in the range to lowercase and replacing
  * accent letters with plain letters

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;