@odoo/o-spreadsheet 19.2.11 → 19.3.2

package/dist/types/plugins/ui_core_views/cell_evaluation/r_tree.d.ts

@@ -0,0 +1,108 @@
+import { UID, Zone } from "../../../types/misc";
+/**
+ * R-Tree Data Structure
+ *
+ * R-Tree is a spatial data structure used for efficient indexing and querying
+ * of multi-dimensional objects, particularly in geometric and spatial applications.
+ *
+ * It organizes objects into a tree hierarchy, grouping nearby objects together
+ * in bounding boxes. Each node in the tree represents a bounding box that
+ * contains its child nodes or leaf objects. This hierarchical structure allows
+ * for faster spatial queries.
+ *
+ * @see https://en.wikipedia.org/wiki/R-tree
+ *
+ * Consider a 2D Space with four zones: A, B, C, D
+ * +--------------------------+
+ * |                          |
+ * |   +---+     +-------+    |
+ * |   | A |     |   B   |    |
+ * |   +---+     +-------+    |
+ * |                          |
+ * |                          |
+ * |          +---+           |
+ * |          | C |           |
+ * |          +---+           |
+ * |      +-----------+       |
+ * |      |     D     |       |
+ * |      +-----------+       |
+ * |                          |
+ * +--------------------------+
+ *
+ * It groups together zones that are spatially close into a minimum bounding box.
+ * For example, A and B are grouped together in rectangle R1, and C and D are grouped
+ * in R2.
+ *
+ * R0
+ * +--------------------------+
+ * |   R1                     |
+ * |   +-----------------+    |
+ * |   | A |     |   B   |    |
+ * |   +-----------------+    |
+ * |                          |
+ * |      R2                  |
+ * |      +---+---+---+       |
+ * |      |   | C |   |       |
+ * |      |   +---+   |       |
+ * |      +-----------+       |
+ * |      |     D     |       |
+ * |      +-----------+       |
+ * |                          |
+ * +--------------------------+
+ *
+ * The tree would look like this:
+ *          R0
+ *         /  \
+ *        /    \
+ *       R1     R2
+ *       |      |
+ *      A,B    C,D
+
+ * Choosing how to group the zones is crucial for the performance of the tree.
+ * Key considerations include avoiding excessive empty space coverage and minimizing overlap
+ * to reduce the number of subtrees processed during searches.
+ *
+ * Various heuristics exist for determining the optimal grouping strategy, such as "least enlargement"
+ * which prioritizes grouping nodes resulting in the smallest increase in bounding box size. In cases where
+ * the choice cannot be made based on this criterion due to the same enlargement for different groupings,
+ * we then evaluate "least area," aiming to minimize the overall area of bounding boxes.
+ *
+ * This implementation is tailored for spreadsheet use, indexing objects associated
+ * with a zone and a sheet.
+ *
+ * It uses the RBush library under the hood. One 2D RBush R-tree per sheet.
+ * @see https://github.com/mourner/rbush
+ */
+export declare class SpreadsheetRTree<T> {
+    /**
+     * One 2D R-tree per sheet
+     */
+    private rTrees;
+    /**
+     * Bulk-inserts the given items into the tree. Bulk insertion is usually ~2-3 times
+     * faster than inserting items one by one. After bulk loading (bulk insertion into
+     * an empty tree), subsequent query performance is also ~20-30% better.
+     */
+    constructor(items?: RTreeItem[]);
+    insert(item: RTreeItem<T>): void;
+    search({ zone, sheetId }: RTreeBoundingBox): RTreeItem<T>[];
+    remove(item: RTreeItem<T>): void;
+    rtreeItemComparer(left: RTreeItem<T>, right: RTreeItem<T>): boolean;
+}
+/**
+ * Data associated with a range to be indexed in a R-tree
+ */
+export interface RTreeItem<T = unknown> {
+    /**
+     * A bounding box to locate the item in the space
+     */
+    boundingBox: RTreeBoundingBox;
+    /**
+     * Any arbitrary data associated with the bounding box
+     */
+    data: T;
+}
+export interface RTreeBoundingBox {
+    sheetId: UID;
+    zone: Zone;
+}

