@odoo/o-spreadsheet 18.0.55 → 18.0.67

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

@@ -0,0 +1,211 @@
+import { ConsecutiveIndexes, Lazy, UID } from "../types";
+import { SearchOptions } from "../types/find_and_replace";
+import { DebouncedFunction } from "./../types/misc";
+/**
+ * Remove quotes from a quoted string
+ * ```js
+ * removeStringQuotes('"Hello"')
+ * > 'Hello'
+ * ```
+ */
+export declare function removeStringQuotes(str: string): string;
+/**
+ * Escapes a string to use as a literal string in a RegExp.
+ * @url https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
+ */
+export declare function escapeRegExp(str: string): string;
+/**
+ * Deep copy arrays, plain objects and primitive values.
+ * Throws an error for other types such as class instances.
+ * Sparse arrays remain sparse.
+ */
+export declare function deepCopy<T>(obj: T): T;
+/**
+ * Sanitize the name of a sheet, by eventually removing quotes
+ * @param sheetName name of the sheet, potentially quoted with single quotes
+ */
+export declare function getUnquotedSheetName(sheetName: string): string;
+export declare function unquote(string: string, quoteChar?: "'" | '"'): string;
+/**
+ * Add quotes around the sheet name or any symbol name if it contains at least one non alphanumeric character
+ * '\w' captures [0-9][a-z][A-Z] and _.
+ * @param symbolName Name of the sheet or symbol
+ */
+export declare function getCanonicalSymbolName(symbolName: string): string;
+/** Replace the excel-excluded characters of a sheetName */
+export declare function sanitizeSheetName(sheetName: string, replacementChar?: string): string;
+export declare function clip(val: number, min: number, max: number): number;
+/**
+ * Create a range from start (included) to end (excluded).
+ * range(10, 13) => [10, 11, 12]
+ * range(2, 8, 2) => [2, 4, 6]
+ */
+export declare function range(start: number, end: number, step?: number): number[];
+/**
+ * Groups consecutive numbers.
+ * The input array is assumed to be sorted
+ * @param numbers
+ */
+export declare function groupConsecutive(numbers: number[]): ConsecutiveIndexes[];
+/**
+ * Create one generator from two generators by linking
+ * each item of the first generator to the next item of
+ * the second generator.
+ *
+ * Let's say generator G1 yields A, B, C and generator G2 yields X, Y, Z.
+ * The resulting generator of `linkNext(G1, G2)` will yield A', B', C'
+ * where `A' = A & {next: Y}`, `B' = B & {next: Z}` and `C' = C & {next: undefined}`
+ * @param generator
+ * @param nextGenerator
+ */
+export declare function linkNext<T>(generator: Generator<T>, nextGenerator: Generator<T>): Generator<T & {
+    next?: T;
+}>;
+export declare function isBoolean(str: string): boolean;
+export declare function isMarkdownLink(str: string): boolean;
+/**
+ * Check if the string is a web link.
+ * e.g. http://odoo.com
+ */
+export declare function isWebLink(str: string): boolean;
+/**
+ * Build a markdown link from a label and an url
+ */
+export declare function markdownLink(label: string, url: string): string;
+export declare function parseMarkdownLink(str: string): {
+    url: string;
+    label: string;
+};
+export declare function isSheetUrl(url: string): boolean;
+export declare function buildSheetLink(sheetId: UID): string;
+/**
+ * Parse a sheet link and return the sheet id
+ */
+export declare function parseSheetUrl(sheetLink: string): string;
+/**
+ * This helper function can be used as a type guard when filtering arrays.
+ * const foo: number[] = [1, 2, undefined, 4].filter(isDefined)
+ */
+export declare function isDefined<T>(argument: T | undefined): argument is T;
+export declare function isNotNull<T>(argument: T | null): argument is T;
+/**
+ * Check if all the values of an object, and all the values of the objects inside of it, are undefined.
+ */
+export declare function isObjectEmptyRecursive<T extends object>(argument: T | undefined): boolean;
+/**
+ * Returns a function, that, as long as it continues to be invoked, will not
+ * be triggered. The function will be called after it stops being called for
+ * N milliseconds. If `immediate` is passed, trigger the function on the
+ * leading edge, instead of the trailing.
+ *
+ * Also decorate the argument function with two methods: stopDebounce and isDebouncePending.
+ *
+ * Inspired by https://davidwalsh.name/javascript-debounce-function
+ */
+export declare function debounce<T extends (...args: any) => void>(func: T, wait: number, immediate?: boolean): DebouncedFunction<T>;
+/**
+ * Creates a batched version of a callback so that all calls to it in the same
+ * microtick will only call the original callback once.
+ *
+ * @param callback the callback to batch
+ * @returns a batched version of the original callback
+ *
+ * Copied from odoo/owl repo.
+ */
+export declare function batched(callback: () => void): () => void;
+export declare function concat(chars: string[]): string;
+/**
+ * Lazy value computed by the provided function.
+ */
+export declare function lazy<T>(fn: (() => T) | T): Lazy<T>;
+/**
+ * Find the next defined value after the given index in an array of strings. If there is no defined value
+ * after the index, return the closest defined value before the index. Return an empty string if no
+ * defined value was found.
+ *
+ */
+export declare function findNextDefinedValue(arr: string[], index: number): string;
+/** Get index of first header added by an ADD_COLUMNS_ROWS command */
+export declare function getAddHeaderStartIndex(position: "before" | "after", base: number): number;
+/**
+ * Compares two objects.
+ */
+export declare function deepEquals(o1: any, o2: any): boolean;
+/**
+ * Compares two arrays.
+ * For performance reasons, this function is to be preferred
+ * to 'deepEquals' in the case we know that the inputs are arrays.
+ */
+export declare function deepEqualsArray(arr1: unknown[], arr2: unknown[]): boolean;
+/**
+ * Check if the given array contains all the values of the other array.
+ * It makes the assumption that both array do not contain duplicates.
+ */
+export declare function includesAll<T>(arr: T[], values: T[]): boolean;
+/**
+ * Return an object with all the keys in the object that have a falsy value removed.
+ */
+export declare function removeFalsyAttributes<T extends Object | undefined | null>(obj: T): T;
+export declare const specialWhiteSpaceRegexp: RegExp;
+export declare const whiteSpaceCharacters: string[];
+/**
+ * Replace all different newlines characters by \n
+ */
+export declare function replaceNewLines(text: string | undefined): string;
+/**
+ * Determine if the numbers are consecutive.
+ */
+export declare function isConsecutive(iterable: Iterable<number>): boolean;
+/**
+ * Creates a version of the function that's memoized on the value of its first
+ * argument, if any.
+ */
+export declare function memoize<T extends any[], U>(func: (...args: T) => U): (...args: T) => U;
+/**
+ * Removes the specified indexes from the array.
+ * Sparse (empty) elements are transformed to undefined (unless their index is explicitly removed).
+ */
+export declare function removeIndexesFromArray<T>(array: readonly T[], indexes: number[]): T[];
+export declare function insertItemsAtIndex<T>(array: readonly T[], items: T[], index: number): T[];
+export declare function replaceItemAtIndex<T>(array: readonly T[], newItem: T, index: number): T[];
+export declare function trimContent(content: string): string;
+export declare function isNumberBetween(value: number, min: number, max: number): boolean;
+/**
+ * Get a Regex for the find & replace that matches the given search string and options.
+ */
+export declare function getSearchRegex(searchStr: string, searchOptions: SearchOptions): RegExp;
+/**
+ * Alternative to Math.max that works with large arrays.
+ * Typically useful for arrays bigger than 100k elements.
+ */
+export declare function largeMax(array: number[]): number;
+/**
+ * Alternative to Math.min that works with large arrays.
+ * Typically useful for arrays bigger than 100k elements.
+ */
+export declare function largeMin(array: number[]): number;
+export declare class TokenizingChars {
+    private text;
+    private currentIndex;
+    current: string;
+    constructor(text: string);
+    shift(): string;
+    advanceBy(length: number): void;
+    isOver(): boolean;
+    remaining(): string;
+    currentStartsWith(str: string): boolean;
+}
+/**
+ * Remove duplicates from an array.
+ *
+ * @param array The array to remove duplicates from.
+ * @param cb A callback to get an element value.
+ */
+export declare function removeDuplicates<T>(array: T[], cb?: (a: T) => any): T[];
+/**
+ * Similar to transposing and array, but with POJOs instead of arrays. Useful, for example, when manipulating
+ * a POJO grid[col][row] and you want to transpose it to grid[row][col].
+ *
+ * The resulting object is created such as result[key1][key2] = pojo[key2][key1]
+ */
+export declare function transpose2dPOJO<T>(pojo: Record<string, Record<string, T>>): Record<string, Record<string, T>>;

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

