@odoo/o-spreadsheet 18.0.55 → 18.0.68

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

@@ -0,0 +1,244 @@
+import { AddFunctionDescription, Arg, FunctionResultNumber, FunctionResultObject, Matrix, Maybe } from "../types";
+export declare const AVEDEV: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => number;
+    isExported: true;
+};
+export declare const AVERAGE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const AVERAGE_WEIGHTED: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => FunctionResultNumber;
+};
+export declare const AVERAGEA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const AVERAGEIF: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, criteriaRange: Arg, criterion: Maybe<FunctionResultObject>, averageRange: Arg) => number;
+    isExported: true;
+};
+export declare const AVERAGEIFS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, averageRange: Matrix<FunctionResultObject>, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const COUNT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => number;
+    isExported: true;
+};
+export declare const COUNTA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...values: Arg[]) => number;
+    isExported: true;
+};
+export declare const COVAR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (dataY: Arg, dataX: Arg) => number;
+    isExported: true;
+};
+export declare const COVARIANCE_P: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (dataY: Arg, dataX: Arg) => number;
+    isExported: true;
+};
+export declare const COVARIANCE_S: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (dataY: Arg, dataX: Arg) => number;
+    isExported: true;
+};
+export declare const FORECAST: AddFunctionDescription;
+export declare const GROWTH: AddFunctionDescription;
+export declare const INTERCEPT: AddFunctionDescription;
+export declare const LARGE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, n: Maybe<FunctionResultObject>) => FunctionResultObject;
+    isExported: true;
+};
+export declare const LINEST: AddFunctionDescription;
+export declare const LOGEST: AddFunctionDescription;
+export declare const MATTHEWS: AddFunctionDescription;
+export declare const MAX: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MAXA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MAXIFS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, range: Matrix<FunctionResultObject>, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const MEDIAN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MINA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MINIFS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, range: Matrix<FunctionResultObject>, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const PEARSON: AddFunctionDescription;
+export declare const CORREL: AddFunctionDescription;
+export declare const PERCENTILE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, percentile: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const PERCENTILE_EXC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, percentile: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const PERCENTILE_INC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, percentile: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const POLYFIT_COEFFS: AddFunctionDescription;
+export declare const POLYFIT_FORECAST: AddFunctionDescription;
+export declare const QUARTILE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, quartileNumber: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const QUARTILE_EXC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, quartileNumber: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const QUARTILE_INC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, quartileNumber: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const RANK: AddFunctionDescription;
+export declare const RSQ: AddFunctionDescription;
+export declare const SLOPE: AddFunctionDescription;
+export declare const SMALL: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, n: Maybe<FunctionResultObject>) => FunctionResultObject;
+    isExported: true;
+};
+export declare const SPEARMAN: AddFunctionDescription;
+export declare const STDEV: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STDEV_P: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STDEV_S: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STDEVA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STDEVP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STDEVPA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STEYX: AddFunctionDescription;
+export declare const TREND: AddFunctionDescription;
+export declare const VAR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const VAR_P: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const VAR_S: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const VARA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const VARP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const VARPA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};

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

@@ -0,0 +1,132 @@
+import { Arg, FunctionResultObject, Matrix, Maybe } from "../types";
+export declare const CHAR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, tableNumber: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const CLEAN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const CONCATENATE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...datas: Arg[]) => string;
+    isExported: true;
+};
+export declare const EXACT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (string1: Maybe<FunctionResultObject>, string2: Maybe<FunctionResultObject>) => boolean;
+    isExported: true;
+};
+export declare const FIND: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, searchFor: Maybe<FunctionResultObject>, textToSearch: Maybe<FunctionResultObject>, startingAt?: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const JOIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (delimiter: Maybe<FunctionResultObject>, ...valuesOrArrays: Arg[]) => string;
+};
+export declare const LEFT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => string;
+    isExported: true;
+};
+export declare const LEN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const LOWER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const MID: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, starting_at: Maybe<FunctionResultObject>, extract_length: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const PROPER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const REPLACE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, position: Maybe<FunctionResultObject>, length: Maybe<FunctionResultObject>, newText: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const RIGHT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => string;
+    isExported: true;
+};
+export declare const SEARCH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, searchFor: Maybe<FunctionResultObject>, textToSearch: Maybe<FunctionResultObject>, startingAt?: Maybe<FunctionResultObject>) => {
+        value: "#ERROR";
+        message: string;
+    } | {
+        value: number;
+        message?: undefined;
+    };
+    isExported: true;
+};
+export declare const SPLIT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>, delimiter: Maybe<FunctionResultObject>, splitByEach?: Maybe<FunctionResultObject>, removeEmptyText?: Maybe<FunctionResultObject>) => Matrix<string>;
+    isExported: false;
+};
+export declare const SUBSTITUTE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, textToSearch: Maybe<FunctionResultObject>, searchFor: Maybe<FunctionResultObject>, replaceWith: Maybe<FunctionResultObject>, occurrenceNumber: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const TEXTJOIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (delimiter: Maybe<FunctionResultObject>, ignoreEmpty: Maybe<FunctionResultObject>, ...textsOrArrays: Arg[]) => string;
+    isExported: true;
+};
+export declare const TRIM: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const UPPER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const TEXT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, format: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const VALUE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};

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