package/dist/types/plugins/ui_core_views/cell_evaluation/range_set.d.ts

@@ -0,0 +1,23 @@
+import { CellPosition } from "../../..";
+import { BoundedRange } from "../../../types/range";
+export declare class RangeSet {
+    private setsBySheetId;
+    constructor(ranges?: Iterable<BoundedRange>);
+    add(range: BoundedRange): void;
+    addMany(ranges: Iterable<BoundedRange>): void;
+    addPosition(position: CellPosition): void;
+    addManyPositions(positions: Iterable<CellPosition>): void;
+    has(range: BoundedRange): boolean;
+    hasPosition(position: CellPosition): boolean;
+    delete(range: BoundedRange): void;
+    deleteMany(ranges: Iterable<BoundedRange>): void;
+    deleteManyPositions(positions: Iterable<CellPosition>): void;
+    difference(other: RangeSet): RangeSet;
+    copy(): RangeSet;
+    clear(): void;
+    isEmpty(): boolean;
+    /**
+     * iterator of all the ranges in the RangeSet
+     */
+    [Symbol.iterator](): IterableIterator<BoundedRange>;
+}

package/dist/types/plugins/ui_core_views/cell_evaluation/spreading_relation.d.ts

@@ -0,0 +1,63 @@
+import { CellPosition, UID, Zone } from "../../../types/misc";
+/**
+ * Contains, for each cell, the array
+ * formulas that could potentially spread on it
+ * This is essentially a two way mapping between array formulas
+ * and their results.
+ *
+ * As we don't allow two array formulas to spread on the same cell, this structure
+ * is used to force the reevaluation of the potential spreaders of a cell when the
+ * content of this cell is modified. This structure should be updated each time
+ * an array formula is evaluated and try to spread on another cell.
+ *
+ */
+export declare class SpreadingRelation {
+    /**
+     * Internal structure:
+     * For something like
+     * - A2:'=SPLIT("KAYAK", "A")'
+     * - B1:'=TRANSPOSE(SPLIT("COYOTE", "O"))'
+     *
+     * Resulting in:
+     * ```
+     * -----------------
+     * |   | A | B | C |
+     * |---+---+---+---|
+     * | 1 |   | C |   |
+     * | 2 | K | Y | K |
+     * | 3 |   | T |   |
+     * | 4 |   | E |   |
+     * -----------------
+     * ```
+     * We have `resultsToArrayFormulas` is an R-tree looking like:
+     * - (A2:C2) --> A2     meaning values in A2:C2 are the result of A2
+     * - (B1:B4) --> B1     meaning values in B1:B4 are the result of B1
+     *
+     * Note that B2 is part of both zones because it can be the result of
+     * A2 or B1.
+     * Using an R-tree allows for fast insertions while still having
+     * a relatively fast lookup.
+     *
+     * We have `arrayFormulasToResults` looking like:
+     * - (A2) --> A2:C2     meaning A2 spreads on the zone A2:C2
+     * - (B1) --> B1:B4     meaning B1 spreads on the zone B1:B4
+     *
+     */
+    private readonly resultsToArrayFormulas;
+    private readonly arrayFormulasToResults;
+    searchFormulaPositionsSpreadingOn(sheetId: UID, zone: Zone): CellPosition[];
+    getArrayResultZone(formulasPosition: CellPosition): Zone | undefined;
+    /**
+     * Remove a spreading relation for a given array formula position
+     * and its result zone
+     */
+    removeNode(position: CellPosition): void;
+    /**
+     * Create a spreading relation between two cells
+     */
+    addRelation({ arrayFormulaPosition, resultZone: resultPosition, }: {
+        arrayFormulaPosition: CellPosition;
+        resultZone: Zone;
+    }): void;
+    isArrayFormula(position: CellPosition): boolean;
+}