@@ -0,0 +1,25 @@
+import { Locale } from "../types";
+/**
+ * This function returns a regexp that is supposed to be as close as possible as the numberRegexp,
+ * but its purpose is to be used by the tokenizer.
+ *
+ * - it tolerates extra characters at the end. This is useful because the tokenizer
+ *   only needs to find the number at the start of a string
+ * - it does not support % symbol, in formulas % is an operator
+ */
+export declare const getFormulaNumberRegex: (decimalSeparator: string) => RegExp;
+/**
+ * Return true if the argument is a "number string".
+ *
+ * Note that "" (empty string) does not count as a number string
+ */
+export declare function isNumber(value: string | undefined, locale: Locale): boolean;
+/**
+ * Convert a string into a number. It assumes that the string actually represents
+ * a number (as determined by the isNumber function)
+ *
+ * Note that it accepts "" (empty string), even though it does not count as a
+ * number from the point of view of the isNumber function.
+ */
+export declare function parseNumber(str: string, locale: Locale): number;
+export declare function percentile(values: number[], percent: number, isInclusive: boolean): number;

package/dist/types/helpers/pivot/pivot_composer_helpers.d.ts

@@ -0,0 +1,61 @@
+import { CellComposerStore } from "../../components/composer/composer/cell_composer_store";
+import { Token } from "../../formulas";
+import { EnrichedToken } from "../../formulas/composer_tokenizer";
+import { Granularity, PivotField, PivotMeasure } from "../../types";
+/**
+ * Create a proposal entry for the compose autowcomplete
+ * to insert a field name string in a formula.
+ */
+export declare function makeFieldProposal(field: PivotField, granularity?: Granularity): {
+    text: string;
+    description: string;
+    htmlContent: {
+        value: string;
+        color: "#00a82d";
+    }[];
+    fuzzySearchKey: string;
+};
+export declare function makeMeasureProposal(measure: PivotMeasure): {
+    text: string;
+    description: string;
+    htmlContent: {
+        value: string;
+        color: "#00a82d";
+    }[];
+    fuzzySearchKey: string;
+};
+/**
+ * Perform the autocomplete of the composer by inserting the value
+ * at the cursor position, replacing the current token if necessary.
+ * Must be bound to the autocomplete provider.
+ */
+export declare function insertTokenAfterArgSeparator(this: {
+    composer: CellComposerStore;
+}, tokenAtCursor: EnrichedToken, value: string): void;
+/**
+ * Perform the autocomplete of the composer by inserting the value
+ * at the cursor position, replacing the current token if necessary.
+ * Must be bound to the autocomplete provider.
+ * @param {EnrichedToken} tokenAtCursor
+ * @param {string} value
+ */
+export declare function insertTokenAfterLeftParenthesis(this: {
+    composer: CellComposerStore;
+}, tokenAtCursor: EnrichedToken, value: string): void;
+/**
+ * Extract the pivot id (always the first argument) from the function
+ * context of the given token.
+ */
+export declare function extractFormulaIdFromToken(tokenAtCursor: EnrichedToken): any;
+/**
+ * Get the first Pivot function description of the given formula.
+ */
+export declare function getFirstPivotFunction(tokens: Token[]): {
+    functionName: string;
+    args: import("../..").AST[];
+};
+/**
+ * Parse a spreadsheet formula and detect the number of PIVOT functions that are
+ * present in the given formula.
+ */
+export declare function getNumberOfPivotFunctions(tokens: Token[]): number;

