@odoo/o-spreadsheet 18.0.55 → 18.0.67

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

@@ -0,0 +1,25 @@
+import { Locale } from "../types";
+/**
+ * Tokenizer
+ *
+ * A tokenizer is a piece of code whose job is to transform a string into a list
+ * of "tokens". For example, "(12+" is converted into:
+ *   [{type: "LEFT_PAREN", value: "("},
+ *    {type: "NUMBER", value: "12"},
+ *    {type: "OPERATOR", value: "+"}]
+ *
+ * As the example shows, a tokenizer does not care about the meaning behind those
+ * tokens. It only cares about the structure.
+ *
+ * The tokenizer is usually the first step in a compilation pipeline.  Also, it
+ * is useful for the composer, which needs to be able to work with incomplete
+ * formulas.
+ */
+export declare const POSTFIX_UNARY_OPERATORS: string[];
+type TokenType = "OPERATOR" | "NUMBER" | "STRING" | "SYMBOL" | "SPACE" | "DEBUGGER" | "ARG_SEPARATOR" | "LEFT_PAREN" | "RIGHT_PAREN" | "REFERENCE" | "INVALID_REFERENCE" | "UNKNOWN";
+export interface Token {
+    readonly type: TokenType;
+    readonly value: string;
+}
+export declare function tokenize(str: string, locale?: Locale): Token[];
+export {};

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

@@ -0,0 +1,10 @@
+import { AddFunctionDescription, ArgDefinition, FunctionDescription } from "../types";
+export declare function arg(definition: string, description?: string): ArgDefinition;
+/**
+ * This function adds on description more general information derived from the
+ * arguments.
+ *
+ * This information is useful during compilation.
+ */
+export declare function addMetaInfoFromArg(addDescr: AddFunctionDescription): FunctionDescription;
+export declare function validateArguments(args: ArgDefinition[]): void;

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

@@ -0,0 +1,6 @@
+import { Arg, FunctionResultNumber, FunctionResultObject, Matrix } from "../types";
+export declare function assertSingleColOrRow(errorStr: string, arg: Matrix): void;
+export declare function assertSameDimensions(errorStr: string, ...args: Arg[]): void;
+export declare function assertPositive(errorStr: string, arg: number): void;
+export declare function assertSquareMatrix(errorStr: string, arg: Matrix): void;
+export declare function isNumberMatrix(arg: Matrix<FunctionResultObject>): arg is Matrix<FunctionResultNumber>;

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