package/dist/types/plugins/ui_core_views/cell_evaluation/zone_set.d.ts

@@ -0,0 +1,16 @@
+import { UnboundedZone, Zone } from "../../..";
+export declare class ZoneSet {
+    private profilesStartingPosition;
+    private profiles;
+    constructor(zones?: Iterable<Zone | UnboundedZone>);
+    isEmpty(): boolean;
+    add(zone: Zone | UnboundedZone): void;
+    delete(zone: Zone | UnboundedZone): void;
+    has(zone: Zone | UnboundedZone): boolean;
+    difference(other: ZoneSet): ZoneSet;
+    copy(): ZoneSet;
+    /**
+     * iterator of all the zones in the ZoneSet
+     */
+    [Symbol.iterator](): IterableIterator<Zone>;
+}

package/dist/types/plugins/ui_core_views/cell_icon_plugin.d.ts

@@ -0,0 +1,15 @@
+import { GridIcon } from "../../registries/icons_on_cell_registry";
+import { Command } from "../../types/commands";
+import { CellPosition } from "../../types/misc";
+import { Rect } from "../../types/rendering";
+import { CoreViewPlugin } from "../core_view_plugin";
+export declare class CellIconPlugin extends CoreViewPlugin {
+    static getters: readonly ["doesCellHaveGridIcon", "getCellIcons", "getCellIconRect"];
+    private cellIconsCache;
+    handle(cmd: Command): void;
+    getCellIcons(position: CellPosition): GridIcon[];
+    getCellIconRect(icon: GridIcon, cellRect: Rect): Rect;
+    private getIconHorizontalPosition;
+    private computeCellIcons;
+    doesCellHaveGridIcon(position: CellPosition): boolean;
+}

package/dist/types/plugins/ui_core_views/custom_colors.d.ts

@@ -0,0 +1,29 @@
+import { Command } from "../../types/commands";
+import { Color, Immutable } from "../../types/misc";
+import { CoreViewPlugin, CoreViewPluginConfig } from "../core_view_plugin";
+interface CustomColorState {
+    readonly customColors: Immutable<Record<Color, true>>;
+    readonly shouldUpdateColors: boolean;
+}
+/**
+ * CustomColors plugin
+ * This plugins aims to compute and keep to custom colors used in the
+ * current spreadsheet
+ */
+export declare class CustomColorsPlugin extends CoreViewPlugin<CustomColorState> {
+    private readonly customColors;
+    private readonly shouldUpdateColors;
+    static getters: readonly ["getCustomColors"];
+    constructor(config: CoreViewPluginConfig);
+    handle(cmd: Command): void;
+    finalize(): void;
+    getCustomColors(): Color[];
+    private computeCustomColors;
+    private getColorsFromCells;
+    private getFormattingColors;
+    private getChartColors;
+    private getTableColors;
+    private getTableStyleElementColors;
+    private tryToAddColors;
+}
+export {};

package/dist/types/plugins/ui_core_views/dynamic_tables.d.ts

