@odoo/o-spreadsheet 17.0.85 → 17.0.96

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

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

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

@@ -0,0 +1,98 @@
+import { CellValue, Maybe, ValueAndFormat } from "../types";
+export declare const ADD: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (value1: Maybe<ValueAndFormat>, value2: Maybe<ValueAndFormat>) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, value1: Maybe<CellValue>, value2: Maybe<CellValue>) => number;
+};
+export declare const CONCAT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (value1: Maybe<CellValue>, value2: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const DIVIDE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (dividend: Maybe<ValueAndFormat>, divisor: Maybe<ValueAndFormat>) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, dividend: Maybe<CellValue>, divisor: Maybe<CellValue>) => number;
+};
+export declare const EQ: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value1: Maybe<CellValue>, value2: Maybe<CellValue>) => boolean;
+};
+export declare const GT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value1: Maybe<CellValue>, value2: Maybe<CellValue>) => boolean;
+};
+export declare const GTE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value1: Maybe<CellValue>, value2: Maybe<CellValue>) => boolean;
+};
+export declare const LT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (this: import("../types").EvalContext, value1: Maybe<CellValue>, value2: Maybe<CellValue>) => boolean;
+};
+export declare const LTE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (this: import("../types").EvalContext, value1: Maybe<CellValue>, value2: Maybe<CellValue>) => boolean;
+};
+export declare const MINUS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (value1: Maybe<ValueAndFormat>, value2: Maybe<ValueAndFormat>) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, value1: Maybe<CellValue>, value2: Maybe<CellValue>) => number;
+};
+export declare const MULTIPLY: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (factor1: Maybe<ValueAndFormat>, factor2: Maybe<ValueAndFormat>) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, factor1: Maybe<CellValue>, factor2: Maybe<CellValue>) => number;
+};
+export declare const NE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (this: import("../types").EvalContext, value1: Maybe<CellValue>, value2: Maybe<CellValue>) => boolean;
+};
+export declare const POW: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, base: Maybe<CellValue>, exponent: Maybe<CellValue>) => number;
+};
+export declare const UMINUS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    computeFormat: (value: Maybe<ValueAndFormat>) => import("../types").Format | undefined;
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, value: Maybe<CellValue>) => number;
+};
+export declare const UNARY_PERCENT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, percentage: Maybe<CellValue>) => number;
+};
+export declare const UPLUS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["ANY"];
+    computeFormat: (value: Maybe<ValueAndFormat>) => import("../types").Format | undefined;
+    compute: (value?: Maybe<CellValue>) => CellValue;
+};