@@ -0,0 +1,51 @@
+import { Locale } from "../types";
+/** Assert maturity date > settlement date */
+export declare function assertMaturityAndSettlementDatesAreValid(settlement: number, maturity: number): void;
+/** Assert settlement date > issue date */
+export declare function assertSettlementAndIssueDatesAreValid(settlement: number, issue: number): void;
+/** Assert coupon frequency is in [1, 2, 4] */
+export declare function assertCouponFrequencyIsValid(frequency: number): void;
+/** Assert dayCountConvention is between 0 and 4 */
+export declare function assertDayCountConventionIsValid(dayCountConvention: number): void;
+export declare function assertRedemptionStrictlyPositive(redemption: number): void;
+export declare function assertPriceStrictlyPositive(price: number): void;
+export declare function assertNumberOfPeriodsStrictlyPositive(nPeriods: number): void;
+export declare function assertRateStrictlyPositive(rate: number): void;
+export declare function assertLifeStrictlyPositive(life: number): void;
+export declare function assertCostStrictlyPositive(cost: number): void;
+export declare function assertPurchaseDatePositiveOrZero(purchaseDate: number): void;
+export declare function assertIssuePositiveOrZero(issue: number): void;
+export declare function assertCostPositiveOrZero(cost: number): void;
+export declare function assertPeriodStrictlyPositive(period: number): void;
+export declare function assertPeriodPositiveOrZero(period: number): void;
+export declare function assertSalvagePositiveOrZero(salvage: number): void;
+export declare function assertSalvageSmallerOrEqualThanCost(salvage: number, cost: number): void;
+export declare function assertPresentValueStrictlyPositive(pv: number): void;
+export declare function assertPeriodSmallerOrEqualToLife(period: number, life: number): void;
+export declare function assertInvestmentStrictlyPositive(investment: number): void;
+export declare function assertDiscountStrictlyPositive(discount: number): void;
+export declare function assertDiscountStrictlySmallerThanOne(discount: number): void;
+export declare function assertDeprecationFactorStrictlyPositive(factor: number): void;
+export declare function assertSettlementLessThanOneYearBeforeMaturity(settlement: number, maturity: number, locale: Locale): void;
+/**
+ * Check if the given periods are valid. This will assert :
+ *
+ * - 0 < numberOfPeriods
+ * - 0 < firstPeriod <= lastPeriod
+ * - 0 < lastPeriod <= numberOfPeriods
+ *
+ */
+export declare function assertFirstAndLastPeriodsAreValid(firstPeriod: number, lastPeriod: number, numberOfPeriods: number): void;
+/**
+ * Check if the given periods are valid. This will assert :
+ *
+ * - 0 < life
+ * - 0 <= startPeriod <= endPeriod
+ * - 0 <= endPeriod <= life
+ *
+ */
+export declare function assertStartAndEndPeriodAreValid(startPeriod: number, endPeriod: number, life: number): void;
+export declare function assertRateGuessStrictlyGreaterThanMinusOne(guess: number): void;
+export declare function assertCashFlowsAndDatesHaveSameDimension(cashFlows: any[][], dates: any[][]): void;
+export declare function assertCashFlowsHavePositiveAndNegativesValues(cashFlow: number[]): void;
+export declare function assertEveryDateGreaterThanFirstDateOfCashFlowDates(dates: number[]): void;

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

@@ -0,0 +1,9 @@
+import { Arg } from "../types";
+export declare function boolAnd(args: Arg[]): {
+    foundBoolean: boolean;
+    result: boolean;
+};
+export declare function boolOr(args: Arg[]): {
+    foundBoolean: boolean;
+    result: boolean;
+};

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

@@ -0,0 +1,9 @@
+import { EvalContext, FunctionResultObject, Getters, Maybe, UID } from "../types";
+import { PivotCoreMeasure } from "../types/pivot";
+/**
+ * Get the pivot ID from the formula pivot ID.
+ */
+export declare function getPivotId(pivotFormulaId: string, getters: Getters): UID;
+export declare function assertMeasureExist(pivotId: UID, measure: string, getters: Getters): void;
+export declare function assertDomainLength(domain: Maybe<FunctionResultObject>[]): void;
+export declare function addPivotDependencies(evalContext: EvalContext, pivotId: UID, forMeasures: PivotCoreMeasure[]): void;

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

@@ -0,0 +1,3 @@
+import { Arg, Locale } from "../types";
+export declare function sum(values: Arg[], locale: Locale): number;
+export declare function countUnique(args: Arg[]): number;

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

@@ -0,0 +1,24 @@
+import { Matrix } from "../types";
+export declare function getUnitMatrix(n: number): Matrix<number>;
+/**
+ * Invert a matrix and compute its determinant using Gaussian Elimination.
+ *
+ * The Matrix should be a square matrix, and should be indexed [col][row] instead of the
+ * standard mathematical indexing [row][col].
+ */
+export declare function invertMatrix(M: Matrix<number>): {
+    inverted?: Matrix<number>;
+    determinant: number;
+};
+/**
+ * Matrix multiplication of 2 matrices.
+ * ex: matrix1 : n x l, matrix2 : m x n => result : m x l
+ *
+ * Note: we use indexing [col][row] instead of the standard mathematical notation [row][col]
+ */
+export declare function multiplyMatrices(matrix1: Matrix<number>, matrix2: Matrix<number>): Matrix<number>;
+/**
+ * Return the input if it's a scalar or the first element of the input if it's a matrix.
+ */
+export declare function toScalar<T>(arg: Matrix<T> | T): T;
+export declare function isMultipleElementMatrix(arg: any): boolean;

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