@@ -0,0 +1,38 @@
+import { CellPosition, FilterId, UID, Zone } from "../..";
+import { Command } from "../../types/commands";
+import { Filter, Table } from "../../types/table";
+import { ExcelWorkbookData } from "../../types/workbook_data";
+import { CoreViewPlugin } from "../core_view_plugin";
+export declare class DynamicTablesPlugin extends CoreViewPlugin {
+    static getters: readonly ["canCreateDynamicTableOnZones", "doesZonesContainFilter", "getFilter", "getFilters", "getTable", "getTables", "getTablesOverlappingZones", "getFilterId", "getFilterHeaders", "isFilterHeader"];
+    tables: Record<UID, Table[]>;
+    handle(cmd: Command): void;
+    finalize(): void;
+    private computeTables;
+    private getDynamicTables;
+    private getTablesFromPivots;
+    private getTableConfigFromPivotStyle;
+    getFilters(sheetId: UID): Filter[];
+    getTables(sheetId: UID): Table[];
+    getFilter(position: CellPosition): Filter | undefined;
+    getFilterId(position: CellPosition): FilterId | undefined;
+    getTable({ sheetId, col, row }: CellPosition): Table | undefined;
+    getTablesOverlappingZones(sheetId: UID, zones: Zone[]): Table[];
+    doesZonesContainFilter(sheetId: UID, zones: Zone[]): boolean;
+    getFilterHeaders(sheetId: UID): CellPosition[];
+    isFilterHeader({ sheetId, col, row }: CellPosition): boolean;
+    /**
+     * Check if we can create a dynamic table on the given zones.
+     * - The zones must be continuous
+     * - The union of the zones must be either:
+     *    - A single cell that contains an array formula
+     *    - All the spread cells of a single array formula
+     */
+    canCreateDynamicTableOnZones(sheetId: UID, zones: Zone[]): boolean;
+    private coreTableToTable;
+    private getDynamicTableFilters;
+    private getDynamicTableFilterId;
+    /** Check if a table contains array formula, as we cannot have them in a table in Excel */
+    private isTableExcelExportable;
+    exportForExcel(data: ExcelWorkbookData): void;
+}

package/dist/types/plugins/ui_core_views/evaluation_chart.d.ts

@@ -0,0 +1,26 @@
+import { ChartRuntime } from "../../types/chart";
+import { CoreViewCommand } from "../../types/commands";
+import { Color, UID } from "../../types/misc";
+import { Range } from "../../types/range";
+import { ExcelWorkbookData } from "../../types/workbook_data";
+import { CoreViewPlugin } from "../core_view_plugin";
+interface EvaluationChartStyle {
+    background: Color;
+    fontColor: Color;
+}
+interface EvaluationChartState {
+    charts: Record<UID, ChartRuntime | undefined>;
+}
+export declare class EvaluationChartPlugin extends CoreViewPlugin<EvaluationChartState> {
+    static getters: readonly ["getChartRuntime", "getStyleOfSingleCellChart"];
+    charts: Record<UID, ChartRuntime | undefined>;
+    handle(cmd: CoreViewCommand): void;
+    getChartRuntime(chartId: UID): ChartRuntime;
+    /**
+     * Get the background and textColor of a chart based on the color of the first cell of the main range of the chart.
+     */
+    getStyleOfSingleCellChart(chartBackground: Color | undefined, mainRange: Range | undefined): EvaluationChartStyle;
+    exportForExcel(data: ExcelWorkbookData): Promise<void>;
+    private createRuntimeChart;
+}
+export {};

package/dist/types/plugins/ui_core_views/evaluation_conditional_format.d.ts

@@ -0,0 +1,36 @@
+import { CoreViewCommand } from "../../types/commands";
+import { CellPosition, DataBarFill, Style } from "../../types/misc";
+import { CoreViewPlugin } from "../core_view_plugin";
+export declare class EvaluationConditionalFormatPlugin extends CoreViewPlugin {
+    static getters: readonly ["getConditionalIcon", "getCellConditionalFormatStyle", "getConditionalDataBar"];
+    private isStale;
+    private computedStyles;
+    private computedIcons;
+    private computedDataBars;
+    handle(cmd: CoreViewCommand): void;
+    finalize(): void;
+    getCellConditionalFormatStyle(position: CellPosition): Style | undefined;
+    getConditionalIcon({ sheetId, col, row }: CellPosition): string | undefined;
+    getConditionalDataBar({ sheetId, col, row }: CellPosition): DataBarFill | undefined;
+    /**
+     * Compute the styles according to the conditional formatting.
+     * This computation must happen after the cell values are computed if they change
+     *
+     * This result of the computation will be in the state.cell[XC].conditionalStyle and will be the union of all the style
+     * properties of the rules applied (in order).
+     * So if a cell has multiple conditional formatting applied to it, and each affect a different value of the style,
+     * the resulting style will have the combination of all those values.
+     * If multiple conditional formatting use the same style value, they will be applied in order so that the last applied wins
+     */
+    private getComputedStyles;
+    private getComputedIcons;
+    private getComputedDataBars;
+    private parsePoint;
+    /** Compute the CF icons for the given range and CF rule, and apply in in the given computedIcons object */
+    private applyIcon;
+    private computeIcon;
+    private applyDataBar;
+    /** Compute the color scale for the given range and CF rule, and apply in in the given computedStyle object */
+    private applyColorScale;
+    private getRuleResultForTarget;
+}

