@odoo/o-spreadsheet 17.0.84 → 17.0.96

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

@@ -0,0 +1,141 @@
+import { Arg, ArgValue, CellValue, Matrix, Maybe, ValueAndFormat } from "../types";
+export declare const ARRAY_CONSTRAIN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (this: import("../types").EvalContext, array: Arg, rows: Maybe<ValueAndFormat>, columns: Maybe<ValueAndFormat>) => Matrix<ValueAndFormat>;
+    isExported: false;
+};
+export declare const CHOOSECOLS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (this: import("../types").EvalContext, array: Arg, ...columns: Arg[]) => Matrix<ValueAndFormat>;
+    isExported: true;
+};
+export declare const CHOOSEROWS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (this: import("../types").EvalContext, array: Arg, ...rows: Arg[]) => Matrix<ValueAndFormat>;
+    isExported: true;
+};
+export declare const EXPAND: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (this: import("../types").EvalContext, arg: Arg, rows: Maybe<ValueAndFormat>, columns?: Maybe<ValueAndFormat>, padWith?: Maybe<ValueAndFormat>) => Matrix<ValueAndFormat>;
+    isExported: true;
+};
+export declare const FLATTEN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (...ranges: Arg[]) => Matrix<ValueAndFormat>;
+    isExported: false;
+};
+export declare const FREQUENCY: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<NUMBER>"];
+    compute: (data: Matrix<CellValue>, classes: Matrix<CellValue>) => CellValue[][];
+    isExported: true;
+};
+export declare const HSTACK: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (...ranges: Arg[]) => Matrix<ValueAndFormat>;
+    isExported: true;
+};
+export declare const MDETERM: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (matrix: ArgValue) => number;
+    isExported: true;
+};
+export declare const MINVERSE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<NUMBER>"];
+    compute: (matrix: ArgValue) => Matrix<number>;
+    isExported: true;
+};
+export declare const MMULT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<NUMBER>"];
+    compute: (matrix1: ArgValue, matrix2: ArgValue) => Matrix<number>;
+    isExported: true;
+};
+export declare const SUMPRODUCT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...args: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const SUMX2MY2: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (arrayX: ArgValue, arrayY: ArgValue) => number;
+    isExported: true;
+};
+export declare const SUMX2PY2: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (arrayX: ArgValue, arrayY: ArgValue) => number;
+    isExported: true;
+};
+export declare const SUMXMY2: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (arrayX: ArgValue, arrayY: ArgValue) => number;
+    isExported: true;
+};
+export declare const TOCOL: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (this: import("../types").EvalContext, array: Arg, ignore?: Maybe<ValueAndFormat>, scanByColumn?: Maybe<ValueAndFormat>) => ValueAndFormat[][];
+    isExported: true;
+};
+export declare const TOROW: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (this: import("../types").EvalContext, array: Arg, ignore?: Maybe<ValueAndFormat>, scanByColumn?: Maybe<ValueAndFormat>) => Matrix<ValueAndFormat>;
+    isExported: true;
+};
+export declare const TRANSPOSE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE"];
+    computeValueAndFormat: (arg: Arg) => Matrix<ValueAndFormat>;
+    isExported: true;
+};
+export declare const VSTACK: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (...ranges: Arg[]) => Matrix<ValueAndFormat>;
+    isExported: true;
+};
+export declare const WRAPCOLS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (this: import("../types").EvalContext, range: Arg, wrapCount: Maybe<ValueAndFormat>, padWith?: Maybe<ValueAndFormat>) => Matrix<ValueAndFormat>;
+    isExported: true;
+};
+export declare const WRAPROWS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (this: import("../types").EvalContext, range: Arg, wrapCount: Maybe<ValueAndFormat>, padWith?: Maybe<ValueAndFormat>) => Matrix<ValueAndFormat>;
+    isExported: true;
+};

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

@@ -0,0 +1,8 @@
+import { CellValue, Maybe, ValueAndFormat } from "../types";
+export declare const FORMAT_LARGE_NUMBER: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (this: import("../types").EvalContext, arg: Maybe<ValueAndFormat>, unit: Maybe<ValueAndFormat>) => import("../types").Format;
+    compute: (this: import("../types").EvalContext, value: Maybe<CellValue>) => number;
+};

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