@@ -0,0 +1,95 @@
+type UnitTransformation = {
+    transform: (number: any) => number;
+    inverseTransform: (number: any) => number;
+};
+type Unit = UnitTransformation & {
+    category: string;
+    factor: number;
+    order?: number;
+};
+export declare const UNITS_ALIASES: {
+    shweight: string;
+    lcwt: string;
+    hweight: string;
+    LTON: string;
+    brton: string;
+    pc: string;
+    Pica: string;
+    d: string;
+    mn: string;
+    s: string;
+    p: string;
+    at: string;
+    dy: string;
+    ev: string;
+    hh: string;
+    wh: string;
+    btu: string;
+    h: string;
+    cel: string;
+    fah: string;
+    kel: string;
+    us_pt: string;
+    L: string;
+    lt: string;
+    ang3: string;
+    ft3: string;
+    in3: string;
+    ly3: string;
+    m3: string;
+    mi3: string;
+    yd3: string;
+    Nmi3: string;
+    Picapt3: string;
+    "Pica^3": string;
+    Pica3: string;
+    regton: string;
+    ang2: string;
+    ft2: string;
+    in2: string;
+    ly2: string;
+    m2: string;
+    mi2: string;
+    Nmi2: string;
+    Picapt2: string;
+    "Pica^2": string;
+    Pica2: string;
+    yd2: string;
+    "m/h": string;
+    "m/sec": string;
+};
+export declare const UNIT_PREFIXES: {
+    "": number;
+    Y: number;
+    Z: number;
+    E: number;
+    P: number;
+    T: number;
+    G: number;
+    M: number;
+    k: number;
+    h: number;
+    da: number;
+    e: number;
+    d: number;
+    c: number;
+    m: number;
+    u: number;
+    n: number;
+    p: number;
+    f: number;
+    a: number;
+    z: number;
+    y: number;
+    Yi: number;
+    Zi: number;
+    Ei: number;
+    Pi: number;
+    Ti: number;
+    Gi: number;
+    Mi: number;
+    ki: number;
+};
+export declare function getTranslatedCategory(key: string): string;
+export declare function getTransformation(key: string): Unit | undefined;
+export {};

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

@@ -0,0 +1,19 @@
+import { Arg, Locale, Matrix } from "../types";
+export declare function assertSameNumberOfElements(...args: any[][]): void;
+export declare function average(values: Arg[], locale: Locale): number;
+export declare function countNumbers(values: Arg[], locale: Locale): number;
+export declare function countAny(values: Arg[]): number;
+export declare function max(values: Arg[], locale: Locale): {
+    value: number;
+};
+export declare function min(values: Arg[], locale: Locale): {
+    value: number;
+};
+export declare function fullLinearRegression(X: Matrix<number>, Y: Matrix<number>, computeIntercept?: boolean, verbose?: boolean): (string | number)[][];
+export declare function polynomialRegression(flatY: number[], flatX: number[], order: number, intercept: boolean): Matrix<number>;
+export declare function evaluatePolynomial(coeffs: number[], x: number, order: number): number;
+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 assertNonEmptyMatrix(matrix: any[][], argName: string): void;
+export declare function assertNonEmpty(...data: any[][]): void;

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