package/dist/types/plugins/ui_core_views/evaluation_data_validation.d.ts

@@ -0,0 +1,54 @@
+import { CellValue } from "../../types/cells";
+import { CoreViewCommand } from "../../types/commands";
+import { DataValidationCriterionType, DataValidationRule } from "../../types/data_validation";
+import { GenericCriterion } from "../../types/generic_criterion";
+import { CellPosition, HeaderIndex, Lazy, Style, UID } from "../../types/misc";
+import { CoreViewPlugin } from "../core_view_plugin";
+interface InvalidValidationResult {
+    readonly isValid: false;
+    readonly rule: DataValidationRule;
+    readonly error: string;
+}
+interface ValidValidationResult {
+    readonly isValid: true;
+}
+type ValidationResult = ValidValidationResult | InvalidValidationResult;
+type SheetValidationResult = {
+    [col: HeaderIndex]: Array<Lazy<ValidationResult>>;
+};
+export declare class EvaluationDataValidationPlugin extends CoreViewPlugin {
+    static getters: readonly ["getDataValidationInvalidCriterionValueMessage", "getInvalidDataValidationMessage", "getValidationResultForCellValue", "getDataValidationRangeValues", "isCellValidCheckbox", "getDataValidationCellStyle", "getDataValidationChipStyle", "isDataValidationInvalid"];
+    validationResults: Record<UID, SheetValidationResult>;
+    criterionPreComputeResult: Record<UID, {
+        [dvRuleId: UID]: unknown;
+    }>;
+    handle(cmd: CoreViewCommand): void;
+    isDataValidationInvalid(cellPosition: CellPosition): boolean;
+    getDataValidationCellStyle(position: CellPosition): Style | undefined;
+    getDataValidationChipStyle(position: CellPosition): Style | undefined;
+    getInvalidDataValidationMessage(cellPosition: CellPosition): string | undefined;
+    /**
+     * Check if the value is valid for the given criterion, and return an error message if not.
+     *
+     * The value must be canonicalized.
+     */
+    getDataValidationInvalidCriterionValueMessage(criterionType: DataValidationCriterionType, value: string): string | undefined;
+    getDataValidationRangeValues(sheetId: UID, criterion: GenericCriterion): {
+        value: string;
+        label: string;
+    }[];
+    isCellValidCheckbox(cellPosition: CellPosition): boolean;
+    /** Get the validation result if the cell on the given position had the given value */
+    getValidationResultForCellValue(cellValue: CellValue, cellPosition: CellPosition): ValidationResult;
+    private hasChip;
+    private getDataValidationStyle;
+    private getValueColor;
+    private isValidFormula;
+    private getValidationResultForCell;
+    private computeSheetValidationResults;
+    private getRuleErrorForCellValue;
+    /** Get the offset of the cell inside the ranges of the rule. Throws an error if the cell isn't inside the rule. */
+    private getCellOffsetInRule;
+    private getEvaluatedCriterionValues;
+}
+export {};

package/dist/types/plugins/ui_core_views/formula_tracker.d.ts