@@ -0,0 +1,7 @@
+import { FunctionResultObject, Maybe } from "../types";
+export declare const HYPERLINK: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (url: Maybe<FunctionResultObject>, linkLabel: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};

package/dist/types/helpers/cells/cell_evaluation.d.ts

@@ -0,0 +1,4 @@
+import { Cell, CellValue, EvaluatedCell, FunctionResultObject, LiteralCell, Locale, LocaleFormat } from "../../types";
+export declare function evaluateLiteral(literalCell: LiteralCell, localeFormat: LocaleFormat): EvaluatedCell;
+export declare function parseLiteral(content: string, locale: Locale): CellValue;
+export declare function createEvaluatedCell(functionResult: FunctionResultObject, locale?: Locale, cell?: Cell): EvaluatedCell;

package/dist/types/helpers/cells/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../links";
+export * from "./cell_evaluation";

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

@@ -0,0 +1,8 @@
+import type { TimeScaleOptions } from "chart.js";
+import { DeepPartial, Format, Locale } from "../types";
+/**
+ * Regex to test if a format string is a date format that can be translated into a luxon time format
+ */
+export declare const timeFormatLuxonCompatible: RegExp;
+/** Get the time options for the XAxis of ChartJS */
+export declare function getChartTimeOptions(labels: string[], labelFormat: Format, locale: Locale): DeepPartial<TimeScaleOptions["time"]>;

package/dist/types/helpers/clipboard/clipboard_helpers.d.ts

@@ -0,0 +1,32 @@
+import { ClipboardHandler } from "../../clipboard_handlers/abstract_clipboard_handler";
+import { SelectionStreamProcessor } from "../../selection_stream/selection_stream_processor";
+import { ClipboardCellData, ClipboardOptions, ClipboardPasteTarget, MinimalClipboardData, OSClipboardContent, ParsedOSClipboardContent, UID, Zone } from "../../types";
+export declare function getClipboardDataPositions(sheetId: UID, zones: Zone[]): ClipboardCellData;
+/**
+ * Compute the complete zones where to paste the current clipboard
+ */
+export declare function getPasteZones<T>(target: Zone[], content: T[][]): Zone[];
+export declare function parseOSClipboardContent(content: OSClipboardContent): ParsedOSClipboardContent;
+/**
+ * Applies each clipboard handler to paste its corresponding data into the target.
+ */
+export declare const applyClipboardHandlersPaste: (handlers: {
+    handlerName: string;
+    handler: ClipboardHandler<any>;
+}[], copiedData: MinimalClipboardData, target: ClipboardPasteTarget, options: ClipboardOptions) => void;
+/**
+ * Returns the paste target based on clipboard handlers.
+ * Also includes the full affected zone and the list of pasted zones for selection.
+ */
+export declare function getPasteTargetFromHandlers(sheetId: string, zones: Zone[], copiedData: MinimalClipboardData, handlers: {
+    handlerName: string;
+    handler: ClipboardHandler<any>;
+}[], options: ClipboardOptions): {
+    target: ClipboardPasteTarget;
+    zone?: Zone;
+    selectedZones: Zone[];
+};
+/**
+ * Updates the selection after a paste operation.
+ */
+export declare const selectPastedZone: (selection: SelectionStreamProcessor, sourceZones: Zone[], pastedZones: Zone[]) => void;

package/dist/types/helpers/clipboard/navigator_clipboard_wrapper.d.ts

@@ -0,0 +1,13 @@
+import { OSClipboardContent } from "./../../types/clipboard";
+export type ClipboardReadResult = {
+    status: "ok";
+    content: OSClipboardContent;
+} | {
+    status: "permissionDenied" | "notImplemented";
+};
+export interface ClipboardInterface {
+    write(clipboardContent: OSClipboardContent): Promise<void>;
+    writeText(text: string): Promise<void>;
+    read(): Promise<ClipboardReadResult>;
+}
+export declare function instantiateClipboard(): ClipboardInterface;

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

