@odoo/o-spreadsheet 19.5.0-alpha.2 → 19.5.0-alpha.20

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

@@ -4,7 +4,9 @@ import { Arg, FunctionResultNumber, FunctionResultObject, Matrix, Maybe } from "
 export declare const AVEDEV: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...values: Arg[]) => number | DivisionByZeroError;
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => DivisionByZeroError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const AVERAGE: {
@@ -33,48 +35,70 @@ export declare const AVERAGEA: {
 export declare const AVERAGEIF: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, criteriaRange: Arg, criterion: Maybe<FunctionResultObject>, averageRange: Arg) => number | DivisionByZeroError;
+    compute: (this: import("..").EvalContext, criteriaRange: Arg, criterion: Maybe<FunctionResultObject>, averageRange: Arg) => DivisionByZeroError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const AVERAGEIFS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, averageRange: Matrix<FunctionResultObject>, ...args: Arg[]) => number | DivisionByZeroError;
+    compute: (this: import("..").EvalContext, averageRange: Matrix<FunctionResultObject>, ...args: Arg[]) => DivisionByZeroError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const COUNT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...values: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const COUNTA: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...values: Arg[]) => number;
+    compute: (...values: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const COVAR: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (dataY: Arg, dataX: Arg) => number;
+    compute: (dataY: Arg, dataX: Arg) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const COVARIANCE_P: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (dataY: Arg, dataX: Arg) => number;
+    compute: (dataY: Arg, dataX: Arg) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const COVARIANCE_S: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (dataY: Arg, dataX: Arg) => number;
+    compute: (dataY: Arg, dataX: Arg) => {
+        value: number;
+    };
     isExported: true;
 };
+export declare const CHISQ_DIST_RT: AddFunctionDescription;
+export declare const CHISQ_TEST: AddFunctionDescription;
+export declare const CONFIDENCE_NORM: AddFunctionDescription;
+export declare const CONFIDENCE_T: AddFunctionDescription;
+export declare const F_TEST: AddFunctionDescription;
 export declare const FORECAST: AddFunctionDescription;
+export declare const GEOMEAN: AddFunctionDescription;
 export declare const GROWTH: AddFunctionDescription;
+export declare const HARMEAN: AddFunctionDescription;
 export declare const INTERCEPT: AddFunctionDescription;
+export declare const KURT: AddFunctionDescription;
 export declare const LARGE: {
     description: string;
     args: import("..").ArgDefinition[];
@@ -99,7 +123,9 @@ export declare const MAXA: {
 export declare const MAXIFS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, range: Matrix<FunctionResultObject>, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, range: Matrix<FunctionResultObject>, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const MEDIAN: {
@@ -123,7 +149,9 @@ export declare const MINA: {
 export declare const MINIFS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, range: Matrix<FunctionResultObject>, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, range: Matrix<FunctionResultObject>, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const PEARSON: AddFunctionDescription;
@@ -169,6 +197,8 @@ export declare const QUARTILE_INC: {
 export declare const RANK: AddFunctionDescription;
 export declare const RSQ: AddFunctionDescription;
 export declare const SLOPE: AddFunctionDescription;
+export declare const SKEW: AddFunctionDescription;
+export declare const SKEW_P: AddFunctionDescription;
 export declare const SMALL: {
     description: string;
     args: import("..").ArgDefinition[];
@@ -179,74 +209,100 @@ export declare const SPEARMAN: AddFunctionDescription;
 export declare const STDEV: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const STDEV_P: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const STDEV_S: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const STDEVA: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const STDEVP: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const STDEVPA: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
+export declare const T_TEST: AddFunctionDescription;
 export declare const STEYX: AddFunctionDescription;
 export declare const TREND: AddFunctionDescription;
+export declare const TRIMMEAN: AddFunctionDescription;
 export declare const VAR: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const VAR_P: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const VAR_S: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const VARA: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const VARP: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const VARPA: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => {
+        value: number;
+    };
     isExported: true;
 };

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

@@ -1,85 +1,114 @@
 import { EvaluationError } from "../types/errors";
-import { Arg, FunctionResultNumber, FunctionResultObject, Maybe } from "../types/misc";
+import { Arg, FunctionResultObject, Maybe } from "../types/misc";
 export declare const CHAR: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, tableNumber: Maybe<FunctionResultObject>) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, tableNumber: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const CLEAN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => string;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const CONCATENATE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...datas: Arg[]) => string;
+    compute: (this: import("..").EvalContext, ...datas: Arg[]) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const EXACT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (string1: Maybe<FunctionResultObject>, string2: Maybe<FunctionResultObject>) => boolean;
+    compute: (this: import("..").EvalContext, string1: Maybe<FunctionResultObject>, string2: Maybe<FunctionResultObject>) => {
+        value: 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 | EvaluationError;
+    compute: (this: import("..").EvalContext, searchFor: Maybe<FunctionResultObject>, textToSearch: Maybe<FunctionResultObject>, startingAt?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const FORMAT_LARGE_NUMBER: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, unite: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, unite: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+        format: string;
+    };
 };
 export declare const JOIN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (delimiter: Maybe<FunctionResultObject>, ...valuesOrArrays: Arg[]) => string;
+    compute: (this: import("..").EvalContext, delimiter: Maybe<FunctionResultObject>, ...valuesOrArrays: Arg[]) => {
+        value: string;
+    };
 };
 export declare const LEFT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const LEN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const LOWER: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => string;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>) => {
+        value: 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 | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, starting_at: Maybe<FunctionResultObject>, extract_length: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const PROPER: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => string;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const REGEXTEST: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => boolean | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: boolean;
+    };
     isExported: true;
 };
 export declare const REGEXEXTRACT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, return_mode?: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => string | string[][] | EvaluationError | {
+    computeArray: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, return_mode?: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    }[][] | {
         value: string;
     };
     isExported: true;