package/dist/types/helpers/pivot/pivot_domain_helpers.d.ts

@@ -0,0 +1,68 @@
+import { CellValue, Pivot, PivotColRowDomain, PivotDomain, PivotNode } from "../../types";
+export declare const PREVIOUS_VALUE = "(previous)";
+export declare const NEXT_VALUE = "(next)";
+export declare function getDomainOfParentRow(pivot: Pivot, domain: PivotDomain): PivotDomain;
+export declare function getDomainOfParentCol(pivot: Pivot, domain: PivotDomain): PivotDomain;
+/**
+ * Split a pivot domain into the part related to the rows of the pivot, and the part related to the columns.
+ */
+export declare function domainToColRowDomain(pivot: Pivot, domain: PivotDomain): PivotColRowDomain;
+export declare function getDimensionDomain(pivot: Pivot, dimension: "column" | "row", domain: PivotDomain): PivotDomain;
+export declare function isDomainIsInPivot(pivot: Pivot, domain: PivotDomain): boolean;
+/**
+ * Get the domain parent of the given domain with the field `parentFieldName` as leaf of the domain.
+ *
+ * In practice, if the `parentFieldName` is a row in the pivot, the helper will return a domain with the same column
+ * domain, and with a row domain all groupBys children to `parentFieldName` removed.
+ */
+export declare function getFieldParentDomain(pivot: Pivot, parentFieldName: string, domain: PivotDomain): PivotDomain;
+/**
+ * Replace in the domain the value of the field `fieldNameWithGranularity` with the given `value`
+ */
+export declare function replaceFieldValueInDomain(domain: PivotDomain, fieldNameWithGranularity: string, value: CellValue): PivotDomain;
+export declare function isFieldInDomain(nameWithGranularity: string, domain: PivotDomain): boolean;
+/**
+ * Check if the field is in the rows or columns of the pivot
+ */
+export declare function getFieldDimensionType(pivot: Pivot, nameWithGranularity: string): "row" | "column";
+/**
+ * Replace in the given domain the value of the field `fieldNameWithGranularity` with the previous or next value.
+ */
+export declare function getPreviousOrNextValueDomain(pivot: Pivot, domain: PivotDomain, fieldNameWithGranularity: string, direction: typeof PREVIOUS_VALUE | typeof NEXT_VALUE): PivotDomain | undefined;
+export declare function domainToString(domain: PivotDomain | undefined): string;
+export declare function domainNodeToString(domainNode: PivotNode | undefined): string;
+/**
+ *
+ * For the ranking, the pivot cell values of a column (or row) at the same depth are grouped together before being sorted
+ * and ranked.
+ *
+ * The grouping of a pivot cell is done with both the value of the domain nodes that are parent of the field
+ * `fieldNameWithGranularity` and the value of the last node of the domain of the pivot cell, if it's not the field
+ * `fieldNameWithGranularity`.
+ *
+ * For example, let's take a pivot grouped by (Date:year, Stage, User, Product), where we want to rank by "Stage" field.
+ * The domain nodes parents of the "Stage" are [Date:year]. The pivot cell with domain:
+ * - [Date:year=2021] is not ranked because it does not contain the "Stage" field
+ * - [Date:year=2021, Stage=Lead] is grouped with the cells [Date:year=2021, Stage=*, User=None, Product=None],
+ *      and then ranked within the group
+ * - [Date:year=2021, Stage=Lead, User=Bob] is grouped with the cells [Date:year=2021, Stage=*, User=Bob, Product=None],
+ *      and then ranked within the group
+ * - [Date:year=2021, Stage=Lead, User=Bob, Product=Table] is grouped with the cells [Date:year=2021, Stage=*, User=*, Product=Table],
+ *      and then ranked within the group
+ *
+ * If we rank the pivot on "User" instead, the parent domain becomes [Date:year, Sage] .The cell with domain:
+ * - [Date:year=2021] is not ranked because it does not contain the "Stage" field
+ * - [Date:year=2021, Stage=Lead] is not ranked because it does not contain the "User" field
+ * - [Date:year=2021, Stage=Lead, User=Bob] is grouped with the cells [Date:year=2021, Stage=Lead, User=Bob, Product=None],
+ *      and then ranked within the group
+ * - [Date:year=2021, Stage=Lead, User=Bob, Product=Table] is grouped with the cells with [Date:year=2021, Stage=Lead, User=*, Product=Table],
+ *     and then ranked within the group
+ *
+ */
+export declare function getRankingDomainKey(domain: PivotDomain, fieldNameWithGranularity: string): string;
+/**
+ * The running total domain is the domain without the field `fieldNameWithGranularity`, ie. we do the running total of
+ * all the pivot cells of the column that have any value for the field `fieldNameWithGranularity` and the same value for
+ * the other fields.
+ */
+export declare function getRunningTotalDomainKey(domain: PivotDomain, fieldNameWithGranularity: string): string;