@@ -0,0 +1,8 @@
+import { Command } from "../../types/commands";
+import { CoreViewPlugin } from "../core_view_plugin";
+export declare class FormulaTrackerPlugin extends CoreViewPlugin {
+    static getters: readonly ["getCellsWithTrackedFormula"];
+    private trackedCells;
+    handle(cmd: Command): void;
+    getCellsWithTrackedFormula(formula: string): number[];
+}

package/dist/types/plugins/ui_core_views/header_sizes_ui.d.ts

@@ -0,0 +1,36 @@
+import { Canvas2DContext } from "../../types/canvas";
+import { Command } from "../../types/commands";
+import { AnchorOffset } from "../../types/figure";
+import { CellPosition, Dimension, HeaderIndex, Immutable, Pixel, UID } from "../../types/misc";
+import { CoreViewPlugin } from "../core_view_plugin";
+interface HeaderSizeState {
+    tallestCellInRow: Immutable<Record<UID, Array<CellWithSize | undefined>>>;
+}
+interface CellWithSize {
+    cell: CellPosition;
+    size: Pixel;
+}
+export declare class HeaderSizeUIPlugin extends CoreViewPlugin<HeaderSizeState> implements HeaderSizeState {
+    static getters: readonly ["getRowSize", "getHeaderSize", "getMaxAnchorOffset"];
+    readonly tallestCellInRow: Immutable<Record<UID, Array<CellWithSize | undefined>>>;
+    ctx: Canvas2DContext;
+    beforeHandle(cmd: Command): void;
+    handle(cmd: Command): void;
+    getRowSize(sheetId: UID, row: HeaderIndex): Pixel;
+    getMaxAnchorOffset(sheetId: UID, height: Pixel, width: Pixel): AnchorOffset;
+    getHeaderSize(sheetId: UID, dimension: Dimension, index: HeaderIndex): Pixel;
+    private updateRowSizeForZoneChange;
+    private updateRowSizeForCellChange;
+    private initializeSheet;
+    /**
+     * Return the height the cell should have in the sheet, which is either DEFAULT_CELL_HEIGHT if the cell is in a multi-row
+     * merge, or the height of the cell computed based on its style/content.
+     */
+    private getCellHeight;
+    private isInMultiRowMerge;
+    /**
+     * Get the tallest cell of a row and its size.
+     */
+    private getRowTallestCell;
+}
+export {};

package/dist/types/plugins/ui_core_views/pivot_ui.d.ts