@@ -0,0 +1,85 @@
+import { CellValue, Matrix, Maybe } from "../types";
+export declare const DAVERAGE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};
+export declare const DCOUNT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};
+export declare const DCOUNTA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};
+export declare const DGET: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => CellValue;
+    isExported: true;
+};
+export declare const DMAX: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};
+export declare const DMIN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};
+export declare const DPRODUCT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};
+export declare const DSTDEV: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};
+export declare const DSTDEVP: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};
+export declare const DSUM: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};
+export declare const DVAR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};
+export declare const DVARP: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, database: Matrix<CellValue>, field: Maybe<CellValue>, criteria: Matrix<CellValue>) => number;
+    isExported: true;
+};

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

@@ -0,0 +1,231 @@
+import { ArgValue, CellValue, Maybe } from "../types";
+export declare const DATE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, year: Maybe<CellValue>, month: Maybe<CellValue>, day: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const DATEDIF: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, startDate: Maybe<CellValue>, endDate: Maybe<CellValue>, unit: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const DATEVALUE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, dateString: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const DAY: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const DAYS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, endDate: Maybe<CellValue>, startDate: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const DAYS360: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, startDate: Maybe<CellValue>, endDate: Maybe<CellValue>, method?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const EDATE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, startDate: Maybe<CellValue>, months: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const EOMONTH: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, startDate: Maybe<CellValue>, months: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const HOUR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const ISOWEEKNUM: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const MINUTE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const MONTH: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const NETWORKDAYS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, startDate: Maybe<CellValue>, endDate: Maybe<CellValue>, holidays: ArgValue) => number;
+    isExported: true;
+};
+export declare const NETWORKDAYS_INTL: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, startDate: Maybe<CellValue>, endDate: Maybe<CellValue>, weekend: Maybe<CellValue>, holidays: ArgValue) => number;
+    isExported: true;
+};
+export declare const NOW: {
+    description: string;
+    args: never[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: () => number;
+    isExported: true;
+};
+export declare const SECOND: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const TIME: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, hour: Maybe<CellValue>, minute: Maybe<CellValue>, second: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const TIMEVALUE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, timeString: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const TODAY: {
+    description: string;
+    args: never[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: () => number;
+    isExported: true;
+};
+export declare const WEEKDAY: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>, type?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const WEEKNUM: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>, type?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const WORKDAY: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, startDate: Maybe<CellValue>, numDays: Maybe<CellValue>, holidays?: ArgValue | undefined) => number;
+    isExported: true;
+};
+export declare const WORKDAY_INTL: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, startDate: Maybe<CellValue>, numDays: Maybe<CellValue>, weekend: Maybe<CellValue>, holidays: ArgValue) => number;
+    isExported: true;
+};
+export declare const YEAR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const YEARFRAC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, startDate: Maybe<CellValue>, endDate: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+};
+export declare const MONTH_START: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+};
+export declare const MONTH_END: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+};
+export declare const QUARTER: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+};
+export declare const QUARTER_START: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+};
+export declare const QUARTER_END: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+};
+export declare const YEAR_START: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+};
+export declare const YEAR_END: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["DATE"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, date: Maybe<CellValue>) => number;
+};

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

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

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

@@ -0,0 +1,17 @@
+import { AddFunctionDescription, Arg, Matrix, Maybe, ValueAndFormat } from "../types";
+export declare const FILTER: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<ANY>"];
+    computeValueAndFormat: (range: Arg, ...conditions: Arg[]) => Matrix<ValueAndFormat>;
+    isExported: false;
+};
+export declare const SORT: AddFunctionDescription;
+export declare const SORTN: AddFunctionDescription;
+export declare const UNIQUE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<NUMBER>"];
+    computeValueAndFormat: (range: Arg, byColumn: Maybe<ValueAndFormat>, exactlyOnce: Maybe<ValueAndFormat>) => Matrix<ValueAndFormat>;
+    isExported: true;
+};