package/dist/types/helpers/pivot/pivot_helpers.d.ts

@@ -0,0 +1,55 @@
+import { Registry } from "../../registries/registry";
+import { CellValue, FunctionResultObject, Locale, Matrix, Maybe, Pivot } from "../../types";
+import { Granularity, PivotCoreDimension, PivotDimension, PivotDomain, PivotField, PivotTableCell } from "../../types/pivot";
+import { PivotRuntimeDefinition } from "./pivot_runtime_definition";
+export declare const AGGREGATORS: {};
+type AggregatorFN = (args: Matrix<FunctionResultObject>, locale?: Locale) => FunctionResultObject;
+export declare const AGGREGATORS_FN: Record<string, AggregatorFN | undefined>;
+/**
+ * Given an object of form {"1": {...}, "2": {...}, ...} get the maximum ID used
+ * in this object
+ * If the object has no keys, return 0
+ *
+ */
+export declare function getMaxObjectId(o: object): number;
+export declare const ALL_PERIODS: {
+    year: string;
+    quarter: string;
+    month: string;
+    week: string;
+    day: string;
+    quarter_number: string;
+    month_number: string;
+    iso_week_number: string;
+    day_of_month: string;
+    day_of_week: string;
+    hour_number: string;
+    minute_number: string;
+    second_number: string;
+};
+/**
+ * Parse a dimension string into a pivot dimension definition.
+ * e.g "create_date:month" => { name: "create_date", granularity: "month" }
+ */
+export declare function parseDimension(dimension: string): PivotCoreDimension;
+export declare function isDateOrDatetimeField(field: PivotField): boolean;
+export declare function generatePivotArgs(formulaId: string, domain: PivotDomain, measure?: string): string[];
+/**
+ * Check if the fields in the domain part of
+ * a pivot function are valid according to the pivot definition.
+ * e.g. =PIVOT.VALUE(1,"revenue","country_id",...,"create_date:month",...,"source_id",...)
+ */
+export declare function areDomainArgsFieldsValid(dimensions: string[], definition: PivotRuntimeDefinition): boolean;
+export declare function createPivotFormula(formulaId: string, cell: PivotTableCell): string;
+/**
+ * Parses the value defining a pivot group in a PIVOT formula
+ * e.g. given the following formula PIVOT.VALUE("1", "stage_id", "42", "status", "won"),
+ * the two group values are "42" and "won".
+ */
+export declare function toNormalizedPivotValue(dimension: Pick<PivotDimension, "type" | "displayName" | "granularity">, groupValue: Maybe<CellValue | FunctionResultObject>): CellValue;
+export declare function toFunctionPivotValue(value: CellValue, dimension: Pick<PivotDimension, "type" | "granularity">): string;
+export declare const pivotNormalizationValueRegistry: Registry<(value: string, granularity?: Granularity | string) => CellValue>;
+export declare const pivotToFunctionValueRegistry: Registry<(value: CellValue, granularity?: string) => string>;
+export declare function getFieldDisplayName(field: PivotDimension): string;
+export declare function addIndentAndAlignToPivotHeader(pivot: Pivot, domain: PivotDomain, functionResult: FunctionResultObject): FunctionResultObject;
+export {};