@@ -0,0 +1,146 @@
+import { DateTime } from "../helpers/dates";
+import { Arg, CellValue, FunctionResultNumber, FunctionResultObject, Locale, Matrix, Maybe } from "../types";
+import { ErrorValue } from "../types/errors";
+import { LookupCaches } from "../types/functions";
+export declare function assert(condition: () => boolean, message: string, value?: string): void;
+export declare function inferFormat(data: Arg | undefined): string | undefined;
+export declare function isEvaluationError(error: Maybe<CellValue>): error is ErrorValue;
+export declare const expectNumberRangeError: (lowerBound: number, upperBound: number, value: number) => string;
+export declare const expectStringSetError: (stringSet: string[], value: string) => string;
+export declare function toNumber(data: FunctionResultObject | CellValue | undefined, locale: Locale): number;
+export declare function tryToNumber(value: string | number | boolean | null | undefined, locale: Locale): number | undefined;
+export declare function toNumberMatrix(data: Arg, argName: string): Matrix<number>;
+export declare function strictToNumber(data: FunctionResultObject | CellValue | undefined, locale: Locale): number;
+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 assertNumberGreaterThanOrEqualToOne(value: number): void;
+export declare function assertNotZero(value: number): void;
+export declare function toString(data: FunctionResultObject | CellValue | undefined): string;
+/**
+ * Normalize range by setting all the string in the range to lowercase and replacing
+ * accent letters with plain letters
+ */
+export declare function normalizeRange<T>(range: T[]): (string | T)[];
+export declare function toBoolean(data: FunctionResultObject | CellValue | undefined): boolean;
+export declare function toJsDate(data: FunctionResultObject | CellValue | undefined, locale: Locale): DateTime;
+export declare function visitAny(args: Arg[], cb: (a: Maybe<FunctionResultObject>) => void): void;
+export declare function visitNumbers(args: Arg[], cb: (arg: FunctionResultNumber) => void, locale: Locale): void;
+export declare function reduceAny<T, M>(args: (T | Matrix<T>)[], cb: (acc: M, a: T) => M, initialValue: M, dir?: "rowFirst" | "colFirst"): M;
+export declare function reduceNumbers(args: Arg[], cb: (acc: number, a: number) => number, initialValue: number, locale: Locale): number;
+export declare function reduceNumbersTextAs0(args: Arg[], cb: (acc: number, a: number) => number, initialValue: number, locale: Locale): number;
+/**
+ * Generate a matrix of size nColumns x nRows and apply a callback on each position
+ */
+export declare function generateMatrix<T>(nColumns: number, nRows: number, callback: (col: number, row: number) => T): Matrix<T>;
+export declare function matrixMap<T, M>(matrix: Matrix<T>, callback: (value: T) => M): Matrix<M>;
+export declare function matrixForEach<T>(matrix: Matrix<T>, fn: (value: T) => void): void;
+export declare function transposeMatrix<T>(matrix: Matrix<T>): Matrix<T>;
+/**
+ * Enables a formula function to accept matrix or vector inputs instead of simple value, computing results across multiple dimensions.
+ *
+ * ```
+ *                    /         |‾                 ‾| \        |‾                                                    ‾|
+ *                   |          | [A]               |  |       | compute(A, D, E), compute(A, D, F), compute(A, D, G) |
+ * applyVectorization| compute, | [B], D, [E, F, G] |  |  <=>  | compute(B, D, E), compute(B, D, F), compute(B, D, G) |
+ *                   |          | [C]               |  |       | compute(C, D, E), compute(C, D, F), compute(C, D, G) |
+ *                    \         |_                 _| /        |_                                                    _|
+ * ```
+ *
+ * By default, all arguments are vectorized. To control which arguments are vectorized,
+ * pass an `acceptToVectorize` boolean array of the same length as `args`:
+ * - `true`  enables vectorization for that argument
+ * - `false` disables vectorization for that argument
+ *
+ * For example, with `[true, true, false]` on previous example you get:
+ *
+ * ```
+ * |‾                        ‾|
+ * | compute(A, D, [E, F, G]) |
+ * | compute(B, D, [E, F, G]) |
+ * | compute(C, D, [E, F, G]) |
+ * |_                        _|
+ * ```
+ *
+ * @remarks
+ * This helper is automatically applied (by default) to **all** `compute` functions
+ * across the various spreadsheet formula modules:
+ * - If an argument is declared **scalar** (not `"range"`), it is vectorized.
+ * - If **all** arguments are declared **ranges**, no vectorization occurs.
+ *   - e.g. `SUM(A1:B2)` returns a 1×1 sum over the range.
+ *   - e.g. `COS(A1:B2)` over `A1:B2` returns a 2×2 element-wise result.
+ * - 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(formula: (...args: Arg[]) => Matrix<FunctionResultObject> | FunctionResultObject, args: Arg[], acceptToVectorize?: boolean[] | undefined): FunctionResultObject | Matrix<FunctionResultObject>;
+export declare function conditionalVisitBoolean(args: Arg[], cb: (a: boolean) => boolean): void;
+/**
+ * Functions used especially for predicate evaluation on ranges.
+ *
+ * Take ranges with same dimensions and take predicates, one for each range.
+ * For (i, j) coordinates, if all elements with coordinates (i, j) of each
+ * range correspond to the associated predicate, then the function uses a callback
+ * function with the parameters "i" and "j".
+ *
+ * Syntax:
+ * visitMatchingRanges([range1, predicate1, range2, predicate2, ...], cb(i,j), likeSelection)
+ *
+ * - range1 (range): The range to check against predicate1.
+ * - predicate1 (string): The pattern or test to apply to range1.
+ * - range2: (range, repeatable) ranges to check.
+ * - predicate2 (string, repeatable): Additional pattern or test to apply to range2.
+ *
+ * - cb(i: number, j: number) => void: the callback function.
+ *
+ * - isQuery (boolean) indicates if the comparison with a string should be done as a SQL-like query.
+ * (Ex1 isQuery = true, predicate = "abc", element = "abcde": predicate match the element),
+ * (Ex2 isQuery = false, predicate = "abc", element = "abcde": predicate not match the element).
+ * (Ex3 isQuery = true, predicate = "abc", element = "abc": predicate match the element),
+ * (Ex4 isQuery = false, predicate = "abc", element = "abc": predicate match the element).
+ */
+export declare function visitMatchingRanges(args: Arg[], cb: (i: number, j: number) => void, locale: Locale, isQuery?: boolean): void;
+/**
+ * Perform a dichotomic search on an array and return the index of the nearest match.
+ *
+ * The array should be sorted, if not an incorrect value might be returned. In the case where multiple
+ * element of the array match the target, the method will return the first match if the array is sorted
+ * in descending order, and the last match if the array is in ascending order.
+ *
+ *
+ * @param data the array in which to search.
+ * @param target the value to search.
+ * @param mode "nextGreater/nextSmaller" : return next greater/smaller value if no exact match is found.
+ * @param sortOrder whether the array is sorted in ascending or descending order.
+ * @param rangeLength the number of elements to consider in the search array.
+ * @param getValueInData function returning the element at index i in the search array.
+ */
+export declare function dichotomicSearch<T>(data: T, target: Maybe<FunctionResultObject>, mode: "nextGreater" | "nextSmaller" | "strict", sortOrder: "asc" | "desc", rangeLength: number, getValueInData: (range: T, index: number) => CellValue | undefined): number;
+export type LinearSearchMode = "nextSmaller" | "nextGreater" | "strict" | "wildcard";
+/**
+ * Perform a linear search and return the index of the match.
+ * -1 is returned if no value is found.
+ *
+ * Example:
+ * - [3, 6, 10], 3 => 0
+ * - [3, 6, 10], 6 => 1
+ * - [3, 6, 10], 9 => -1
+ * - [3, 6, 10], 2 => -1
+ *
+ * @param data the array to search in.
+ * @param target the value to search in the array.
+ * @param mode if "strict" return exact match index. "nextGreater" returns the next greater
+ * element from the target and "nextSmaller" the next smaller
+ * @param numberOfValues the number of elements to consider in the search array.
+ * @param getValueInData function returning the element at index i in the search array.
+ * @param reverseSearch if true, search in the array starting from the end.
+
+ */
+export declare function linearSearch<T>(data: T, target: Maybe<FunctionResultObject> | undefined, mode: LinearSearchMode, numberOfValues: number, getValueInData: (data: T, index: number) => CellValue | undefined, lookupCaches?: LookupCaches, reverseSearch?: boolean): number;
+export declare function toMatrix<T>(data: T | Matrix<T> | undefined): Matrix<T>;
+/**
+ * Flatten an array of items, where each item can be a single value or a 2D array, and apply the
+ * callback to each element.
+ *
+ * The 2D array are flattened row first.
+ */
+export declare function flattenRowFirst<T, K>(items: Array<T | Matrix<T>>, callback: (val: T) => K): K[];
+export declare function isDataNonEmpty(data: FunctionResultObject | undefined): boolean;

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

