@odoo/o-spreadsheet 17.0.85 → 17.0.96

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

@@ -0,0 +1,76 @@
+import { Command, GridRenderingContext, HeaderIndex, LAYERS } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export interface SearchOptions {
+    matchCase: boolean;
+    exactMatch: boolean;
+    searchFormulas: boolean;
+}
+interface SearchMatch {
+    selected: boolean;
+    col: HeaderIndex;
+    row: HeaderIndex;
+}
+/**
+ * Find and Replace Plugin
+ *
+ * This plugin is used in combination with the find_and_replace sidePanel
+ * It is used to 'highlight' cells that match an input string according to
+ * the given searchOptions. The second part of this plugin makes it possible
+ * (again with the find_and_replace sidePanel), to replace the values that match
+ * the search with a new value.
+ */
+export declare class FindAndReplacePlugin extends UIPlugin {
+    static layers: LAYERS[];
+    static getters: readonly ["getSearchMatches", "getCurrentSelectedMatchIndex"];
+    private searchMatches;
+    private selectedMatchIndex;
+    private currentSearchRegex;
+    private searchOptions;
+    private toSearch;
+    private isSearchDirty;
+    handle(cmd: Command): void;
+    finalize(): void;
+    getSearchMatches(): SearchMatch[];
+    getCurrentSelectedMatchIndex(): number | null;
+    /**
+     * Will update the current searchOptions and accordingly update the regex.
+     * It will then search for matches using the regex and store them.
+     */
+    private updateSearch;
+    /**
+     * refresh the matches according to the current search options
+     */
+    private refreshSearch;
+    /**
+     * Updates the regex based on the current searchOptions and
+     * the value toSearch
+     */
+    private updateRegex;
+    /**
+     * Find matches using the current regex
+     */
+    private findMatches;
+    private sortByRowThenColumn;
+    /**
+     * Changes the selected search cell. Given a direction it will
+     * Change the selection to the previous, current or nextCell,
+     * if it exists otherwise it will set the selectedMatchIndex to null.
+     * It will also reset the index to 0 if the search has changed.
+     * It is also used to keep coherence between the selected searchMatch
+     * and selectedMatchIndex.
+     */
+    private selectNextCell;
+    private clearSearch;
+    private replaceMatch;
+    /**
+     * Replace the value of the currently selected match
+     */
+    private replace;
+    /**
+     * Apply the replace function to all the matches one time.
+     */
+    private replaceAll;
+    private getSearchableString;
+    drawGrid(renderingContext: GridRenderingContext): void;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { Command } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class FormatPlugin extends UIPlugin {
+    handle(cmd: Command): void;
+    /**
+     * This function allows to adjust the quantity of decimal places after a decimal
+     * point on cells containing number value. It does this by changing the cells
+     * format. Values aren't modified.
+     *
+     * The change of the decimal quantity is done one by one, the sign of the step
+     * variable indicates whether we are increasing or decreasing.
+     *
+     * If several cells are in the zone, each cell's format will be individually
+     * evaluated and updated with the number type.
+     */
+    private setDecimal;
+    /**
+     * Take a range of cells and return the format of the first cell containing a
+     * number value. Returns a default format if the cell hasn't format. Returns
+     * undefined if no number value in the range.
+     */
+    private getCellNumberFormat;
+}

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

@@ -0,0 +1,21 @@
+import { CellPosition, Dimension, ExcelWorkbookData, HeaderIndex, UID } from "../../types";
+import { UIPlugin } from "../ui_plugin";
+export declare class HeaderVisibilityUIPlugin extends UIPlugin {
+    static getters: readonly ["getNextVisibleCellPosition", "findVisibleHeader", "findLastVisibleColRowIndex", "findFirstVisibleColRowIndex", "isRowHidden", "isColHidden", "isHeaderHidden"];
+    isRowHidden(sheetId: UID, index: number): boolean;
+    isColHidden(sheetId: UID, index: number): boolean;
+    isHeaderHidden(sheetId: UID, dimension: Dimension, index: number): boolean;
+    getNextVisibleCellPosition({ sheetId, col, row }: CellPosition): CellPosition;
+    /**
+     * Find the first visible header in the range [`from` => `to`].
+     *
+     * Both `from` and `to` are inclusive.
+     */
+    findVisibleHeader(sheetId: UID, dimension: Dimension, from: number, to: number): number | undefined;
+    findLastVisibleColRowIndex(sheetId: UID, dimension: Dimension, { last, first }: {
+        first: HeaderIndex;
+        last: HeaderIndex;
+    }): HeaderIndex;
+    findFirstVisibleColRowIndex(sheetId: UID, dimension: Dimension): number | undefined;
+    exportForExcel(data: ExcelWorkbookData): void;
+}

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

@@ -0,0 +1,12 @@
+import { GridRenderingContext, Highlight, LAYERS } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+/**
+ * HighlightPlugin
+ */
+export declare class HighlightPlugin extends UIPlugin {
+    static layers: LAYERS[];
+    static getters: readonly ["getHighlights"];
+    getHighlights(): Highlight[];
+    private prepareHighlights;
+    drawGrid(renderingContext: GridRenderingContext): void;
+}

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

@@ -0,0 +1,15 @@
+export * from "./autofill";
+export * from "./automatic_sum";
+export * from "./cell_popovers";
+export * from "./collaborative";
+export * from "./data_cleanup";
+export * from "./find_and_replace";
+export * from "./format";
+export * from "./header_visibility_ui";
+export * from "./highlight";
+export * from "./renderer";
+export * from "./selection_input";
+export * from "./selection_inputs_manager";
+export * from "./sort";
+export * from "./ui_options";
+export * from "./ui_sheet";

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

@@ -0,0 +1,36 @@
+import { Command, CommandResult } from "../../types";
+import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+/**
+ * Local History
+ *
+ * The local history is responsible of tracking the locally state updates
+ * It maintains the local undo and redo stack to allow to undo/redo only local
+ * changes
+ */
+export declare class HistoryPlugin extends UIPlugin {
+    static getters: readonly ["canUndo", "canRedo"];
+    /**
+     * Ids of the revisions which can be undone
+     */
+    private undoStack;
+    /**
+     * Ids of the revisions which can be redone
+     */
+    private redoStack;
+    private session;
+    constructor(config: UIPluginConfig);
+    allowDispatch(cmd: Command): CommandResult;
+    handle(cmd: Command): void;
+    finalize(): void;
+    private requestHistoryChange;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    private onNewLocalStateUpdate;
+    /**
+     * Fetch the last revision which is not empty and not a repeated command
+     *
+     * Ignore repeated commands (REQUEST_REDO command as root command)
+     * Ignore standard undo/redo revisions (that are empty)
+     */
+    private getPossibleRevisionToRepeat;
+}

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

@@ -0,0 +1,45 @@
+import { GridRenderingContext, HeaderDimensions, HeaderIndex, LAYERS, UID } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare const CELL_BACKGROUND_GRIDLINE_STROKE_STYLE = "#111";
+export declare class RendererPlugin extends UIPlugin {
+    static layers: LAYERS[];
+    static getters: readonly ["getColDimensionsInViewport", "getRowDimensionsInViewport"];
+    private boxes;
+    /**
+     * Returns the size, start and end coordinates of a column relative to the left
+     * column of the current viewport
+     */
+    getColDimensionsInViewport(sheetId: UID, col: HeaderIndex): HeaderDimensions;
+    /**
+     * Returns the size, start and end coordinates of a row relative to the top row
+     * of the current viewport
+     */
+    getRowDimensionsInViewport(sheetId: UID, row: HeaderIndex): HeaderDimensions;
+    /**
+     * Get the offset of a header (see getColRowOffsetInViewport), adjusted with the header
+     * size (HEADER_HEIGHT and HEADER_WIDTH)
+     */
+    private getHeaderOffset;
+    drawGrid(renderingContext: GridRenderingContext, layer: LAYERS): void;
+    private drawGlobalBackground;
+    private drawBackground;
+    private drawCellBackground;
+    private drawOverflowingCellBackground;
+    private drawBorders;
+    private drawTexts;
+    private drawIcon;
+    /** Compute the vertical start point from which a text line should be draw.
+     *
+     * Note that in case the cell does not have enough spaces to display its text lines,
+     * (wrapping cell case) then the vertical align should be at the top.
+     * */
+    private computeTextYCoordinate;
+    private drawHeaders;
+    private drawFrozenPanesHeaders;
+    private drawFrozenPanes;
+    private findNextEmptyCol;
+    private findPreviousEmptyCol;
+    private computeCellAlignment;
+    private createZoneBox;
+    private getGridBoxes;
+}

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

@@ -0,0 +1,67 @@
+import { StreamCallbacks } from "../../selection_stream/event_stream";
+import { SelectionEvent } from "../../types/event_stream";
+import { Color, Command, Highlight, LAYERS } from "../../types/index";
+import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+export interface RangeInputValue {
+    id: number;
+    xc: string;
+    color: Color;
+}
+/**
+ * Selection input Plugin
+ *
+ * The SelectionInput component input and output are both arrays of strings, but
+ * it requires an intermediary internal state to work.
+ * This plugin handles this internal state.
+ */
+export declare class SelectionInputPlugin extends UIPlugin implements StreamCallbacks<SelectionEvent> {
+    readonly inputHasSingleRange: boolean;
+    static layers: LAYERS[];
+    static getters: never[];
+    ranges: RangeInputValue[];
+    focusedRangeIndex: number | null;
+    private inputSheetId;
+    constructor(config: UIPluginConfig, initialRanges: string[], inputHasSingleRange: boolean);
+    handleEvent(event: SelectionEvent): void;
+    handle(cmd: Command): void;
+    getSelectionInputValue(): string[];
+    getSelectionInputHighlights(): Highlight[];
+    /**
+     * Focus a given range or remove the focus.
+     */
+    private focus;
+    private focusLast;
+    private unfocus;
+    private setContent;
+    /**
+     * Insert new inputs after the given index.
+     */
+    private insertNewRange;
+    /**
+     * Set a new value in a given range input. If more than one value is provided,
+     * new inputs will be added.
+     */
+    private setRange;
+    private removeRange;
+    /**
+     * Convert highlights input format to the command format.
+     * The first xc in the input range will keep its color.
+     * Invalid ranges and ranges from other sheets than the active sheets
+     * are ignored.
+     */
+    private inputToHighlights;
+    private cleanInputs;
+    /**
+     * Check if a cell or range reference should be highlighted.
+     * It should be highlighted if it references the current active sheet.
+     * Note that if no sheet name is given in the reference ("A1"), it refers to the
+     * active sheet when the selection input was enabled which might be different from
+     * the current active sheet.
+     */
+    private shouldBeHighlighted;
+    /**
+     * Return the index of a range given its id
+     * or `null` if the range is not found.
+     */
+    getIndex(rangeId: number | null): number | null;
+}

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

@@ -0,0 +1,33 @@
+import { Command, CommandResult, Highlight, LAYERS, LocalCommand, UID } from "../../types/index";
+import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+import { RangeInputValue, SelectionInputPlugin } from "./selection_input";
+/**
+ * Selection input Plugin
+ *
+ * The SelectionInput component input and output are both arrays of strings, but
+ * it requires an intermediary internal state to work.
+ * This plugin handles this internal state.
+ */
+export declare class SelectionInputsManagerPlugin extends UIPlugin {
+    private config;
+    static layers: LAYERS[];
+    static getters: readonly ["getSelectionInput", "getSelectionInputValue", "isRangeValid", "getSelectionInputHighlights"];
+    private inputs;
+    private focusedInputId;
+    get currentInput(): SelectionInputPlugin | null;
+    constructor(config: UIPluginConfig);
+    allowDispatch(cmd: LocalCommand): CommandResult;
+    handle(cmd: Command): void;
+    /**
+     * Return a list of all valid XCs.
+     * e.g. ["A1", "Sheet2!B3", "E12"]
+     */
+    getSelectionInput(id: UID): (RangeInputValue & {
+        isFocused: boolean;
+    })[];
+    isRangeValid(reference: string): boolean;
+    getSelectionInputValue(id: UID): string[];
+    getSelectionInputHighlights(): Highlight[];
+    private initInput;
+    private unfocus;
+}

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

@@ -0,0 +1,75 @@
+import { Command, CommandResult, LocalCommand, UID, Zone } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class SortPlugin extends UIPlugin {
+    static getters: readonly ["getContiguousZone"];
+    allowDispatch(cmd: LocalCommand): CommandResult | CommandResult[];
+    handle(cmd: Command): void;
+    private checkMerge;
+    private checkMergeSizes;
+    /**
+     * safe-version of expandZone to make sure we don't get out of the grid
+     */
+    private expand;
+    /**
+     * verifies the presence of at least one non-empty cell in the given zone
+     */
+    private checkExpandedValues;
+    /**
+     * This function will expand the provided zone in directions (top, bottom, left, right) for which there
+     * are non-null cells on the external boundary of the zone in the given direction.
+     *
+     * Example:
+     *          A     B     C     D     E
+     *         ___   ___   ___   ___   ___
+     *    1  |     |  D  |     |     |     |
+     *         ___   ___   ___   ___   ___
+     *    2  |  5  |     |  1  |  D  |     |
+     *         ___   ___   ___   ___   ___
+     *    3  |     |     |  A  |  X  |     |
+     *         ___   ___   ___   ___   ___
+     *    4  |     |     |     |     |     |
+     *         ___   ___   ___   ___   ___
+     *
+     *  Let's consider a provided zone corresponding to (C2:D3) - (left:2, right: 3, top:1, bottom:2)
+     *  - the top external boundary is (B1:E1)
+     *    Since we have B1='D' != "", we expand to the top: => (C1:D3)
+     *    The top boundary having reached the top of the grid, we cannot expand in that direction anymore
+     *
+     *  - the left boundary is (B1:B4)
+     *    since we have B1 again, we expand to the left  => (B1:D3)
+     *
+     *  - the right and bottom boundaries are a dead end for now as (E1:E4) and (A4:E4) are empty.
+     *
+     *  - the left boundary is now (A1:A4)
+     *    Since we have A2=5 != "", we can therefore expand to the left => (A1:D3)
+     *
+     *  This will be the final zone as left and top have reached the boundaries of the grid and
+     *  the other boundaries (E1:E4) and (A4:E4) are empty.
+     *
+     * @param sheetId UID of concerned sheet
+     * @param zone Zone
+     *
+     */
+    getContiguousZone(sheetId: UID, zone: Zone): Zone;
+    /**
+     * This function evaluates if the top row of a provided zone can be considered as a `header`
+     * by checking the following criteria:
+     * * If the left-most column top row value (topLeft) is empty, we ignore it while evaluating the criteria.
+     * 1 - Apart from the left-most column, every element of the top row must be non-empty, i.e. a cell should be present in the sheet.
+     * 2 - There should be at least one column in which the type (CellValueType) of the rop row cell differs from the type of the cell below.
+     *  For the second criteria, we ignore columns on which the cell below is empty.
+     *
+     */
+    private hasHeader;
+    private sortZone;
+    /**
+     * Return the distances between main merge cells in the zone.
+     * (1 if there are no merges).
+     * Note: it is assumed all merges are the same in the zone.
+     */
+    private mainCellsSteps;
+    /**
+     * Return a 2D array of cells in the zone (main merge cells if there are merges)
+     */
+    private mainCells;
+}

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

@@ -0,0 +1,21 @@
+import { Command, CommandResult } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class SplitToColumnsPlugin extends UIPlugin {
+    static getters: readonly ["getAutomaticSeparator"];
+    allowDispatch(cmd: Command): CommandResult | CommandResult[];
+    handle(cmd: Command): void;
+    getAutomaticSeparator(): string;
+    private getAutoSeparatorForString;
+    private splitIntoColumns;
+    private getSplittedCols;
+    private splitAndRemoveTrailingEmpty;
+    private willSplittedColsOverwriteContent;
+    private removeMergesInSplitZone;
+    private addColsToAvoidCollisions;
+    private getColsToAddToAvoidCollision;
+    private addColumnsToNotOverflowSheet;
+    private checkSingleColSelected;
+    private checkNonEmptySelector;
+    private checkNotOverwritingContent;
+    private checkSeparatorInSelection;
+}

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

@@ -0,0 +1,8 @@
+import { Command } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class UIOptionsPlugin extends UIPlugin {
+    static getters: readonly ["shouldShowFormulas"];
+    private showFormulas;
+    handle(cmd: Command): void;
+    shouldShowFormulas(): boolean;
+}

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

@@ -0,0 +1,30 @@
+import { Command, CommandResult, LocalCommand } from "../../types";
+import { CellPosition, Pixel, Style } from "../../types/misc";
+import { UIPlugin } from "../ui_plugin";
+export declare class SheetUIPlugin extends UIPlugin {
+    static getters: readonly ["doesCellHaveGridIcon", "getCellWidth", "getTextWidth", "getCellText", "getCellMultiLineText"];
+    private ctx;
+    allowDispatch(cmd: LocalCommand): CommandResult | CommandResult[];
+    handle(cmd: Command): void;
+    getCellWidth(position: CellPosition): number;
+    getTextWidth(text: string, style: Style): Pixel;
+    getCellText(position: CellPosition, showFormula?: boolean): string;
+    /**
+     * Return the text of a cell, split in multiple lines if needed. The text will be split in multiple
+     * line if it contains NEWLINE characters, or if it's longer than the given width.
+     */
+    getCellMultiLineText(position: CellPosition, width: number | undefined): string[];
+    doesCellHaveGridIcon(position: CellPosition): boolean;
+    private getColMaxWidth;
+    /**
+     * Check that any "sheetId" in the command matches an existing
+     * sheet.
+     */
+    private checkSheetExists;
+    /**
+     * Check if zones in the command are well formed and
+     * not outside the sheet.
+     */
+    private checkZonesAreInSheet;
+    private autoResizeRows;
+}

package/dist/types/plugins/ui_plugin.d.ts

@@ -0,0 +1,36 @@
+import { Session } from "../collaborative/session";
+import { ModelConfig } from "../model";
+import { SelectionStreamProcessor } from "../selection_stream/selection_stream_processor";
+import { StateObserver } from "../state_observer";
+import { ClientPosition, Command, CommandDispatcher, Format, Getters, GridRenderingContext, LAYERS } from "../types/index";
+import { BasePlugin } from "./base_plugin";
+type UIActions = Pick<ModelConfig, "notifyUI" | "raiseBlockingErrorUI">;
+export interface UIPluginConfig {
+    readonly getters: Getters;
+    readonly stateObserver: StateObserver;
+    readonly dispatch: CommandDispatcher["dispatch"];
+    readonly selection: SelectionStreamProcessor;
+    readonly moveClient: (position: ClientPosition) => void;
+    readonly uiActions: UIActions;
+    readonly custom: ModelConfig["custom"];
+    readonly session: Session;
+    readonly defaultCurrencyFormat?: Format;
+}
+export interface UIPluginConstructor {
+    new (config: UIPluginConfig): UIPlugin;
+    layers: LAYERS[];
+    getters: readonly string[];
+}
+/**
+ * UI plugins handle any transient data required to display a spreadsheet.
+ * They can draw on the grid canvas.
+ */
+export declare class UIPlugin<State = any> extends BasePlugin<State, Command> {
+    static layers: LAYERS[];
+    protected getters: Getters;
+    protected ui: UIActions;
+    protected selection: SelectionStreamProcessor;
+    constructor({ getters, stateObserver, dispatch, uiActions, selection }: UIPluginConfig);
+    drawGrid(ctx: GridRenderingContext, layer: LAYERS): void;
+}
+export {};

package/dist/types/plugins/ui_stateful/clipboard.d.ts

@@ -0,0 +1,43 @@
+import { ClipboardContent } from "../../types/clipboard";
+import { Command, CommandResult, GridRenderingContext, LAYERS, LocalCommand } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+/**
+ * Clipboard Plugin
+ *
+ * This clipboard manages all cut/copy/paste interactions internal to the
+ * application, and with the OS clipboard as well.
+ */
+export declare class ClipboardPlugin extends UIPlugin {
+    static layers: LAYERS[];
+    static getters: readonly ["getClipboardContent", "getClipboardTextContent", "isCutOperation", "isPaintingFormat"];
+    private status;
+    private state?;
+    private lastPasteState?;
+    private paintFormatStatus;
+    private originSheetId?;
+    allowDispatch(cmd: LocalCommand): CommandResult;
+    handle(cmd: Command): void;
+    /**
+     * Format the current clipboard to a string suitable for being pasted in other
+     * programs.
+     *
+     * - add a tab character between each consecutive cells
+     * - add a newline character between each line
+     *
+     * Note that it returns \t if the clipboard is empty. This is necessary for the
+     * clipboard copy event to add it as data, otherwise an empty string is not
+     * considered as a copy content.
+     */
+    getClipboardContent(): ClipboardContent;
+    getClipboardTextContent(): string;
+    isCutOperation(): boolean;
+    isPaintingFormat(): boolean;
+    private getDeleteCellsTargets;
+    private getInsertCellsTargets;
+    private getClipboardStateForCopyCells;
+    /**
+     * Get the clipboard state from the given zones.
+     */
+    private getClipboardState;
+    drawGrid(renderingContext: GridRenderingContext): void;
+}

package/dist/types/plugins/ui_stateful/edition.d.ts

@@ -0,0 +1,117 @@
+import { EnrichedToken } from "../../formulas/index";
+import { CellPosition, Command, CommandResult, Highlight, LocalCommand, Range } from "../../types";
+import { UIPlugin } from "../ui_plugin";
+export type EditionMode = "editing" | "selecting" | "inactive";
+export interface ComposerSelection {
+    start: number;
+    end: number;
+}
+export declare class EditionPlugin extends UIPlugin {
+    static getters: readonly ["getEditionMode", "isSelectingForComposer", "showSelectionIndicator", "getCurrentContent", "getComposerSelection", "getCurrentTokens", "getTokenAtCursor", "getComposerHighlights", "getCurrentEditedCell", "getCycledReference", "getAutoCompleteDataValidationValues"];
+    private col;
+    private row;
+    private mode;
+    private sheetId;
+    private currentContent;
+    private currentTokens;
+    private selectionStart;
+    private selectionEnd;
+    private initialContent;
+    private colorIndexByRange;
+    allowDispatch(cmd: LocalCommand): CommandResult;
+    private handleEvent;
+    handle(cmd: Command): void;
+    getEditionMode(): EditionMode;
+    getCurrentContent(): string;
+    getComposerSelection(): ComposerSelection;
+    getCurrentEditedCell(): CellPosition;
+    isSelectingForComposer(): boolean;
+    showSelectionIndicator(): boolean;
+    getCurrentTokens(): EnrichedToken[];
+    /**
+     * Return the (enriched) token just before the cursor.
+     */
+    getTokenAtCursor(): EnrichedToken | undefined;
+    /**
+     * Return the cycled reference if any (A1 -> $A$1 -> A$1 -> $A1 -> A1)
+     */
+    getCycledReference(selection: {
+        start: number;
+        end: number;
+    }, content: string): {
+        content: string;
+        selection: {
+            start: number;
+            end: number;
+        };
+    } | undefined;
+    getInitialComposerContent(): string | undefined;
+    private cycleReferences;
+    private validateSelection;
+    private onColumnsRemoved;
+    private onRowsRemoved;
+    private onAddElements;
+    /**
+     * Enable the selecting mode
+     */
+    private startComposerRangeSelection;
+    /**
+     * start the edition of a cell
+     * @param str the key that is used to start the edition if it is a "content" key like a letter or number
+     * @param selection
+     * @private
+     */
+    private startEdition;
+    private stopEdition;
+    private getCurrentCanonicalContent;
+    private cancelEditionAndActivateSheet;
+    private getComposerContent;
+    private numberComposerContent;
+    private cancelEdition;
+    /**
+     * Reset the current content to the active cell content
+     */
+    private resetContent;
+    private setContent;
+    private insertSelectedRange;
+    /**
+     * Replace the current reference selected by the new one.
+     * */
+    private replaceSelectedRange;
+    /**
+     * Replace the reference of the old zone by the new one.
+     */
+    private updateComposerRange;
+    private getZoneReference;
+    private getRangeReference;
+    /**
+     * Replace the current selection by a new text.
+     * The cursor is then set at the end of the text.
+     */
+    private replaceSelection;
+    private replaceText;
+    /**
+     * Insert a text at the given position.
+     * The cursor is then set at the end of the text.
+     */
+    private insertText;
+    private updateRangeColor;
+    /**
+     * Highlight all ranges that can be found in the composer content.
+     */
+    getComposerHighlights(): Highlight[];
+    /**
+     * Return ranges currently referenced in the composer
+     */
+    getReferencedRanges(): Range[];
+    getAutoCompleteDataValidationValues(): string[];
+    /**
+     * Function used to determine when composer selection can start.
+     * Three conditions are necessary:
+     * - the previous token is among ["ARG_SEPARATOR", "LEFT_PAREN", "OPERATOR"], and is not a postfix unary operator
+     * - the next token is missing or is among ["ARG_SEPARATOR", "RIGHT_PAREN", "OPERATOR"]
+     * - Previous and next tokens can be separated by spaces
+     */
+    private canStartComposerRangeSelection;
+    private checkDataValidation;
+}