package/dist/types/helpers/pivot/pivot_highlight.d.ts

@@ -0,0 +1,2 @@
+import { Getters, Highlight, UID } from "../../types";
+export declare function getPivotHighlights(getters: Getters, pivotId: UID): Highlight[];

package/dist/types/helpers/pivot/pivot_menu_items.d.ts

@@ -0,0 +1,3 @@
+import { ActionSpec } from "../../actions/action";
+export declare const pivotProperties: ActionSpec;
+export declare const FIX_FORMULAS: ActionSpec;

package/dist/types/helpers/pivot/pivot_positional_formula_registry.d.ts

@@ -0,0 +1,7 @@
+import { Registry } from "../../registries/registry";
+/**
+ * Registry to enable or disable the support of positional arguments
+ * (with a leading #) in pivot functions
+ * e.g. =PIVOT.VALUE(1,"probability","#stage",1)
+ */
+export declare const supportedPivotPositionalFormulaRegistry: Registry<boolean>;

package/dist/types/helpers/pivot/pivot_presence_tracker.d.ts

@@ -0,0 +1,9 @@
+import { PivotDomain } from "../../types";
+export declare class PivotPresenceTracker {
+    private trackedValues;
+    private domainToArray;
+    isValuePresent(measure: string, domain: PivotDomain): boolean;
+    isHeaderPresent(domain: PivotDomain): boolean;
+    trackValue(measure: string, domain: PivotDomain): void;
+    trackHeader(domain: PivotDomain): void;
+}