@@ -87,19 +116,25 @@ export declare const REGEXEXTRACT: {
 export declare const REGEXREPLACE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, replacement: Maybe<FunctionResultObject>, occurence?: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, replacement: Maybe<FunctionResultObject>, occurence?: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: 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 | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, position: Maybe<FunctionResultObject>, length: Maybe<FunctionResultObject>, newText: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const RIGHT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const SEARCH: {
@@ -117,49 +152,63 @@ export declare const SEARCH: {
 export declare const SPLIT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>, delimiter: Maybe<FunctionResultObject>, splitByEach?: Maybe<FunctionResultObject>, removeEmptyText?: Maybe<FunctionResultObject>) => EvaluationError | import("..").Matrix<string>;
+    computeArray: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, delimiter: Maybe<FunctionResultObject>, splitByEach?: Maybe<FunctionResultObject>, removeEmptyText?: Maybe<FunctionResultObject>) => EvaluationError | import("..").Matrix<{
+        value: 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 | EvaluationError;
+    compute: (this: import("..").EvalContext, textToSearch: Maybe<FunctionResultObject>, searchFor: Maybe<FunctionResultObject>, replaceWith: Maybe<FunctionResultObject>, occurrenceNumber: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const TEXTJOIN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (delimiter: Maybe<FunctionResultObject>, ignoreEmpty?: Maybe<FunctionResultObject>, ...textsOrArrays: Arg[]) => string;
+    compute: (this: import("..").EvalContext, delimiter: Maybe<FunctionResultObject>, ignoreEmpty?: Maybe<FunctionResultObject>, ...textsOrArrays: Arg[]) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const TEXTSPLIT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: FunctionResultObject, colDelimiter: Arg, rowDelimiter: Arg, ignoreEmpty?: Maybe<FunctionResultObject>, matchMode?: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | import("..").Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, text: FunctionResultObject, colDelimiter: Arg, rowDelimiter: Arg, ignoreEmpty?: Maybe<FunctionResultObject>, matchMode?: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | import("..").Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const TRIM: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => string;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const UPPER: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => string;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const TEXT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, format: Maybe<FunctionResultObject>) => string;
+    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, format: Maybe<FunctionResultObject>) => {
+        value: import("..").FormattedValue;
+    };
     isExported: true;
 };
 export declare const VALUE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const TEXTAFTER: {

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

@@ -2,6 +2,8 @@ import { FunctionResultObject, Maybe } from "../types/misc";
 export declare const HYPERLINK: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (url: Maybe<FunctionResultObject>, linkLabel: Maybe<FunctionResultObject>) => string;
+    compute: (this: import("..").EvalContext, url: Maybe<FunctionResultObject>, linkLabel: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };

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

@@ -1,6 +1,18 @@
-import { ChartDefinition } from "../types/chart/chart";
-import { CarouselItem } from "../types/figure";
+import { AnchorOffset, Carousel, CarouselItem } from "../types/figure";
 import { Getters } from "../types/getters";
-export declare const CAROUSEL_DEFAULT_CHART_DEFINITION: ChartDefinition;
+import { UID } from "../types/misc";
+import { Rect } from "../types/rendering";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+/**
+ * Compute the anchor of a chart popped out of a carousel: slightly offset from the
+ * carousel figure so the new chart does not perfectly overlap it.
+ */
+export declare function getPoppedOutChartAnchor(env: SpreadsheetChildEnv, sheetId: UID, carouselId: UID): AnchorOffset;
 export declare function getCarouselItemPreview(getters: Getters, item: CarouselItem): string;
 export declare function getCarouselItemTitle(getters: Getters, item: CarouselItem): string;
+export declare function getCarouselLayout(figureRect: Rect, carousel: Carousel, selectedItem: CarouselItem | undefined): {
+    headerRect: Rect;
+    separatorRect: Rect | undefined;
+    contentRect: Rect;
+    headerLineHeight: 1.5;
+};

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

@@ -1,7 +1,7 @@
 import { CompiledFormula } from "../../formulas/compiler";
 import { Cell, CellValue, EvaluatedCell, FormulaCell, LiteralCell } from "../../types/cells";
-import { CoreGetters } from "../../types/core_getters";
 import { Format, LocaleFormat } from "../../types/format";
+import { CoreGetters } from "../../types/getters";
 import { Locale } from "../../types/locale";
 import { CellPosition, FunctionResultObject, Style, UID } from "../../types/misc";
 export declare function evaluateLiteral(literalCell: LiteralCell, localeFormat: LocaleFormat, position?: CellPosition): EvaluatedCell;

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

@@ -94,7 +94,7 @@ export declare const DARK_MODE_FILTER_STRING: string;
  * stored in the theme so that, after the dark-mode CSS filter is applied, the
  * desired color is actually shown.
  *
- * This function computes the exact inverse of the DARK_MODE_FILTER chain.
+ * This function computes an approximate inverse of the DARK_MODE_FILTER chain.
  */
 export declare function adaptForDarkMode(displayedColor: Color): Color;
 export declare function darkenColor(color: Color, percentage: number): Color;

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

@@ -0,0 +1,2 @@
+import { ColorThemeName, GridRenderingTheme } from "../types/rendering";
+export declare const COLOR_THEMES: Record<ColorThemeName, GridRenderingTheme>;

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

@@ -0,0 +1,17 @@
+import { EvaluatedCell } from "../types/cells";
+import { Getters } from "../types/getters";
+import { CellPosition, UID, Zone } from "../types/misc";
+export type ExtendedColumnType = "error" | "number" | "percentage" | "date" | "categorical" | "label" | "boolean" | "empty";
+export interface ColumnAnalysis {
+    zone: Zone;
+    type: ExtendedColumnType;
+    title?: string;
+    headerInZone: boolean;
+    rowCount: number;
+    uniqueCount: number;
+    uniqueRatio: number;
+    maxValue?: number;
+    nonEmpty: EvaluatedCell[];
+}
+export declare function analyzeColumns(zones: Zone[], getters: Getters): ColumnAnalysis[];
+export declare function getColumnTableHeaderPosition(sheetId: UID, zone: Zone, getters: Getters): CellPosition | undefined;

package/dist/types/helpers/figures/chart.d.ts

@@ -1,8 +1,9 @@
+import { CompiledFormula } from "../../formulas/compiler";
 import { ChartCreationContext, ChartData, ChartDefinition } from "../../types/chart/chart";
-import { CoreGetters } from "../../types/core_getters";
-import { Getters } from "../../types/getters";
+import { CoreGetters, EvaluationGetters } from "../../types/getters";
 import { RangeAdapterFunctions, UID } from "../../types/misc";
 import { Range } from "../../types/range";
+import { ColorThemeName } from "../../types/rendering";
 import { Validator } from "../../types/validator";
 export declare class SpreadsheetChart {
     private readonly getters;
@@ -15,15 +16,17 @@ export declare class SpreadsheetChart {
     static fromStrDefinition(getters: CoreGetters, sheetId: UID, definition: ChartDefinition<string>): SpreadsheetChart;
     static fromDefinition(getters: CoreGetters, sheetId: UID, definition: ChartDefinition<Range>): SpreadsheetChart;
     static validate(validator: Validator, definition: ChartDefinition<string>): import("../..").CommandResult | import("../..").CommandResult[];
-    static transformDefinition(chartSheetId: UID, definition: ChartDefinition<string>, rangeAdapters: RangeAdapterFunctions): import("../../types/chart/line_chart").LineChartDefinition<string> | import("../../types/chart/pie_chart").PieChartDefinition<string> | import("../../types/chart/bar_chart").BarChartDefinition<string> | import("../../types/chart/scatter_chart").ScatterChartDefinition<string> | import("../../types/chart/combo_chart").ComboChartDefinition<string> | import("../../types/chart/waterfall_chart").WaterfallChartDefinition<string> | import("../../types/chart/pyramid_chart").PyramidChartDefinition<string> | import("../../types/chart/radar_chart").RadarChartDefinition<string> | import("../../types/chart/geo_chart").GeoChartDefinition<string> | import("../../types/chart/funnel_chart").FunnelChartDefinition<string> | import("../../types/chart/sunburst_chart").SunburstChartDefinition<string> | import("../../types/chart/tree_map_chart").TreeMapChartDefinition<string> | import("../../types/chart/calendar_chart").CalendarChartDefinition<string> | import("../../types/chart/scorecard_chart").ScorecardChartDefinition<string> | import("../../types/chart/gauge_chart").GaugeChartDefinition<string> | import("../../types/chart/bubble_chart").BubbleChartDefinition<string>;
+    static transformDefinition(chartSheetId: UID, definition: ChartDefinition<string>, rangeAdapters: RangeAdapterFunctions): import("../../types/chart/scorecard_chart").ScorecardChartDefinition | import("../../types/chart/line_chart").LineChartDefinition<string> | import("../../types/chart/pie_chart").PieChartDefinition<string> | import("../../types/chart/bar_chart").BarChartDefinition<string> | import("../../types/chart/scatter_chart").ScatterChartDefinition<string> | import("../../types/chart/combo_chart").ComboChartDefinition<string> | import("../../types/chart/waterfall_chart").WaterfallChartDefinition<string> | import("../../types/chart/pyramid_chart").PyramidChartDefinition<string> | import("../../types/chart/radar_chart").RadarChartDefinition<string> | import("../../types/chart/geo_chart").GeoChartDefinition<string> | import("../../types/chart/funnel_chart").FunnelChartDefinition<string> | import("../../types/chart/sunburst_chart").SunburstChartDefinition<string> | import("../../types/chart/tree_map_chart").TreeMapChartDefinition<string> | import("../../types/chart/calendar_chart").CalendarChartDefinition<string> | import("../../types/chart/gauge_chart").GaugeChartDefinition<string> | import("../../types/chart/bubble_chart").BubbleChartDefinition<string>;
     getRangeDefinition(): ChartDefinition<Range>;
     getDefinition(): ChartDefinition<string>;
     updateRanges(rangeAdapters: RangeAdapterFunctions): ChartDefinition<Range>;
     duplicateInDuplicatedSheet(sheetIdFrom: UID, sheetIdTo: UID): ChartDefinition<string>;
     copyInSheetId(sheetIdTo: UID): ChartDefinition<Range>;
     getContextCreation(): ChartCreationContext;
-    getDefinitionForExcel(getters: Getters): import("../..").ExcelChartDefinition | undefined;
-    getData(getters: Getters, chartId: UID): ChartData;
-    getRuntime(getters: Getters, chartId: UID): import("../..").ChartRuntime;
+    getDefinitionForExcel(getters: EvaluationGetters): import("../..").ExcelChartDefinition | undefined;
+    getData(getters: EvaluationGetters, chartId: UID): ChartData;
+    getFormulas(getters: CoreGetters): CompiledFormula[];
+    getRuntime(getters: EvaluationGetters, chartId: UID, colorThemeName: ColorThemeName): import("../..").ChartRuntime;
     static deleteInvalidKeys(definition: ChartDefinition<any>): ChartDefinition<any>;
+    loadDataForExport(getters: EvaluationGetters): Promise<void | undefined>;
 }

package/dist/types/helpers/figures/charts/chart_common.d.ts

@@ -1,12 +1,11 @@
 import { ChartAxisFormats, ChartDefinition, ChartRangeDataSource, DataSet, DataSetStyle, DatasetValues, ExcelChartDataset } from "../../../types/chart/chart";
 import { CommandResult } from "../../../types/commands";
-import { CoreGetters } from "../../../types/core_getters";
 import { LocaleFormat } from "../../../types/format";
-import { Getters } from "../../../types/getters";
+import { CoreGetters } from "../../../types/getters";
 import { Locale } from "../../../types/locale";
 import { Color, RangeAdapterFunctions, UID } from "../../../types/misc";
 import { Range } from "../../../types/range";
-import { DOMCoordinates, DOMDimension } from "../../../types/rendering";
+import { ColorThemeName } from "../../../types/rendering";
 import { ColorGenerator } from "../../color";
 export declare const TREND_LINE_XAXIS_ID = "x1";
 export declare const MOVING_AVERAGE_TREND_LINE_XAXIS_ID = "xMovingAverage";
@@ -47,7 +46,6 @@ export declare function chartMutedFontColor(backgroundColor: Color | undefined):
 export declare function checkDataset(dataSource: ChartRangeDataSource<string>): CommandResult;
 export declare function checkLabelRange(dataSource: ChartRangeDataSource<string>): CommandResult;
 export declare function shouldRemoveFirstLabel(numberOfLabels: number, numberOfDataPoints: number | undefined, dataSetsHaveTitle: boolean): boolean;
-export declare function getChartPositionAtCenterOfViewport(getters: Getters, chartSize: DOMDimension): DOMCoordinates;
 export declare function getDefinedAxis(definition: Partial<ChartDefinition<string | Range>>): {
     useLeftAxis: boolean;
     useRightAxis: boolean;
@@ -63,4 +61,4 @@ export declare function truncateLabel(label: string | undefined, maxLen?: number
 export declare function isTrendLineAxis(axisID: string): axisID is "x1" | "xMovingAverage";
 export declare function getChartBackgroundColor({ background }: {
     background?: Color;
-}, getters: Getters): Color;
+}, colorThemeName: ColorThemeName): Color;

package/dist/types/helpers/figures/charts/chart_data_source_helpers.d.ts

@@ -0,0 +1,10 @@
+import { ChartRangeDataSource } from "../../../types/chart/chart";
+import { Getters } from "../../../types/getters";
+import { Zone } from "../../../types/misc";
+export declare function getUnboundRange(getters: Getters, zone: Zone): string;
+export declare function isDatasetTitled(getters: Getters, zone: Zone): boolean;
+export declare function dataset(zone: Zone, getters: Getters, id?: string): {
+    dataRange: string;
+    dataSetId: string;
+};
+export declare function rangeSource(dataSets: ReturnType<typeof dataset>[], dataSetsHaveTitle: boolean, labelRange?: string): ChartRangeDataSource<string>;

package/dist/types/helpers/figures/charts/chart_data_sources.d.ts

@@ -1,11 +1,11 @@
 import { ChartDataSourceBuilder } from "../../../registries/chart_data_source_registry";
 import { ChartData, ChartRangeDataSource, DataSet } from "../../../types/chart/chart";
-import { Getters } from "../../../types/getters";
+import { EvaluationGetters } from "../../../types/getters";
 import { FunctionResultObject } from "../../../types/misc";
 import { Range } from "../../../types/range";
 export declare const ChartRangeDataSourceHandler: ChartDataSourceBuilder<ChartRangeDataSource<string>, ChartRangeDataSource<Range>>;
-export declare function getChartData(getters: Getters, dataSource: ChartRangeDataSource): ChartData;
+export declare function getChartData(getters: EvaluationGetters, dataSource: ChartRangeDataSource): ChartData;
 /**
  * Get the data from a dataSet
  */
-export declare function getData(getters: Getters, ds: DataSet): FunctionResultObject[];
+export declare function getData(getters: EvaluationGetters, ds: DataSet): FunctionResultObject[];

package/dist/types/helpers/figures/charts/chart_suggestion_engine.d.ts

@@ -0,0 +1,8 @@
+import { ChartDefinition } from "../../../types/chart/chart";
+import { Getters } from "../../../types/getters";
+import { Zone } from "../../../types/misc";
+export interface ChartSuggestion {
+    description: string;
+    definition: ChartDefinition;
+}
+export declare function getChartSuggestions(zones: Zone[], getters: Getters): ChartSuggestion[];