@@ -0,0 +1,18 @@
+import { Registry } from "../registries/registry";
+import { AddFunctionDescription, ComputeFunction, FunctionDescription, FunctionResultObject, Matrix } from "../types";
+export { arg } from "./arguments";
+export interface FunctionRegistry extends Registry<FunctionDescription> {
+    add(functionName: string, addDescr: AddFunctionDescription): FunctionRegistry;
+    get(functionName: string): FunctionDescription;
+    mapping: {
+        [functionName: string]: ComputeFunction<Matrix<FunctionResultObject> | FunctionResultObject>;
+    };
+}
+export declare class FunctionRegistry extends Registry<FunctionDescription> {
+    mapping: {
+        [key: string]: ComputeFunction<Matrix<FunctionResultObject> | FunctionResultObject>;
+    };
+}
+export declare const functionRegistry: FunctionRegistry;
+export declare function handleError(e: unknown, functionName: string): FunctionResultObject;
+export declare const implementationErrorMessage: string;

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

@@ -0,0 +1,122 @@
+import { Arg, FunctionResultObject, Matrix, Maybe } from "../types";
+import { EvaluationError, NotAvailableError } from "../types/errors";
+export declare const ARRAY_CONSTRAIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, array: Arg, rows: Maybe<FunctionResultObject>, columns: Maybe<FunctionResultObject>) => Matrix<FunctionResultObject>;
+    isExported: false;
+};
+export declare const CHOOSECOLS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, array: Arg, ...columns: Arg[]) => Matrix<FunctionResultObject>;
+    isExported: true;
+};
+export declare const CHOOSEROWS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, array: Arg, ...rows: Arg[]) => 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>) => Matrix<FunctionResultObject>;
+    isExported: true;
+};
+export declare const FLATTEN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...ranges: Arg[]) => Matrix<FunctionResultObject>;
+    isExported: false;
+};
+export declare const FREQUENCY: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (data: Matrix<FunctionResultObject>, classes: Matrix<FunctionResultObject>) => Matrix<number>;
+    isExported: true;
+};
+export declare const HSTACK: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...ranges: Arg[]) => Matrix<FunctionResultObject>;
+    isExported: true;
+};
+export declare const MDETERM: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (matrix: Arg) => number;
+    isExported: true;
+};
+export declare const MINVERSE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (matrix: Arg) => EvaluationError | Matrix<number>;
+    isExported: true;
+};
+export declare const MMULT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (matrix1: Arg, matrix2: Arg) => Matrix<number>;
+    isExported: true;
+};
+export declare const SUMPRODUCT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const SUMX2MY2: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (arrayX: Arg, arrayY: Arg) => number;
+    isExported: true;
+};
+export declare const SUMX2PY2: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (arrayX: Arg, arrayY: Arg) => number;
+    isExported: true;
+};
+export declare const SUMXMY2: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (arrayX: Arg, arrayY: Arg) => 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[][];
+    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[][];
+    isExported: true;
+};
+export declare const TRANSPOSE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (arg: Arg) => Matrix<FunctionResultObject>;
+    isExported: true;
+};
+export declare const VSTACK: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...ranges: Arg[]) => 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>) => 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>) => Matrix<FunctionResultObject>;
+    isExported: true;
+};

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

@@ -0,0 +1,6 @@
+import { FunctionResultNumber, FunctionResultObject, Maybe } from "../types";
+export declare const FORMAT_LARGE_NUMBER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, unite: Maybe<FunctionResultObject>) => FunctionResultNumber;
+};

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

@@ -0,0 +1,73 @@
+import { FunctionResultNumber, FunctionResultObject, Matrix, Maybe } from "../types";
+export declare const DAVERAGE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const DCOUNT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => 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;
+    isExported: true;
+};
+export declare const DGET: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => FunctionResultObject;
+    isExported: true;
+};
+export declare const DMAX: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const DMIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const DPRODUCT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => FunctionResultObject;
+    isExported: true;
+};
+export declare const DSTDEV: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => 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;
+    isExported: true;
+};
+export declare const DSUM: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const DVAR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => 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;
+    isExported: true;
+};