@@ -0,0 +1,80 @@
+import { Color, HSLA, RGBA } from "../types";
+export declare const colors: string[];
+export declare function colorNumberString(color: number): Color;
+/**
+ * Converts any CSS color value to a standardized hex6 value.
+ * Accepts: hex3, hex6, hex8, rgb[1] and rgba[1].
+ *
+ * [1] under the form rgb(r, g, b, a?) or rgba(r, g, b, a?)
+ * with r,g,b ∈ [0, 255] and a ∈ [0, 1]
+ *
+ * toHex("#ABC")
+ * >> "#AABBCC"
+ *
+ * toHex("#AAAFFF")
+ * >> "#AAAFFF"
+ *
+ * toHex("rgb(30, 80, 16)")
+ * >> "#1E5010"
+ *
+ *  * toHex("rgb(30, 80, 16, 0.5)")
+ * >> "#1E501080"
+ *
+ */
+export declare function toHex(color: Color): Color;
+export declare function isColorValid(color: Color): boolean;
+export declare function isHSLAValid(color: HSLA): boolean;
+export declare function rgba(r: number, g: number, b: number, a?: number): RGBA;
+/**
+ * The relative brightness of a point in the colorspace, normalized to 0 for
+ * darkest black and 1 for lightest white.
+ * https://www.w3.org/TR/WCAG20/#relativeluminancedef
+ */
+export declare function relativeLuminance(color: Color): number;
+/**
+ * RGBA to HEX representation (#RRGGBBAA).
+ *
+ * https://css-tricks.com/converting-color-spaces-in-javascript/
+ */
+export declare function rgbaToHex(rgba: RGBA): Color;
+/**
+ * Color string to RGBA representation
+ */
+export declare function colorToRGBA(color: Color): RGBA;
+/**
+ * HSLA to RGBA.
+ *
+ * https://css-tricks.com/converting-color-spaces-in-javascript/
+ */
+export declare function hslaToRGBA(hsla: HSLA): RGBA;
+/**
+ * HSLA to RGBA.
+ *
+ * https://css-tricks.com/converting-color-spaces-in-javascript/
+ */
+export declare function rgbaToHSLA(rgba: RGBA): HSLA;
+export declare function hslaToHex(hsla: HSLA): Color;
+export declare function hexToHSLA(hex: Color): HSLA;
+/**
+ * Will compare two color strings
+ * A tolerance can be provided to account for small differences that could
+ * be introduced by non-bijective transformations between color spaces.
+ *
+ * E.g. HSV <-> RGB is not a bijection
+ *
+ * Note that the tolerance is applied on the euclidean distance between
+ * the two **normalized** color values.
+ */
+export declare function isSameColor(color1: Color, color2: Color, tolerance?: number): boolean;
+export declare function setColorAlpha(color: Color, alpha: number): string;
+export declare function lightenColor(color: Color, percentage: number): Color;
+export declare function darkenColor(color: Color, percentage: number): Color;
+export declare function getNthColor(index: number, palette: Color[]): Color;
+export declare function getColorsPalette(quantity: number): string[];
+export declare class ColorGenerator {
+    private preferredColors;
+    private currentColorIndex;
+    private palette;
+    constructor(paletteSize: number, preferredColors?: (string | undefined)[]);
+    next(): string;
+}

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

@@ -0,0 +1,38 @@
+import { HeaderIndex, Position, RangePart } from "../types";
+import { TokenizingChars } from "./misc";
+/**
+ * Convert a (col) number to the corresponding letter.
+ *
+ * Examples:
+ *     0 => 'A'
+ *     25 => 'Z'
+ *     26 => 'AA'
+ *     27 => 'AB'
+ */
+export declare function numberToLetters(n: number): string;
+export declare function lettersToNumber(letters: string): number;
+export declare const MAX_COL: number;
+export declare const MAX_ROW = 9999998;
+export declare function consumeSpaces(chars: TokenizingChars): void;
+export declare function consumeLetters(chars: TokenizingChars): number;
+export declare function consumeDigits(chars: TokenizingChars): number;
+/**
+ * Convert a "XC" coordinate to cartesian coordinates.
+ *
+ * Examples:
+ *   A1 => [0,0]
+ *   B3 => [1,2]
+ *
+ * Note: it also accepts lowercase coordinates, but not fixed references
+ */
+export declare function toCartesian(xc: string): Position;
+/**
+ * Convert from cartesian coordinate to the "XC" coordinate system.
+ *
+ * Examples:
+ *   - 0,0 => A1
+ *   - 1,2 => B3
+ *   - 0,0, {colFixed: false, rowFixed: true} => A$1
+ *   - 1,2, {colFixed: true, rowFixed: false} => $B3
+ */
+export declare function toXC(col: HeaderIndex, row: HeaderIndex, rangePart?: RangePart): string;

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

@@ -0,0 +1,14 @@
+import { Position } from "../types";
+type ItemsDic<T> = {
+    [id: number]: T;
+};
+/**
+ * Get the id of the given item (its key in the given dictionary).
+ * If the given item does not exist in the dictionary, it creates one with a new id.
+ */
+export declare function getItemId<T>(item: T, itemsDic: ItemsDic<T>): number;
+export declare function groupItemIdsByZones(positionsByItemId: {
+    [id: number]: Position[];
+}): Record<string, number>;
+export declare function getCanonicalRepresentation(item: any): string;
+export {};

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

@@ -0,0 +1,6 @@
+import { DataValidationCriterion, Locale } from "../types";
+/** Get all the dates values of a criterion converted to numbers, converting date values such as "today" to actual dates  */
+export declare function getDateNumberCriterionValues(criterion: DataValidationCriterion, locale: Locale): (number | undefined)[];
+/** Convert the criterion values to numbers. Return undefined values if they cannot be converted to numbers. */
+export declare function getCriterionValuesAsNumber(criterion: DataValidationCriterion, locale: Locale): (number | undefined)[];
+export declare function getDateCriterionFormattedValues(values: string[], locale: Locale): string[];