@@ -0,0 +1,62 @@
+import { CompiledFormula } from "../../formulas/compiler";
+import { Command } from "../../types/commands";
+import { CellPosition, SortDirection, UID } from "../../types/misc";
+import { PivotCoreMeasure, PivotStyle, PivotTableCell } from "../../types/pivot";
+import { Pivot } from "../../types/pivot_runtime";
+import { CoreViewPlugin, CoreViewPluginConfig } from "../core_view_plugin";
+export declare const UNDO_REDO_PIVOT_COMMANDS: string[];
+export declare class PivotUIPlugin extends CoreViewPlugin {
+    static getters: readonly ["getPivot", "getFirstPivotFunction", "getPivotCellSortDirection", "getPivotIdFromPosition", "getPivotCellFromPosition", "generateNewCalculatedMeasureName", "isPivotUnused", "isSpillPivotFormula", "getAllPivotArrayFormulas", "getPivotStyleAtPosition"];
+    private pivots;
+    private unusedPivotsInFormulas?;
+    private custom;
+    constructor(config: CoreViewPluginConfig);
+    beforeHandle(cmd: Command): void;
+    handle(cmd: Command): void;
+    /**
+     * Get the id of the pivot at the given position. Returns undefined if there
+     * is no pivot at this position
+     */
+    getPivotIdFromPosition(position: CellPosition): "" | UID | undefined;
+    isSpillPivotFormula(position: CellPosition): boolean;
+    getFirstPivotFunction(sheetId: UID, compiledFormula: CompiledFormula): {
+        functionName: string;
+        args: (import("../..").CellValue | import("../..").Matrix<import("../..").CellValue> | undefined)[];
+    } | undefined;
+    /**
+     * Returns the domain args of a pivot formula from a position.
+     * For all those formulas:
+     *
+     * =PIVOT.VALUE(1,"expected_revenue","stage_id",2,"city","Brussels")
+     * =PIVOT.HEADER(1,"stage_id",2,"city","Brussels")
+     * =PIVOT.HEADER(1,"stage_id",2,"city","Brussels","measure","expected_revenue")
+     *
+     * the result is the same: ["stage_id", 2, "city", "Brussels"]
+     *
+     * If the cell is the result of PIVOT, the result is the domain of the cell
+     * as if it was the individual pivot formula
+     */
+    getPivotCellFromPosition(position: CellPosition): PivotTableCell;
+    generateNewCalculatedMeasureName(measures: PivotCoreMeasure[]): string;
+    getPivot(pivotId: UID): Pivot<import("../..").PivotRuntimeDefinition>;
+    isPivotUnused(pivotId: UID): boolean;
+    getPivotCellSortDirection(position: CellPosition): SortDirection | "none" | undefined;
+    /**
+     * Refresh the cache of a pivot
+     */
+    private refreshPivot;
+    setupPivot(pivotId: UID, { recreate }?: {
+        recreate: boolean;
+    }): void;
+    private _getUnusedPivotsInFormulas;
+    getAllPivotArrayFormulas(): {
+        position: CellPosition;
+        pivotStyle: Required<PivotStyle>;
+        pivotId: UID;
+    }[];
+    getPivotStyleAtPosition(position: CellPosition): {
+        pivotStyle: Required<PivotStyle>;
+        pivotId: UID;
+    } | undefined;
+    private isMainFunctionPivotSpreadFunction;
+}

package/dist/types/plugins/ui_feature/autofill.d.ts

@@ -0,0 +1,63 @@
+import { Tooltip } from "../../types/autofill";
+import { Command, CommandResult, LocalCommand } from "../../types/commands";
+import { GridRenderingContext } from "../../types/rendering";
+import { UIPlugin } from "../ui_plugin";
+/**
+ * Autofill Plugin
+ *
+ */
+export declare class AutofillPlugin extends UIPlugin {
+    static layers: readonly ["Autofill"];
+    static getters: readonly ["getAutofillTooltip"];
+    private autofillZone;
+    private steps;
+    private lastCellSelected;
+    private direction;
+    private tooltip;
+    allowDispatch(cmd: LocalCommand): CommandResult;
+    handle(cmd: Command): void;
+    getAutofillTooltip(): Tooltip | undefined;
+    /**
+     * Autofill the autofillZone from the current selection
+     * @param apply Flag set to true to apply the autofill in the model. It's
+     *              useful to set it to false when we need to fill the tooltip
+     */
+    private autofill;
+    private collectBordersData;
+    private collectConditionalFormatsData;
+    private collectDataValidationsData;
+    private autofillCell;
+    private autofillBorders;
+    private autofillConditionalFormats;
+    private autofillDataValidations;
+    /**
+     * Select a cell which becomes the last cell of the autofillZone
+     */
+    private select;
+    /**
+     * Computes the autofillZone to autofill when the user double click on the
+     * autofiller
+     */
+    private autofillAuto;
+    private getAutofillAutoLastRow;
+    /**
+     * Generate the next cell
+     */
+    private computeNewCell;
+    /**
+     * Get the rule associated to the current cell
+     */
+    private getRule;
+    /**
+     * Create the generator to be able to autofill the next cells.
+     */
+    private createGenerator;
+    private saveZone;
+    /**
+     * Compute the direction of the autofill from the last selected zone and
+     * a given cell (col, row)
+     */
+    private getDirection;
+    private autofillMerge;
+    drawLayer(renderingContext: GridRenderingContext): void;
+}