@odoo/o-spreadsheet 18.0.55 → 18.0.68

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

@@ -0,0 +1,108 @@
+import { AddFunctionDescription, Arg, FunctionResultObject, Matrix, Maybe } from "../types";
+import { EvaluationError } from "../types/errors";
+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;
+    isExported: true;
+};
+export declare const COLUMN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, cellReference: Maybe<{
+        value: string;
+    }>) => number | {
+        value: string;
+    } | Matrix<{
+        value: number;
+    }>;
+    isExported: true;
+};
+export declare const COLUMNS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (range: {
+        value: string;
+    }) => number | {
+        value: string;
+    };
+    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;
+    isExported: true;
+};
+export declare const ROW: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, cellReference: Maybe<{
+        value: string;
+    }>) => number | {
+        value: string;
+    } | Matrix<{
+        value: number;
+    }>;
+    isExported: true;
+};
+export declare const ROWS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (range: {
+        value: string;
+    }) => number | {
+        value: string;
+    };
+    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 | 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>) => EvaluationError | FunctionResultObject | Matrix<FunctionResultObject>;
+};
+export declare const OFFSET: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, cellReference: Maybe<{
+        value: string;
+    }>, offsetRows: Maybe<FunctionResultObject>, offsetColumns: Maybe<FunctionResultObject>, height: Maybe<FunctionResultObject>, width: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject> | {
+        value: string;
+    };
+};

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

@@ -0,0 +1,354 @@
+import { AddFunctionDescription, Arg, FunctionResultNumber, FunctionResultObject, Matrix, Maybe } from "../types";
+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;
+    isExported: true;
+};
+export declare const ACOSH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    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;
+    isExported: true;
+};
+export declare const ASIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    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;
+    isExported: true;
+};
+export declare const ATANH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const CEILING: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, factor?: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    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;
+    isExported: true;
+};
+export declare const COTH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    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;
+    isExported: true;
+};
+export declare const CSCH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const DECIMAL: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, base: Maybe<FunctionResultObject>) => number;
+    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>) => FunctionResultNumber;
+    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;
+    isExported: true;
+};
+export declare const LOG: AddFunctionDescription;
+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>) => 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>) => FunctionResultNumber;
+    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>) => Matrix<number>;
+    isExported: true;
+};
+export declare const RANDBETWEEN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, low: Maybe<FunctionResultObject>, high: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    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) => Matrix<FunctionResultObject>;
+    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>) => FunctionResultNumber;
+    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,77 @@
+import { FunctionResultNumber, FunctionResultObject, Maybe } from "../types";
+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>) => FunctionResultNumber;
+};
+export declare const EQ: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => boolean;
+};
+export declare const GT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => boolean;
+};
+export declare const GTE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => boolean;
+};
+export declare const LT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => boolean;
+};
+export declare const LTE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => boolean;
+};
+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>) => boolean;
+};
+export declare const POW: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, base: Maybe<FunctionResultObject>, exponent: Maybe<FunctionResultObject>) => FunctionResultNumber;
+};
+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";
+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;
+};