package/dist/types/helpers/pivot/pivot_presentation.d.ts

@@ -0,0 +1,91 @@
+import { ModelConfig } from "../../model";
+import { CellValue, DimensionTree, FunctionResultObject, Getters, PivotDomain, PivotMeasure, PivotMeasureDisplay, PivotValueCell } from "../../types";
+import { UID } from "../../types/misc";
+import { NEXT_VALUE, PREVIOUS_VALUE } from "./pivot_domain_helpers";
+import { PivotParams, PivotUIConstructor } from "./pivot_registry";
+type CacheForMeasureAndField<T> = {
+    [measureId: string]: {
+        [field: string]: T;
+    };
+};
+type DomainGroups<T> = {
+    [colDomain: string]: {
+        [rowDomain: string]: T;
+    };
+};
+/**
+ * Dynamically creates a presentation layer wrapper around a given pivot class.
+ *
+ * It allows to implement additional behaviors and features that can be applied
+ * to all pivots, regardless of the specific pivot implementation.
+ * Examples of such features include calculated measures or "Show value as" options.
+ */
+export default function (PivotClass: PivotUIConstructor): {
+    new (pivotId: any, custom: ModelConfig["custom"], params: PivotParams): {
+        getters: Getters;
+        pivotId: UID;
+        cache: Record<string, FunctionResultObject>;
+        rankAsc: CacheForMeasureAndField<DomainGroups<number> | undefined>;
+        rankDesc: CacheForMeasureAndField<DomainGroups<number> | undefined>;
+        runningTotal: CacheForMeasureAndField<DomainGroups<number | undefined> | undefined>;
+        runningTotalInPercent: CacheForMeasureAndField<DomainGroups<number | undefined> | undefined>;
+        markAsDirtyForEvaluation(): void;
+        getPivotCellValueAndFormat(measureName: string, domain: PivotDomain): FunctionResultObject;
+        _getPivotCellValueAndFormat(measureName: string, domain: PivotDomain): FunctionResultObject;
+        computeMeasure(measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        getValuesToAggregate(measure: PivotMeasure, domain: PivotDomain): FunctionResultObject[];
+        getSubTreeMatchingDomain(tree: DimensionTree, domain: PivotDomain, domainLevel?: number): DimensionTree;
+        treeToLeafDomains(tree: DimensionTree, parentDomain?: PivotDomain): PivotDomain[];
+        getMeasureDisplayValue(measureId: string, domain: PivotDomain): FunctionResultObject;
+        asPercentOfGrandTotal(rawValue: FunctionResultObject, measure: PivotMeasure): FunctionResultObject;
+        asPercentOfRowTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        asPercentOfColumnTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        asPercentOfParentRowTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        asPercentOfParentColumnTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        asPercentOfParentTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay): FunctionResultObject;
+        asIndex(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        asRunningTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay, mode: "running_total" | "%_running_total"): FunctionResultObject;
+        asPercentOf(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay): FunctionResultObject;
+        asDifferenceFrom(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay): FunctionResultObject;
+        asDifferenceFromInPercent(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay): FunctionResultObject;
+        asRank(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay, order: "asc" | "desc"): FunctionResultObject;
+        computeRank(measure: PivotMeasure, fieldNameWithGranularity: string, order: "asc" | "desc"): DomainGroups<number>;
+        computeRunningTotal(measure: PivotMeasure, fieldNameWithGranularity: string, mode: "running_total" | "%_running_total"): DomainGroups<number | undefined>;
+        getGrandTotal(measureId: string): number;
+        getRowTotal(measureId: string, domain: PivotDomain): number;
+        getColumnTotal(measureId: string, domain: PivotDomain): number;
+        isFieldInPivot(nameWithGranularity: string): boolean;
+        /**
+         * With the given measure, fetch the value of the cell in the pivot that has the given domain with
+         * the value of the field `fieldNameWithGranularity` replaced by `valueToCompare`.
+         *
+         * @param valueToCompare either a value to replace the field value with, or "(previous)" or "(next)"
+         * @returns the value of the cell in the pivot with the new domain, or "sameValue" if the domain is the same
+         */
+        getComparisonValue(measure: PivotMeasure, domain: PivotDomain, fieldNameWithGranularity: string, valueToCompare: CellValue | typeof PREVIOUS_VALUE | typeof NEXT_VALUE): number | "sameValue" | undefined;
+        getPivotValueCells(measureId: string): PivotValueCell[][];
+        measureValueToNumber(result: FunctionResultObject): number;
+        strictMeasureValueToNumber(result: FunctionResultObject): number | undefined;
+        type: import("../..").PivotCoreDefinition["type"];
+        definition: import("./pivot_runtime_definition").PivotRuntimeDefinition;
+        init(params?: import("../..").InitPivotParams): void;
+        isValid(): boolean;
+        onDefinitionChange(nextDefinition: import("../..").PivotCoreDefinition): void;
+        getTableStructure(): import("./table_spreadsheet_pivot").SpreadsheetPivotTable;
+        getFields(): import("../..").PivotFields;
+        getPivotHeaderValueAndFormat(domain: PivotDomain): FunctionResultObject;
+        getPivotMeasureValue(measure: string, domain: PivotDomain): FunctionResultObject;
+        getMeasure: (id: string) => PivotMeasure;
+        parseArgsToPivotDomain(args: import("../..").Maybe<FunctionResultObject>[]): PivotDomain;
+        areDomainArgsFieldsValid(args: import("../..").Maybe<FunctionResultObject>[]): boolean;
+        assertIsValid({ throwOnError }: {
+            throwOnError: boolean;
+        }): FunctionResultObject | undefined;
+        getPossibleFieldValues(dimension: import("../..").PivotDimension): {
+            value: string | boolean | number;
+            label: string;
+        }[];
+        needsReevaluation: boolean;
+    };
+};
+export {};

package/dist/types/helpers/pivot/pivot_registry.d.ts

@@ -0,0 +1,28 @@
+import { ModelConfig } from "../../model";
+import { Registry } from "../../registries/registry";
+import { ApplyRangeChange, CoreGetters, Getters } from "../../types";
+import { PivotCoreDefinition, PivotField, PivotFields } from "../../types/pivot";
+import { Pivot } from "../../types/pivot_runtime";
+import { PivotRuntimeDefinition } from "./pivot_runtime_definition";
+export interface PivotParams {
+    definition: PivotCoreDefinition;
+    getters: Getters;
+}
+export interface PivotCoreParams {
+    definition: PivotCoreDefinition;
+    getters: CoreGetters;
+}
+export type PivotUIConstructor = new (custom: ModelConfig["custom"], params: PivotParams) => Pivot;
+type PivotDefinitionConstructor = new (definition: PivotCoreDefinition, fields: PivotFields, getters: Getters) => PivotRuntimeDefinition;
+export interface PivotRegistryItem {
+    ui: PivotUIConstructor;
+    definition: PivotDefinitionConstructor;
+    dateGranularities: string[];
+    datetimeGranularities: string[];
+    isMeasureCandidate: (field: PivotField) => boolean;
+    isGroupable: (field: PivotField) => boolean;
+    adaptRanges?: (getters: CoreGetters, definition: PivotCoreDefinition, applyChange: ApplyRangeChange) => PivotCoreDefinition;
+}
+export declare const pivotRegistry: Registry<PivotRegistryItem>;
+export declare const datetimeGranularities: string[];
+export {};

package/dist/types/helpers/pivot/pivot_runtime_definition.d.ts

@@ -0,0 +1,14 @@
+import { CommonPivotCoreDefinition, PivotDimension, PivotFields, PivotMeasure } from "../../types/pivot";
+/**
+ * Represent a pivot runtime definition. A pivot runtime definition is a pivot
+ * definition that has been enriched to include the display name of its attributes
+ * (measures, columns, rows).
+ */
+export declare class PivotRuntimeDefinition {
+    readonly measures: PivotMeasure[];
+    readonly columns: PivotDimension[];
+    readonly rows: PivotDimension[];
+    constructor(definition: CommonPivotCoreDefinition, fields: PivotFields);
+    getDimension(nameWithGranularity: string): PivotDimension;
+    getMeasure(id: string): PivotMeasure;
+}

package/dist/types/helpers/pivot/pivot_side_panel_registry.d.ts

@@ -0,0 +1,6 @@
+import { Component } from "@odoo/owl";
+import { Registry } from "../../registries/registry";
+export interface PivotRegistryItem {
+    editor: new (...args: any) => Component;
+}
+export declare const pivotSidePanelRegistry: Registry<PivotRegistryItem>;

package/dist/types/helpers/pivot/pivot_time_adapter.d.ts

@@ -0,0 +1,5 @@
+import { Registry } from "../../registries/registry";
+import { CellValue } from "../../types";
+import { Granularity, PivotTimeAdapter } from "../../types/pivot";
+export declare const pivotTimeAdapterRegistry: Registry<PivotTimeAdapter<CellValue>>;
+export declare function pivotTimeAdapter(granularity: Granularity): PivotTimeAdapter<CellValue>;

package/dist/types/helpers/pivot/spreadsheet_pivot/data_entry_spreadsheet_pivot.d.ts

@@ -0,0 +1,20 @@
+import { EvaluatedCell } from "../../../types";
+import { PivotDimension } from "../../../types/pivot";
+import { SpreadsheetPivotTable } from "../table_spreadsheet_pivot";
+import { SpreadsheetPivotRuntimeDefinition } from "./runtime_definition_spreadsheet_pivot";
+export type FieldName = string;
+export type FieldValue = Pick<EvaluatedCell, "type" | "format" | "value" | "formattedValue">;
+export type DataEntry = Record<FieldName, FieldValue | undefined>;
+export type DataEntries = DataEntry[];
+/**
+ * This function converts a list of data entry into a spreadsheet pivot table.
+ */
+export declare function dataEntriesToSpreadsheetPivotTable(dataEntries: DataEntries, definition: SpreadsheetPivotRuntimeDefinition): SpreadsheetPivotTable;
+/**
+ * Group the dataEntries based on the given dimension
+ */
+export declare function groupPivotDataEntriesBy(dataEntries: DataEntries, dimension: PivotDimension): Partial<Record<string, DataEntry[]>>;
+/**
+ * Order the keys of the given data entries, based on the given dimension
+ */
+export declare function orderDataEntriesKeys(groups: Partial<Record<string, DataEntries>>, dimension: PivotDimension): string[];

package/dist/types/helpers/pivot/spreadsheet_pivot/date_spreadsheet_pivot.d.ts

@@ -0,0 +1,7 @@
+import { CellValue, Locale } from "../../../types";
+import { PivotDimension } from "../../../types/pivot";
+export declare function createDate(dimension: PivotDimension, value: CellValue, locale: Locale): CellValue;
+/**
+ * Reset the cache of the pivot date values.
+ */
+export declare function resetMapValueDimensionDate(): void;

package/dist/types/helpers/pivot/spreadsheet_pivot/runtime_definition_spreadsheet_pivot.d.ts

@@ -0,0 +1,7 @@
+import { Getters, Range } from "../../../types";
+import { PivotFields, SpreadsheetPivotCoreDefinition } from "../../../types/pivot";
+import { PivotRuntimeDefinition } from "../pivot_runtime_definition";
+export declare class SpreadsheetPivotRuntimeDefinition extends PivotRuntimeDefinition {
+    readonly range?: Range;
+    constructor(definition: SpreadsheetPivotCoreDefinition, fields: PivotFields, getters: Getters);
+}