@odoo/o-spreadsheet 14.0.1 → 14.0.3

package/dist/o-spreadsheet.d.ts

@@ -0,0 +1,4119 @@
+import { Env } from '@odoo/owl/dist/types/component/component';
+import * as owl from '@odoo/owl';
+import { Component as Component$a } from '@odoo/owl';
+import { ChartConfiguration } from 'chart.js';
+
+/**
+ * Registry
+ *
+ * The Registry class is basically just a mapping from a string key to an object.
+ * It is really not much more than an object. It is however useful for the
+ * following reasons:
+ *
+ * 1. it let us react and execute code when someone add something to the registry
+ *   (for example, the FunctionRegistry subclass this for this purpose)
+ * 2. it throws an error when the get operation fails
+ * 3. it provides a chained API to add items to the registry.
+ */
+declare class Registry<T> {
+    content: {
+        [key: string]: T;
+    };
+    /**
+     * Add an item to the registry
+     *
+     * Note that this also returns the registry, so another add method call can
+     * be chained
+     */
+    add(key: string, value: T): Registry<T>;
+    /**
+     * Get an item from the registry
+     */
+    get(key: string): T;
+    /**
+     * Get a list of all elements in the registry
+     */
+    getAll(): T[];
+    /**
+     * Remove an item from the registry
+     */
+    remove(key: string): void;
+}
+
+declare type TranslationFunction = (string: string, ...values: string[] | [{
+    [key: string]: string;
+}]) => string;
+/***
+ * Allow to inject a translation function from outside o-spreadsheet.
+ * @param tfn the function that will do the translation
+ */
+declare function setTranslationMethod(tfn: TranslationFunction): void;
+
+declare type UID = string;
+interface Zone {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+declare type Align = "left" | "right" | "center" | undefined;
+interface Style {
+    bold?: boolean;
+    italic?: boolean;
+    strikethrough?: boolean;
+    align?: Align;
+    fillColor?: string;
+    textColor?: string;
+    fontSize?: number;
+}
+interface Sheet {
+    id: string;
+    name: string;
+    cells: {
+        [key: string]: Cell;
+    };
+    colNumber: number;
+    rowNumber: number;
+    merges: {
+        [key: number]: Merge;
+    };
+    mergeCellMap: {
+        [key: string]: number;
+    };
+    cols: Col[];
+    rows: Row[];
+}
+declare type BorderStyle = "thin" | "medium" | "thick" | "dashed" | "dotted" | "double";
+declare type BorderDescr = [BorderStyle, string];
+interface Border {
+    top?: BorderDescr;
+    left?: BorderDescr;
+    bottom?: BorderDescr;
+    right?: BorderDescr;
+}
+interface NewCell {
+    content?: string;
+    style?: number;
+    border?: number;
+    format?: string;
+}
+declare type ReferenceDenormalizer = (position: number, references: string[], sheetId: UID, functionName: string, paramNumber: number) => any | any[][];
+declare type EnsureRange = (position: number, references: string[], sheetId: UID) => any[][];
+declare type _CompiledFormula = (deps: Dependencies, sheetId: UID, refFn: ReferenceDenormalizer, range: EnsureRange, ctx: {}) => any;
+interface CompiledFormula extends _CompiledFormula {
+    async: boolean;
+}
+interface Cell extends NewCell {
+    col: number;
+    row: number;
+    xc: string;
+    error?: string;
+    pending?: boolean;
+    value: any;
+    formula?: {
+        text: string;
+        dependencies: Dependencies;
+        compiledFormula: CompiledFormula;
+    };
+    type: "formula" | "text" | "number" | "date";
+}
+interface Header {
+    start: number;
+    end: number;
+    name: string;
+    size: number;
+}
+interface Row extends Header {
+    cells: {
+        [col: number]: Cell;
+    };
+}
+declare type Col = Header;
+interface Merge extends Zone {
+    id: number;
+    topLeft: string;
+}
+interface Highlight {
+    zone: Zone;
+    sheet: string;
+    color: string | null;
+}
+declare type BorderCommand = "all" | "hv" | "h" | "v" | "external" | "left" | "top" | "right" | "bottom" | "clear";
+interface Workbook {
+    visibleSheets: string[];
+    sheets: {
+        [id: string]: Sheet;
+    };
+    activeSheet: Sheet;
+}
+declare const enum DIRECTION {
+    UP = 0,
+    DOWN = 1,
+    LEFT = 2,
+    RIGHT = 3
+}
+
+/**
+ * https://docs.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/025ea6e4-ad42-43ea-a016-16f4e4688ac8
+ */
+interface ConditionalFormat {
+    id: string;
+    rule: SingleColorRules | ColorScaleRule;
+    stopIfTrue?: boolean;
+    ranges: string[];
+}
+declare type SingleColorRules = CellIsRule | ExpressionRule | ContainsTextRule | NotContainsTextRule | BeginsWithRule | EndsWithRule | containsBlanksRule | notContainsBlanksRule | containsErrorsRule | notContainsErrorsRule | TimePeriodRule | AboveAverageRule | Top10Rule;
+interface SingleColorRule {
+    style: Style;
+}
+interface TextRule extends SingleColorRule {
+    text: string;
+}
+interface CellIsRule extends SingleColorRule {
+    type: "CellIsRule";
+    operator: ConditionalFormattingOperatorValues;
+    values: string[];
+}
+interface ExpressionRule extends SingleColorRule {
+    type: "ExpressionRule";
+}
+declare type ThresholdTypes = "value" | "number" | "percent" | "percentile" | "formula";
+declare type ColorScaleThreshold = {
+    color: number;
+    type: ThresholdTypes;
+    value?: number;
+};
+interface ColorScaleRule {
+    type: "ColorScaleRule";
+    minimum: ColorScaleThreshold;
+    maximum: ColorScaleThreshold;
+    midpoint?: ColorScaleThreshold;
+}
+interface ContainsTextRule extends TextRule {
+    type: "ContainsTextRule";
+}
+interface NotContainsTextRule extends TextRule {
+    type: "NotContainsTextRule";
+}
+interface BeginsWithRule extends TextRule {
+    type: "BeginsWithRule";
+}
+interface EndsWithRule extends TextRule {
+    type: "EndsWithRule";
+}
+interface containsBlanksRule extends TextRule {
+    type: "containsBlanksRule";
+}
+interface notContainsBlanksRule extends TextRule {
+    type: "notContainsBlanksRule";
+}
+interface containsErrorsRule extends SingleColorRule {
+    type: "containsErrorsRule";
+}
+interface notContainsErrorsRule extends SingleColorRule {
+    type: "notContainsErrorsRule";
+}
+interface TimePeriodRule extends SingleColorRule {
+    type: "TimePeriodRule";
+    timePeriod: string;
+}
+interface AboveAverageRule extends SingleColorRule {
+    type: "AboveAverageRule";
+    aboveAverage: boolean;
+    equalAverage: boolean;
+}
+interface Top10Rule extends SingleColorRule {
+    type: "Top10Rule";
+    percent: boolean;
+    bottom: boolean;
+    rank: number;
+}
+declare type ConditionalFormattingOperatorValues = "BeginsWith" | "Between" | "ContainsText" | "EndsWith" | "Equal" | "GreaterThan" | "GreaterThanOrEqual" | "LessThan" | "LessThanOrEqual" | "NotBetween" | "NotContains" | "NotEqual";
+
+declare type Dependencies = (string | number)[];
+/**
+ * Represents a string in which all range references, strings and numbers are
+ * replaced by dependencies references.
+ */
+declare type NormalizedFormulaString = string;
+declare type NormalizedFormula = {
+    text: NormalizedFormulaString;
+    dependencies: Dependencies;
+};
+interface CellData {
+    content?: string;
+    formula?: NormalizedFormula;
+    style?: number;
+    border?: number;
+    format?: string;
+}
+interface HeaderData {
+    size?: number;
+}
+interface Figure<T> {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    tag: string;
+    data: T;
+}
+interface SheetData {
+    id: string;
+    name: string;
+    colNumber: number;
+    rowNumber: number;
+    cells: {
+        [key: string]: CellData;
+    };
+    merges: string[];
+    figures: Figure<any>[];
+    cols: {
+        [key: number]: HeaderData;
+    };
+    rows: {
+        [key: number]: HeaderData;
+    };
+    conditionalFormats: ConditionalFormat[];
+}
+interface WorkbookData {
+    version: number;
+    sheets: SheetData[];
+    activeSheet: string;
+    styles: {
+        [key: number]: Style;
+    };
+    borders: {
+        [key: number]: Border;
+    };
+    entities: {
+        [key: string]: {
+            [key: string]: any;
+        };
+    };
+}
+
+/**
+ * An AutofillModifier describe the possible operations to apply to the
+ * content of a cell when we autofill this cell.
+ *
+ * It could be:
+ *  - Increment: increment the content by a given step
+ *  - Copy: simply copy the content
+ *  - Formula: update the formula, with the same behaviour than paste
+ */
+
+interface IncrementModifier {
+    type: "INCREMENT_MODIFIER";
+    increment: number;
+    current: number;
+}
+interface CopyModifier {
+    type: "COPY_MODIFIER";
+}
+interface FormulaModifier {
+    type: "FORMULA_MODIFIER";
+    increment: number;
+    current: number;
+}
+declare type AutofillModifier = IncrementModifier | CopyModifier | FormulaModifier;
+interface Tooltip {
+    props: any;
+    component?: any;
+}
+
+declare type ChartTypes = "line" | "bar" | "pie";
+interface CreateChartDefinition {
+    type: ChartTypes;
+    title: string;
+    labelRange: string;
+    dataSets: string[];
+    seriesHasTitle: boolean;
+}
+
+declare type ArgType = "ANY" | "BOOLEAN" | "NUMBER" | "STRING" | "DATE" | "RANGE" | "RANGE<BOOLEAN>" | "RANGE<NUMBER>" | "RANGE<STRING>" | "RANGE<DATE>";
+interface Arg {
+    repeating?: boolean;
+    optional?: boolean;
+    lazy?: boolean;
+    description: string;
+    name: string;
+    type: ArgType[];
+    default?: any;
+}
+interface FunctionDescription {
+    description: string;
+    compute: (this: EvalContext, ...args: any[]) => any;
+    async?: boolean;
+    category?: string;
+    args: Arg[];
+    returns: [ArgType];
+}
+interface EvalContext {
+    __lastFnCalled?: string;
+    [key: string]: any;
+}
+
+interface WorkbookHistory {
+    updateState(path: (string | number)[], val: any): void;
+    updateLocalState(path: (string | number)[], val: any): void;
+    updateCell<T extends keyof Cell>(cell: Cell, key: T, value: Cell[T]): void;
+    updateSheet(sheet: Sheet, path: (string | number)[], value: any): void;
+}
+declare type WorkbookHistoryNonLocal = Omit<WorkbookHistory, "updateLocalState">;
+declare class WHistory implements WorkbookHistoryNonLocal, CommandHandler {
+    private workbook;
+    private current;
+    private undoStack;
+    private redoStack;
+    constructor(workbook: Workbook);
+    canUndo(): boolean;
+    canRedo(): boolean;
+    allowDispatch(cmd: Command): CommandResult;
+    beforeHandle(cmd: Command): void;
+    handle(cmd: Command): void;
+    finalize(): void;
+    isActiveSheet(): boolean | null;
+    undo(): void;
+    redo(): void;
+    private applyChange;
+    updateStateFromRoot(root: any, path: (string | number)[], val: any): void;
+    updateState(path: (string | number)[], val: any): void;
+    updateCell<T extends keyof Cell>(cell: Cell, key: T, value: Cell[T]): void;
+    updateSheet(sheet: Sheet, path: (string | number)[], value: any): void;
+}
+
+/**
+ * Model
+ *
+ * The Model class is the owner of the state of the Spreadsheet. However, it
+ * has more a coordination role: it defers the actual state manipulation work to
+ * plugins.
+ *
+ * At creation, the Model instantiates all necessary plugins.  They each have
+ * a private state (for example, the Selection plugin has the current selection),
+ * and share a common core state (named workbook).
+ *
+ * State changes are then performed through commands.  Commands are dispatched
+ * to the model, which will then relay them to each plugins (and the history
+ * handler). Then, the model will trigger an 'update' event to notify whoever
+ * is concerned that the command was applied (if it was not cancelled).
+ *
+ * Also, the model has an unconventional responsibility: it actually renders the
+ * visible viewport on a canvas. This is because each plugins actually manage a
+ * specific concern about the content of the spreadsheet, and it is more natural
+ * if they are able to read data from their internal state to represent it on the
+ * screen.
+ *
+ * Note that the Model can be used in a standalone way to manipulate
+ * programmatically a spreadsheet.
+ */
+declare type Mode = "normal" | "headless" | "readonly";
+interface ModelConfig {
+    mode: Mode;
+    openSidePanel: (panel: string, panelProps?: any) => void;
+    notifyUser: (content: string) => any;
+    askConfirmation: (content: string, confirm: () => any, cancel?: () => any) => any;
+    editText: (title: string, placeholder: string, callback: (text: string | null) => any) => any;
+    evalContext: EvalContext;
+}
+declare class Model extends owl.core.EventBus implements CommandDispatcher {
+    /**
+     * Handlers are classes that can handle a command. In practice, this is
+     * basically a list of all plugins and the history manager (not a plugin)
+     */
+    private handlers;
+    /**
+     * A plugin can draw some contents on the canvas. But even better: it can do
+     * so multiple times.  The order of the render calls will determine a list of
+     * "layers" (i.e., earlier calls will be obviously drawn below later calls).
+     * This list simply keeps the renderers+layer information so the drawing code
+     * can just iterate on it
+     */
+    private renderers;
+    /**
+     * Internal status of the model. Important for command handling coordination
+     */
+    private status;
+    /**
+     * The config object contains some configuration flag and callbacks
+     */
+    private config;
+    /**
+     * The workbook is the core state, shared between all plugins.
+     */
+    private workbook;
+    /**
+     * Getters are the main way the rest of the UI read data from the model. Also,
+     * it is shared between all plugins, so they can also communicate with each
+     * other.
+     */
+    getters: Getters;
+    constructor(data?: any, config?: Partial<ModelConfig>);
+    destroy(): void;
+    /**
+     * Initialise and properly configure a plugin.
+     *
+     * This method is private for now, but if the need arise, there is no deep
+     * reason why the model could not add dynamically a plugin while it is running.
+     */
+    private setupPlugin;
+    /**
+     * The dispatch method is the only entry point to manipulate date in the model.
+     * This is through this method that commands are dispatched, most of the time
+     * recursively until no plugin want to react anymore.
+     *
+     * Small technical detail: it is defined as an arrow function.  There are two
+     * reasons for this:
+     * 1. this means that the dispatch method can be "detached" from the model,
+     *    which is done when it is put in the environment (see the Spreadsheet
+     *    component)
+     * 2. This allows us to define its type by using the interface CommandDispatcher
+     */
+    dispatch: CommandDispatcher["dispatch"];
+    /**
+     * When the Grid component is ready (= mounted), it has a reference to its
+     * canvas and need to draw the grid on it.  This is then done by calling this
+     * method, which will dispatch the call to all registered plugins.
+     *
+     * Note that nothing prevent multiple grid components from calling this method
+     * each, or one grid component calling it multiple times with a different
+     * context. This is probably the way we should do if we want to be able to
+     * freeze a part of the grid (so, we would need to render different zones)
+     */
+    drawGrid(context: GridRenderingContext): void;
+    /**
+     * As the name of this method strongly implies, it is useful when we need to
+     * export date out of the model.
+     */
+    exportData(): WorkbookData;
+}
+
+declare type UIActions = Pick<ModelConfig, "askConfirmation" | "notifyUser" | "openSidePanel" | "editText">;
+/**
+ * BasePlugin
+ *
+ * Since the spreadsheet internal state is quite complex, it is split into
+ * multiple parts, each managing a specific concern.
+ *
+ * This file introduce the BasePlugin, which is the common class that defines
+ * how each of these model sub parts should interact with each other.
+ */
+declare class BasePlugin implements CommandHandler {
+    static layers: LAYERS[];
+    static getters: string[];
+    static modes: Mode[];
+    protected workbook: Workbook;
+    protected getters: Getters;
+    protected history: WorkbookHistory;
+    protected dispatch: CommandDispatcher["dispatch"];
+    protected currentMode: Mode;
+    protected ui: UIActions;
+    constructor(workbook: Workbook, getters: Getters, history: WHistory, dispatch: CommandDispatcher["dispatch"], config: ModelConfig);
+    /**
+     * Before a command is accepted, the model will ask each plugin if the command
+     * is allowed.  If all of then return true, then we can proceed. Otherwise,
+     * the command is cancelled.
+     *
+     * There should not be any side effects in this method.
+     */
+    allowDispatch(command: Command): CommandResult;
+    /**
+     * This method is useful when a plugin need to perform some action before a
+     * command is handled in another plugin. This should only be used if it is not
+     * possible to do the work in the handle method.
+     */
+    beforeHandle(command: Command): void;
+    /**
+     * This is the standard place to handle any command. Most of the plugin
+     * command handling work should take place here.
+     */
+    handle(command: Command): void;
+    /**
+     * Sometimes, it is useful to perform some work after a command (and all its
+     * subcommands) has been completely handled.  For example, when we paste
+     * multiple cells, we only want to reevaluate the cell values once at the end.
+     */
+    finalize(command: Command): void;
+    drawGrid(ctx: GridRenderingContext, layer: LAYERS): void;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+}
+
+/**
+ * Autofill Plugin
+ *
+ */
+declare class AutofillPlugin extends BasePlugin {
+    static layers: LAYERS[];
+    static getters: string[];
+    static modes: Mode[];
+    private autofillZone;
+    private lastCellSelected;
+    private direction;
+    private tooltip;
+    allowDispatch(cmd: Command): 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
+     *              usefull to set it to false when we need to fill the tooltip
+     */
+    private autofill;
+    /**
+     * 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;
+    /**
+     * 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;
+    drawGrid(renderingContext: GridRenderingContext): void;
+}
+
+declare class ChartPlugin extends BasePlugin {
+    static getters: string[];
+    static layers: LAYERS[];
+    private chartFigures;
+    private chartRuntime;
+    private outOfDate;
+    allowDispatch(cmd: Command): CommandResult;
+    handle(cmd: Command): void;
+    finalize(cmd: Command): void;
+    import(data: WorkbookData): void;
+    getChartRuntime(figureId: string): ChartConfiguration | undefined;
+    private getChartDefinition;
+    private createChartDefinition;
+    /**
+     * Create a chart dataset from a Zone.
+     * The zone should be a single column or a single row
+     */
+    private createDataset;
+    private getDefaultConfiguration;
+    private extractDataFromRange;
+    private mapDefinitionToRuntime;
+    private addChartFigure;
+    private isCellUsedInChart;
+}
+
+/**
+ * Clipboard Plugin
+ *
+ * This clipboard manages all cut/copy/paste interactions internal to the
+ * application, and with the OS clipboard as well.
+ */
+declare class ClipboardPlugin extends BasePlugin {
+    static layers: LAYERS[];
+    static getters: string[];
+    static modes: Mode[];
+    private status;
+    private shouldCut?;
+    private zones;
+    private cells?;
+    private originSheet;
+    private _isPaintingFormat;
+    private pasteOnlyValue;
+    private pasteOnlyFormat;
+    allowDispatch(cmd: Command): 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 concecutive 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(): string;
+    getPasteZones(target: Zone[]): Zone[];
+    isPaintingFormat(): boolean;
+    private cutOrCopy;
+    private pasteFromClipboard;
+    private isPasteAllowed;
+    private pasteFromModel;
+    private clearCutZone;
+    private pasteZone;
+    private addMissingDimensions;
+    pasteCell(origin: Cell | null, col: number, row: number, onlyValue: boolean, onlyFormat: boolean): void;
+    private valueToContent;
+    interactivePaste(target: Zone[]): void;
+    drawGrid(renderingContext: GridRenderingContext): void;
+}
+
+declare class ConditionalFormatPlugin extends BasePlugin {
+    static getters: string[];
+    private isStale;
+    private cfRules;
+    private computedStyles;
+    handle(cmd: Command): void;
+    finalize(): void;
+    import(data: WorkbookData): void;
+    export(data: Partial<WorkbookData>): void;
+    /**
+     * Returns all the conditional format rules defined for the current sheet
+     */
+    getConditionalFormats(): ConditionalFormat[];
+    /**
+     * Returns the conditional style property for a given cell reference in the active sheet or
+     * undefined if this cell doesn't have a conditional style set.
+     */
+    getConditionalStyle(xc: string): Style | undefined;
+    getRulesSelection(selection: [Zone]): string[];
+    getRulesByZone(zone: Zone): Set<string>;
+    getRulesByCell(cellXc: string): Set<ConditionalFormat>;
+    /**
+     * Add or replace a conditional format rule
+     */
+    private addConditionalFormatting;
+    /**
+     * Execute the complete color scale for the range of the conditional format for a 2 colors rule
+     */
+    private applyColorScale;
+    /**
+     * Execute the predicate to know if a conditional formatting rule should be applied to a cell
+     */
+    private rulePredicate;
+    /**
+     * 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 computeStyles;
+    private adaptcfRules;
+    private removeConditionalFormatting;
+    private pasteCf;
+    private adaptRules;
+}
+
+/**
+ * Core Plugin
+ *
+ * This is the most fundamental of all plugins. It defines how to interact with
+ * cell and sheet content.
+ */
+declare class CorePlugin extends BasePlugin {
+    static getters: string[];
+    private sheetIds;
+    private showFormulas;
+    allowDispatch(cmd: Command): CommandResult;
+    handle(cmd: Command): void;
+    applyOffset(formula: string, offsetX: number, offsetY: number): string;
+    getCell(col: number, row: number, sheetName?: string): Cell | null;
+    getCellText(cell: Cell): string;
+    /**
+     * Converts a zone to a XC coordinate system
+     *
+     * The conversion also treats merges as one single cell
+     *
+     * Examples:
+     * {top:0,left:0,right:0,bottom:0} ==> A1
+     * {top:0,left:0,right:1,bottom:1} ==> A1:B2
+     *
+     * if A1:B2 is a merge:
+     * {top:0,left:0,right:1,bottom:1} ==> A1
+     * {top:1,left:0,right:1,bottom:2} ==> A1:B3
+     *
+     * if A1:B2 and A4:B5 are merges:
+     * {top:1,left:0,right:1,bottom:3} ==> A1:A5
+     */
+    zoneToXC(zone: Zone): string;
+    /**
+     * Returns the id (not the name) of the currently active sheet
+     */
+    getActiveSheet(): string;
+    getSheetName(sheetId: string): string | undefined;
+    getSheetIdByName(name: string | undefined): string | undefined;
+    getSheets(): Sheet[];
+    getCol(sheetId: string, index: number): Col;
+    getRow(sheetId: string, index: number): Row;
+    /**
+     * Returns all the cells of a col
+     */
+    getColCells(col: number): Cell[];
+    getNumberCols(sheetId: string): number;
+    getNumberRows(sheetId: string): number;
+    getColsZone(start: number, end: number): Zone;
+    getRowsZone(start: number, end: number): Zone;
+    getGridSize(): [number, number];
+    shouldShowFormulas(): boolean;
+    getRangeValues(reference: string, defaultSheetId: string): any[][];
+    getRangeFormattedValues(reference: string, defaultSheetId: string): string[][];
+    private getColMaxWidth;
+    private getRowMaxHeight;
+    private setColSize;
+    private setRowSize;
+    /**
+     * Delete column. This requires a lot of handling:
+     * - Update all the formulas in all sheets
+     * - Move the cells
+     * - Update the cols/rows (size, number, (cells), ...)
+     * - Reevaluate the cells
+     *
+     * @param sheetID ID of the sheet on which deletion should be applied
+     * @param columns Columns to delete
+     */
+    private removeColumns;
+    /**
+     * Delete row. This requires a lot of handling:
+     * - Update the merges
+     * - Update all the formulas in all sheets
+     * - Move the cells
+     * - Update the cols/rows (size, number, (cells), ...)
+     * - Reevaluate the cells
+     *
+     * @param sheetID ID of the sheet on which deletion should be applied
+     * @param rows Rows to delete
+     */
+    private removeRows;
+    private addColumns;
+    private addRows;
+    private moveCellsHorizontally;
+    /**
+     * Move all the cells that are from the row under `deleteToRow` up to `deleteFromRow`
+     *
+     * b.e.
+     * move vertically with delete from 3 and delete to 5 will first clear all the cells from lines 3 to 5,
+     * then take all the row starting at index 6 and add them back at index 3
+     *
+     * @param deleteFromRow the row index from which to start deleting
+     * @param deleteToRow the row index until which the deleting must continue
+     * @param the sheet from which to remove
+     */
+    private moveCellVerticallyBatched;
+    private moveCellsVertically;
+    private manageColumnsHeaders;
+    private processRowsHeaderDelete;
+    private processRowsHeaderAdd;
+    private addEmptyRow;
+    private updateColumnsFormulas;
+    private updateRowsFormulas;
+    private processCellsToMove;
+    private updateCell;
+    private generateSheetName;
+    private createSheet;
+    private moveSheet;
+    private isRenameAllowed;
+    private interactiveRenameSheet;
+    private renameSheet;
+    private duplicateSheet;
+    private interactiveDeleteSheet;
+    private deleteSheet;
+    private clearZones;
+    /**
+     * Update a reference by applying an offset to the column
+     *
+     * @param ref Reference to update
+     * @param sheet Id of the sheet, if cross-sheet reference
+     * @param base Index of the element added/removed
+     * @param step Number of elements added or -1 if removed
+     */
+    private updateColumnsRef;
+    /**
+     * Update a full range by appling an offset.
+     *
+     * @param ref Reference to update
+     * @param sheet Id of the sheet, if cross-sheet reference
+     * @param base Index of the element added/removed
+     * @param step Number of elements added or -1 if removed
+     */
+    private updateColumnsRange;
+    /**
+     * Update a reference by applying an offset to the row
+     *
+     * @param ref Reference to update
+     * @param sheet Id of the sheet, if cross-sheet reference
+     * @param base Index of the element added/removed
+     * @param step Number of elements added or -1 if removed
+     */
+    private updateRowsRef;
+    /**
+     * Update a full range by appling an offset.
+     *
+     * @param ref Reference to update
+     * @param sheet Id of the sheet, if cross-sheet reference
+     * @param base Index of the element added/removed
+     * @param step Number of elements added/removed (negative when removed)
+     */
+    private updateRowsRange;
+    /**
+     * Update a range with some offsets
+     */
+    private updateRange;
+    /**
+     * Update a reference with some offsets.
+     */
+    private updateReference;
+    private visitAllFormulasSymbols;
+    /**
+     * Apply a function to update the formula on every cells of every sheets which
+     * contains a formula
+     * @param cb Update formula function to apply
+     */
+    private visitFormulas;
+    import(data: WorkbookData): void;
+    importSheet(data: SheetData): void;
+    export(data: WorkbookData): void;
+}
+
+declare type EditionMode = "editing" | "selecting" | "inactive";
+declare class EditionPlugin extends BasePlugin {
+    static layers: LAYERS[];
+    static getters: string[];
+    static modes: Mode[];
+    private col;
+    private row;
+    private mode;
+    private sheet;
+    private currentContent;
+    beforeHandle(cmd: Command): void;
+    handle(cmd: Command): void;
+    getEditionMode(): EditionMode;
+    getCurrentContent(): string;
+    getEditionSheet(): string;
+    private startEdition;
+    private stopEdition;
+    private cancelEdition;
+}
+
+declare class EvaluationPlugin extends BasePlugin {
+    static getters: string[];
+    static modes: Mode[];
+    private isUptodate;
+    private loadingCells;
+    private isStarted;
+    private evalContext;
+    /**
+     * For all cells that are being currently computed (asynchronously).
+     *
+     * For example: =Wait(3)
+     */
+    private PENDING;
+    /**
+     * For all cells that are NOT being currently computed, but depend on another
+     * asynchronous computation.
+     *
+     * For example: A2 is in WAITING (initially) and A1 in PENDING
+     *   A1: =Wait(3)
+     *   A2: =A1
+     */
+    private WAITING;
+    /**
+     * For all cells that have been async computed.
+     *
+     * For example:
+     *  A1: =Wait(3)
+     *  A2: =A1
+     *
+     * When A1 is computed, A1 is moved in COMPUTED
+     */
+    private COMPUTED;
+    constructor(workbook: Workbook, getters: Getters, history: WHistory, dispatch: CommandDispatcher["dispatch"], config: ModelConfig);
+    handle(cmd: Command): void;
+    finalize(): void;
+    evaluateFormula(formula: string, sheet?: UID): any;
+    isIdle(): boolean;
+    private startScheduler;
+    private evaluate;
+    private evaluateCells;
+    /**
+     * Return all functions necessary to properly evaluate a formula:
+     * - a refFn function to read any reference, cell or range of a normalized formula
+     * - a range function to convert any reference to a proper value array
+     * - an evaluation context
+     */
+    private getFormulaParameters;
+}
+
+declare class FigurePlugin extends BasePlugin {
+    static getters: string[];
+    private selectedFigureId;
+    private figures;
+    private sheetFigures;
+    handle(cmd: Command): void;
+    deleteSheet(sheet: string): void;
+    getFigures(viewport: Viewport): Figure<any>[];
+    getSelectedFigureId(): string | null;
+    getFigure<T>(figureId: string): Figure<T>;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+}
+
+/**
+ * Formatting plugin.
+ *
+ * This plugin manages all things related to a cell look:
+ * - styles
+ * - borders
+ * - value formatters
+ */
+declare class FormattingPlugin extends BasePlugin {
+    static getters: string[];
+    private ctx;
+    private styles;
+    private borders;
+    private nextId;
+    handle(cmd: Command): void;
+    getCellWidth(cell: Cell): number;
+    getTextWidth(text: string, styleId?: number): number;
+    getCellHeight(cell: Cell): number;
+    getCellStyle(cell: Cell): Style;
+    getCellBorder(cell: Cell): Border | null;
+    getCurrentStyle(): Style;
+    private setStyle;
+    private setStyleToCell;
+    private registerStyle;
+    private setBorder;
+    private aggregateBorderCommands;
+    private clearBorder;
+    private clearSide;
+    private setBorderToMap;
+    private registerBorder;
+    /**
+     * Note that here, formatting refers to styles+border, not value formatters
+     */
+    private clearFormatting;
+    private setFormatter;
+    /**
+     * 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, the format resulting from the change of the
+     * first cell (with number type) will be applied to the whole zone.
+     */
+    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 searchNumberFormat;
+    /**
+     * Function used to give the default format of a cell with a number for value.
+     * It is considered that the default format of a number is 0 followed by as many
+     * 0 as there are decimal places.
+     *
+     * Exemple:
+     * - 1 --> '0'
+     * - 123 --> '0'
+     * - 12345 --> '0'
+     * - 42.1 --> '0.0'
+     * - 456.0001 --> '0.0000'
+     */
+    private setDefaultNumberFormat;
+    /**
+     * This function take a cell format representation and return a new format representtion
+     * with more or lesse decimal places.
+     *
+     * If the format doesn't look like a digital format (means that not contain '0')
+     * or if this one cannot be increased or decreased, the returned format will be
+     * the same.
+     *
+     * This function aims to work with all possible formats as well as custom formats.
+     *
+     * Examples of format changed by this function:
+     * - "0" (step = 1) --> "0.0"
+     * - "0.000%" (step = 1) --> "0.0000%"
+     * - "0.00" (step = -1) --> "0.0"
+     * - "0%" (step = -1) --> "0%"
+     * - "#,##0.0" (step = -1) --> "#,##0"
+     * - "#,##0;0.0%;0.000" (step = 1) --> "#,##0.0;0.00%;0.0000"
+     */
+    private changeDecimalFormat;
+    /**
+     * This function computes the style/border of a row/col based on the neighbours.
+     *
+     * @param index the index of the row/col of which we will change the style
+     * @param isColumn true if element is a column, false if row
+     * @param upper true if the style of the upper row/col should be used, false, if the lower should be used
+     */
+    private onAddElements;
+    /**
+     * gets the currently used style/border of a cell based on it's coordinates
+     *
+     * @param x column number of a cell
+     * @param y row number of a cell
+     */
+    private getFormat;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+}
+
+/**
+ * HighlightPlugin
+ */
+declare class HighlightPlugin extends BasePlugin {
+    static modes: Mode[];
+    static layers: LAYERS[];
+    static getters: string[];
+    private highlights;
+    private color;
+    private highlightSelectionEnabled;
+    private pendingHighlights;
+    handle(cmd: Command): void;
+    getHighlights(): Highlight[];
+    private addHighlights;
+    private addPendingHighlight;
+    private prepareHighlights;
+    /**
+     *
+     * @param ranges {"[sheet!]XC": color}
+     * @private
+     */
+    private removeHighlights;
+    /**
+     * Highlight selected zones (which are not already highlighted).
+     */
+    private highlightSelection;
+    private isHighlighted;
+    /**
+     * Remove pending highlights which are not selected.
+     * Highlighted zones which are selected are still considered
+     * pending.
+     */
+    private removePendingHighlights;
+    drawGrid(renderingContext: GridRenderingContext): void;
+}
+
+declare class MergePlugin extends BasePlugin {
+    static getters: string[];
+    private nextId;
+    private pending;
+    allowDispatch(cmd: Command): CommandResult;
+    beforeHandle(cmd: Command): void;
+    handle(cmd: Command): void;
+    /**
+     * Return true if the current selection requires losing state if it is merged.
+     * This happens when there is some textual content in other cells than the
+     * top left.
+     */
+    isMergeDestructive(zone: Zone): boolean;
+    /**
+     * Return true if the zone intersects an existing merge:
+     * if they have at least a common cell
+     */
+    doesIntersectMerge(zone: Zone): boolean;
+    /**
+     * Add all necessary merge to the current selection to make it valid
+     */
+    expandZone(zone: Zone): Zone;
+    isInMerge(xc: string): boolean;
+    isMainCell(xc: string, sheetId: string): boolean;
+    getMainCell(xc: string): string;
+    /**
+     * Verify that we can merge without losing content of other cells or
+     * because the user gave his permission
+     */
+    private isMergeAllowed;
+    /**
+     * Merge the current selection. Note that:
+     * - it assumes that we have a valid selection (no intersection with other
+     *   merges)
+     * - it does nothing if the merge is trivial: A1:A1
+     */
+    private addMerge;
+    private applyBorderMerge;
+    private removeMerge;
+    private interactiveMerge;
+    private duplicateMerge;
+    private removeAllMerges;
+    private exportAndRemoveMerges;
+    private updateMergesStyles;
+    private isPasteAllowed;
+    private autoFillMerge;
+    import(data: WorkbookData): void;
+    private importMerges;
+    export(data: WorkbookData): void;
+}
+
+declare class RendererPlugin extends BasePlugin {
+    static layers: LAYERS[];
+    static getters: string[];
+    static modes: Mode[];
+    private boxes;
+    /**
+     * Return the index of a column given an offset x and a visible left col index.
+     * It returns -1 if no column is found.
+     */
+    getColIndex(x: number, left: number): number;
+    getRowIndex(y: number, top: number): number;
+    getRect(zone: Zone, viewport: Viewport): Rect;
+    /**
+     * Snap a viewport boundaries to exactly match the start of a cell.
+     * @param viewport
+     */
+    snapViewportToCell(viewport: Viewport): Viewport;
+    /**
+     * Adjust the viewport until the active cell is completely visible inside it.
+     * @param viewport the viewport that will be adjusted
+     */
+    adjustViewportPosition(viewport: Viewport): Viewport;
+    adjustViewportZone(viewport: Viewport): Viewport;
+    private adjustViewportZoneX;
+    private adjustViewportZoneY;
+    drawGrid(renderingContext: GridRenderingContext, layer: LAYERS): void;
+    private drawBackground;
+    private drawCellBackground;
+    private drawBorders;
+    private drawTexts;
+    private drawHeaders;
+    private hasContent;
+    private getGridBoxes;
+}
+
+interface Selection {
+    anchor: [number, number];
+    zones: Zone[];
+}
+declare enum SelectionMode {
+    idle = 0,
+    selecting = 1,
+    readyToExpand = 2,
+    expanding = 3
+}
+/**
+ * SelectionPlugin
+ */
+declare class SelectionPlugin extends BasePlugin {
+    static layers: LAYERS[];
+    static modes: Mode[];
+    static getters: string[];
+    private selection;
+    private activeCol;
+    private activeRow;
+    private activeXc;
+    private mode;
+    private sheetsData;
+    allowDispatch(cmd: Command): CommandResult;
+    handle(cmd: Command): void;
+    getActiveCell(): Cell | null;
+    getActiveCols(): Set<number>;
+    getActiveRows(): Set<number>;
+    getSelectedZones(): Zone[];
+    getSelectedZone(): Zone;
+    getSelection(): Selection;
+    getPosition(): [number, number];
+    getAggregate(): string | null;
+    getSelectionMode(): SelectionMode;
+    isSelected(zone: Zone): boolean;
+    /**
+     * Return [col, row]
+     */
+    private getReferenceCoords;
+    private selectColumn;
+    private selectRow;
+    private selectAll;
+    /**
+     * Change the anchor of the selection active cell to an absolute col and row inded.
+     *
+     * This is a non trivial task. We need to stop the editing process and update
+     * properly the current selection.  Also, this method can optionally create a new
+     * range in the selection.
+     */
+    private selectCell;
+    /**
+     * Moves the position of either the active cell of the anchor of the current selection by a number of rows / cols delta
+     */
+    movePosition(deltaX: number, deltaY: number): void;
+    setSelection(anchor: [number, number], zones: Zone[], strict?: boolean): void;
+    private moveSelection;
+    private addCellToSelection;
+    /**
+     * Ensure selections are not outside sheet boundaries.
+     * They are clipped to fit inside the sheet if needed.
+     */
+    private ensureSelectionValidity;
+    /**
+     * Clip the selection if it spans outside the sheet
+     */
+    private clipSelection;
+    private onAddColumns;
+    private onAddRows;
+    drawGrid(renderingContext: GridRenderingContext): void;
+}
+
+interface RangeInputValue {
+    id: string;
+    xc: string;
+    color?: string | null;
+}
+/**
+ * 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.
+ */
+declare class SelectionInputPlugin extends BasePlugin {
+    static modes: Mode[];
+    static layers: LAYERS[];
+    static getters: string[];
+    private inputs;
+    private inputMaximums;
+    private focusedInput;
+    private focusedRange;
+    private willAddNewRange;
+    allowDispatch(cmd: Command): CommandResult;
+    handle(cmd: Command): void;
+    getSelectionInput(id: string): (RangeInputValue & {
+        isFocused: boolean;
+    })[];
+    getSelectionInputValue(id: string): string[];
+    private initInput;
+    /**
+     * Focus a given range or remove the focus.
+     */
+    private focus;
+    private focusLast;
+    private removeAllHighlights;
+    /**
+     * Highlight all valid ranges.
+     */
+    private highlightAllRanges;
+    private add;
+    /**
+     * Add a new input at the end and focus it.
+     */
+    private addNewRange;
+    private setRange;
+    private changeRange;
+    private removeRange;
+    private setPendingRange;
+    /**
+     * Convert highlights to the input format
+     */
+    private highlightsToInput;
+    /**
+     * Convert highlights input format to the command format.
+     * The first xc in the input range will keep its color.
+     */
+    private inputToHighlights;
+    private isRangeValid;
+    private cleanInputs;
+    /**
+     * Return the index of a range given its id
+     * or `null` if the range is not found.
+     */
+    private getIndex;
+}
+
+interface Getters {
+    applyOffset: CorePlugin["applyOffset"];
+    getCell: CorePlugin["getCell"];
+    getCellText: CorePlugin["getCellText"];
+    zoneToXC: CorePlugin["zoneToXC"];
+    getActiveSheet: CorePlugin["getActiveSheet"];
+    getSheetName: CorePlugin["getSheetName"];
+    getSheetIdByName: CorePlugin["getSheetIdByName"];
+    getSheets: CorePlugin["getSheets"];
+    getCol: CorePlugin["getCol"];
+    getRow: CorePlugin["getRow"];
+    getColCells: CorePlugin["getColCells"];
+    getNumberCols: CorePlugin["getNumberCols"];
+    getNumberRows: CorePlugin["getNumberRows"];
+    getColsZone: CorePlugin["getColsZone"];
+    getRowsZone: CorePlugin["getRowsZone"];
+    getGridSize: CorePlugin["getGridSize"];
+    getRangeValues: CorePlugin["getRangeValues"];
+    getRangeFormattedValues: CorePlugin["getRangeFormattedValues"];
+    shouldShowFormulas: CorePlugin["shouldShowFormulas"];
+    getClipboardContent: ClipboardPlugin["getClipboardContent"];
+    isPaintingFormat: ClipboardPlugin["isPaintingFormat"];
+    getPasteZones: ClipboardPlugin["getPasteZones"];
+    getCellWidth: FormattingPlugin["getCellWidth"];
+    getTextWidth: FormattingPlugin["getTextWidth"];
+    getCellHeight: FormattingPlugin["getCellHeight"];
+    expandZone: MergePlugin["expandZone"];
+    isMergeDestructive: MergePlugin["isMergeDestructive"];
+    isInMerge: MergePlugin["isInMerge"];
+    getMainCell: MergePlugin["getMainCell"];
+    doesIntersectMerge: MergePlugin["doesIntersectMerge"];
+    getActiveCell: SelectionPlugin["getActiveCell"];
+    getActiveCols: SelectionPlugin["getActiveCols"];
+    getActiveRows: SelectionPlugin["getActiveRows"];
+    getSelectedZones: SelectionPlugin["getSelectedZones"];
+    getSelectedZone: SelectionPlugin["getSelectedZone"];
+    getSelection: SelectionPlugin["getSelection"];
+    getPosition: SelectionPlugin["getPosition"];
+    getAggregate: SelectionPlugin["getAggregate"];
+    getSelectionMode: SelectionPlugin["getSelectionMode"];
+    isSelected: SelectionPlugin["isSelected"];
+    getHighlights: HighlightPlugin["getHighlights"];
+    getConditionalFormats: ConditionalFormatPlugin["getConditionalFormats"];
+    getConditionalStyle: ConditionalFormatPlugin["getConditionalStyle"];
+    getRulesSelection: ConditionalFormatPlugin["getRulesSelection"];
+    getColIndex: RendererPlugin["getColIndex"];
+    getRowIndex: RendererPlugin["getRowIndex"];
+    getRect: RendererPlugin["getRect"];
+    snapViewportToCell: RendererPlugin["snapViewportToCell"];
+    adjustViewportPosition: RendererPlugin["adjustViewportPosition"];
+    adjustViewportZone: RendererPlugin["adjustViewportZone"];
+    getCurrentStyle: FormattingPlugin["getCurrentStyle"];
+    getCellStyle: FormattingPlugin["getCellStyle"];
+    getCellBorder: FormattingPlugin["getCellBorder"];
+    canUndo: WHistory["canUndo"];
+    canRedo: WHistory["canRedo"];
+    evaluateFormula: EvaluationPlugin["evaluateFormula"];
+    isIdle: EvaluationPlugin["isIdle"];
+    getEditionMode: EditionPlugin["getEditionMode"];
+    getCurrentContent: EditionPlugin["getCurrentContent"];
+    getEditionSheet: EditionPlugin["getEditionSheet"];
+    getAutofillTooltip: AutofillPlugin["getAutofillTooltip"];
+    getSelectionInput: SelectionInputPlugin["getSelectionInput"];
+    getSelectionInputValue: SelectionInputPlugin["getSelectionInputValue"];
+    getFigures: FigurePlugin["getFigures"];
+    getSelectedFigureId: FigurePlugin["getSelectedFigureId"];
+    getFigure: FigurePlugin["getFigure"];
+    getChartRuntime: ChartPlugin["getChartRuntime"];
+}
+
+declare type Rect = [number, number, number, number];
+interface Viewport extends Zone {
+    width: number;
+    height: number;
+    offsetX: number;
+    offsetY: number;
+}
+interface GridRenderingContext {
+    ctx: CanvasRenderingContext2D;
+    viewport: Viewport;
+    dpr: number;
+    thinLineWidth: number;
+}
+declare const enum LAYERS {
+    Background = 0,
+    Highlights = 1,
+    Clipboard = 2,
+    Chart = 3,
+    Selection = 4,
+    Autofill = 5,
+    Headers = 6
+}
+
+/**
+ * There are two kinds of commands: Primitive and Local
+ *
+ * - Primitive commands are commands that
+ *    1. manipulate the imported/exported spreadsheet state
+ *    2. are "low level" => cannot be converted into lower level commands
+ *    3. make sense when sent by the network to another user
+ *
+ * - Local commands: every other command.
+ *    1. manipulate the local state (such as the selection, or the clipboard)
+ *    2. can often be converted into primitive commands
+ *    3. do not make sense to send by network to another user.
+ *
+ * For example, "RESIZE_COLUMNS" is a primitive command. "AUTORESIZE_COLUMNS"
+ * can be (locally) converted into a "RESIZE_COLUMNS", and therefore, is not a
+ * primitive command.
+ *
+ * Primitive commands should be "device agnostic". This means that they should
+ * contain all the information necessary to perform their job. Local commands
+ * can use inferred information from the local internal state, such as the
+ * active sheet.
+ */
+interface BaseCommand {
+    interactive?: boolean;
+}
+interface UpdateCellCommand extends BaseCommand {
+    type: "UPDATE_CELL";
+    sheet: string;
+    col: number;
+    row: number;
+    content?: string;
+    style?: number;
+    border?: number;
+    format?: string;
+}
+interface ResizeColumnsCommand extends BaseCommand {
+    type: "RESIZE_COLUMNS";
+    sheet: string;
+    cols: number[];
+    size: number;
+}
+interface ResizeRowsCommand extends BaseCommand {
+    type: "RESIZE_ROWS";
+    sheet: string;
+    rows: number[];
+    size: number;
+}
+/**
+ * Todo: add a string "id" field, and change the code to use internally a uuid.
+ */
+interface CreateSheetCommand extends BaseCommand {
+    type: "CREATE_SHEET";
+    id: string;
+    name?: string;
+    cols?: number;
+    rows?: number;
+    activate?: boolean;
+}
+interface MoveSheetCommand extends BaseCommand {
+    type: "MOVE_SHEET";
+    sheet: string;
+    direction: "left" | "right";
+}
+interface RenameSheetCommand extends BaseCommand {
+    type: "RENAME_SHEET";
+    sheet: string;
+    name?: string;
+}
+interface DuplicateSheetCommand extends BaseCommand {
+    type: "DUPLICATE_SHEET";
+    sheet: string;
+    id: string;
+    name: string;
+}
+interface DeleteSheetCommand extends BaseCommand {
+    type: "DELETE_SHEET";
+    sheet: string;
+}
+interface DeleteSheetConfirmationCommand extends BaseCommand {
+    type: "DELETE_SHEET_CONFIRMATION";
+    sheet: string;
+}
+interface AddMergeCommand extends BaseCommand {
+    type: "ADD_MERGE";
+    sheet: string;
+    zone: Zone;
+    force?: boolean;
+}
+interface RemoveMergeCommand extends BaseCommand {
+    type: "REMOVE_MERGE";
+    sheet: string;
+    zone: Zone;
+}
+interface AddFormattingCommand extends BaseCommand {
+    type: "SET_FORMATTING";
+    sheet: string;
+    target: Zone[];
+    style?: Style;
+    border?: BorderCommand;
+}
+interface ClearFormattingCommand extends BaseCommand {
+    type: "CLEAR_FORMATTING";
+    sheet: string;
+    target: Zone[];
+}
+interface SetFormatterCommand extends BaseCommand {
+    type: "SET_FORMATTER";
+    sheet: string;
+    target: Zone[];
+    formatter: string;
+}
+interface SetDecimalCommand extends BaseCommand {
+    type: "SET_DECIMAL";
+    sheet: string;
+    target: Zone[];
+    step: number;
+}
+/**
+ * todo: add sheet argument...
+ * todo: use id instead of a list. this is not safe to serialize and send to
+ * another user
+ */
+interface AddConditionalFormatCommand extends BaseCommand {
+    type: "ADD_CONDITIONAL_FORMAT";
+    cf: ConditionalFormat;
+    sheet: string;
+}
+interface RemoveConditionalFormatCommand extends BaseCommand {
+    type: "REMOVE_CONDITIONAL_FORMAT";
+    id: string;
+    sheet: string;
+}
+interface RemoveColumnsCommand extends BaseCommand {
+    type: "REMOVE_COLUMNS";
+    columns: number[];
+    sheet: string;
+}
+interface RemoveRowsCommand extends BaseCommand {
+    type: "REMOVE_ROWS";
+    rows: number[];
+    sheet: string;
+}
+interface AddColumnsCommand extends BaseCommand {
+    type: "ADD_COLUMNS";
+    column: number;
+    sheet: string;
+    quantity: number;
+    position: "before" | "after";
+}
+interface AddRowsCommand extends BaseCommand {
+    type: "ADD_ROWS";
+    row: number;
+    sheet: string;
+    quantity: number;
+    position: "before" | "after";
+}
+interface CopyCommand extends BaseCommand {
+    type: "COPY";
+    target: Zone[];
+}
+interface CutCommand extends BaseCommand {
+    type: "CUT";
+    target: Zone[];
+}
+interface PasteCommand extends BaseCommand {
+    type: "PASTE";
+    target: Zone[];
+    onlyValue?: boolean;
+    onlyFormat?: boolean;
+    force?: boolean;
+}
+interface PasteCellCommand extends BaseCommand {
+    type: "PASTE_CELL";
+    origin: Cell | null;
+    originCol: number;
+    originRow: number;
+    col: number;
+    row: number;
+    sheet: string;
+    cut?: boolean;
+    onlyValue: boolean;
+    onlyFormat: boolean;
+}
+interface AutoFillCellCommand extends BaseCommand {
+    type: "AUTOFILL_CELL";
+    originCol: number;
+    originRow: number;
+    col: number;
+    row: number;
+    content?: string;
+    style?: number;
+    border?: number;
+    format?: string;
+}
+interface ActivatePaintFormatCommand extends BaseCommand {
+    type: "ACTIVATE_PAINT_FORMAT";
+    target: Zone[];
+}
+interface PasteFromOSClipboardCommand extends BaseCommand {
+    type: "PASTE_FROM_OS_CLIPBOARD";
+    target: Zone[];
+    text: string;
+}
+interface AutoresizeColumnsCommand extends BaseCommand {
+    type: "AUTORESIZE_COLUMNS";
+    sheet: string;
+    cols: number[];
+}
+interface AutoresizeRowsCommand extends BaseCommand {
+    type: "AUTORESIZE_ROWS";
+    sheet: string;
+    rows: number[];
+}
+interface MovePositionCommand extends BaseCommand {
+    type: "MOVE_POSITION";
+    deltaX: number;
+    deltaY: number;
+}
+interface ActivateSheetCommand extends BaseCommand {
+    type: "ACTIVATE_SHEET";
+    from: string;
+    to: string;
+}
+interface SelectCellCommand extends BaseCommand {
+    type: "SELECT_CELL";
+    col: number;
+    row: number;
+}
+interface SetSelectionCommand extends BaseCommand {
+    type: "SET_SELECTION";
+    anchor: [number, number];
+    zones: Zone[];
+    strict?: boolean;
+}
+/**
+ * Set the selection mode to `selecting`.
+ * The user is currently selecting some cells.
+ */
+interface StartSelectionCommand extends BaseCommand {
+    type: "START_SELECTION";
+}
+/**
+ * Set the selection mode to `readyToExpand`.
+ * The user is ready to expand the selected zones with a new
+ * selection (i.e. add an other zone the to currently selected zones).
+ * In other words, the next selection will be added to the
+ * current selection if this mode is active.
+ */
+interface PrepareExpansionCommand extends BaseCommand {
+    type: "PREPARE_SELECTION_EXPANSION";
+}
+/**
+ * Set the selection mode to `expanding`.
+ * This mode means that the user is currently selecting
+ * a new zone which will be added to the current selection.
+ */
+interface StartExpansionCommand extends BaseCommand {
+    type: "START_SELECTION_EXPANSION";
+}
+/**
+ * Set the selection mode to `idle`.
+ */
+interface StopSelectionCommand extends BaseCommand {
+    type: "STOP_SELECTION";
+}
+/**
+ * When selection highlight is enabled, every selection will
+ * be highlighted. Each selected zone have a different color.
+ */
+interface HighlightSelectionCommand extends BaseCommand {
+    type: "HIGHLIGHT_SELECTION";
+    enabled: boolean;
+}
+/**
+ * Add some highlights as pending highlights.
+ * When highlight selection is enabled, pending highlights
+ * are removed at every new selection.
+ */
+interface AddPendingHighlightCommand extends BaseCommand {
+    type: "ADD_PENDING_HIGHLIGHTS";
+    ranges: {
+        [range: string]: string;
+    };
+}
+/**
+ * Removes all pending highlights.
+ */
+interface ResetPendingHighlightCommand extends BaseCommand {
+    type: "RESET_PENDING_HIGHLIGHT";
+}
+/**
+ * Set a color to be used for the next selection to highlight.
+ * The color is only used when selection highlight is enabled.
+ */
+interface SetColorCommand extends BaseCommand {
+    type: "SET_HIGHLIGHT_COLOR";
+    color: string;
+}
+interface SelectColumnCommand extends BaseCommand {
+    type: "SELECT_COLUMN";
+    index: number;
+    createRange?: boolean;
+    updateRange?: boolean;
+}
+interface SelectRowCommand extends BaseCommand {
+    type: "SELECT_ROW";
+    index: number;
+    createRange?: boolean;
+    updateRange?: boolean;
+}
+interface SelectAllCommand extends BaseCommand {
+    type: "SELECT_ALL";
+}
+interface AlterSelectionCommand extends BaseCommand {
+    type: "ALTER_SELECTION";
+    delta?: [number, number];
+    cell?: [number, number];
+}
+interface EvaluateCellsCommand extends BaseCommand {
+    type: "EVALUATE_CELLS";
+    onlyWaiting?: boolean;
+}
+interface AddHighlightsCommand extends BaseCommand {
+    type: "ADD_HIGHLIGHTS";
+    ranges: {
+        [range: string]: string;
+    };
+}
+/**
+ * Remove the given highlights.
+ */
+interface RemoveHighlightsCommand extends BaseCommand {
+    type: "REMOVE_HIGHLIGHTS";
+    /**
+     * Ranges to remove. Keys are ranges in XC format and values
+     * are the associated colors.
+     * e.g. { B4: "#e2e2e2" }
+     */
+    ranges: {
+        [range: string]: string;
+    };
+}
+interface RemoveAllHighlightsCommand extends BaseCommand {
+    type: "REMOVE_ALL_HIGHLIGHTS";
+}
+interface StartComposerSelectionCommand extends BaseCommand {
+    type: "START_COMPOSER_SELECTION";
+}
+interface StopComposerSelectionCommand extends BaseCommand {
+    type: "STOP_COMPOSER_SELECTION";
+}
+interface StartEditionCommand extends BaseCommand {
+    type: "START_EDITION";
+    text?: string;
+}
+interface StopEditionCommand extends BaseCommand {
+    type: "STOP_EDITION";
+    cancel?: boolean;
+}
+interface SetCurrentContentCommand extends BaseCommand {
+    type: "SET_CURRENT_CONTENT";
+    content: string;
+}
+interface SetValueCommand extends BaseCommand {
+    type: "SET_VALUE";
+    xc: string;
+    text: string;
+    sheetId?: string;
+}
+interface ShowFormulaCommand extends BaseCommand {
+    type: "SET_FORMULA_VISIBILITY";
+    show: boolean;
+}
+interface DeleteContentCommand extends BaseCommand {
+    type: "DELETE_CONTENT";
+    sheet: string;
+    target: Zone[];
+}
+interface ClearCellCommand extends BaseCommand {
+    type: "CLEAR_CELL";
+    sheet: string;
+    col: number;
+    row: number;
+}
+interface UndoCommand extends BaseCommand {
+    type: "UNDO";
+}
+interface RedoCommand extends BaseCommand {
+    type: "REDO";
+}
+interface StartCommand extends BaseCommand {
+    type: "START";
+}
+interface AutofillCommand extends BaseCommand {
+    type: "AUTOFILL";
+}
+interface AutofillSelectCommand extends BaseCommand {
+    type: "AUTOFILL_SELECT";
+    col: number;
+    row: number;
+}
+interface AutofillAutoCommand extends BaseCommand {
+    type: "AUTOFILL_AUTO";
+}
+/**
+ * Create a new state for a SelectionInput component
+ */
+interface NewInputCommand extends BaseCommand {
+    type: "ENABLE_NEW_SELECTION_INPUT";
+    /**
+     * Identifier to use to reference this state.
+     */
+    id: string;
+    /**
+     * Initial ranges for the state.
+     * e.g. ["B4", "A1:A3"]
+     */
+    initialRanges?: string[];
+    /**
+     * Maximum number of ranges allowed
+     */
+    maximumRanges?: number;
+}
+/**
+ * Delete an identified SelectionInput state.
+ */
+interface RemoveInputCommand extends BaseCommand {
+    type: "DISABLE_SELECTION_INPUT";
+    /** SelectionComponent id */
+    id: string;
+}
+/**
+ * Set the focus on a given range of a SelectionComponent state.
+ */
+interface FocusInputCommand extends BaseCommand {
+    type: "FOCUS_RANGE";
+    /** SelectionComponent id */
+    id: string;
+    /**
+     * Range to focus. If `null` is given, removes the focus entirely.
+     */
+    rangeId: string | null;
+}
+/**
+ * Add an empty range at the end of a SelectionComponent state
+ * and focus it.
+ */
+interface AddEmptyRangeCommand extends BaseCommand {
+    type: "ADD_EMPTY_RANGE";
+    /** SelectionComponent id */
+    id: string;
+}
+/**
+ * Remove a given range in a SelectionComponent state
+ */
+interface RemoveRangeCommand extends BaseCommand {
+    type: "REMOVE_RANGE";
+    /** SelectionComponent id */
+    id: string;
+    /** The range to be removed */
+    rangeId: string;
+}
+/**
+ * Set a new value for a given range of a SelectionComponent state.
+ */
+interface ChangeRangeCommand extends BaseCommand {
+    type: "CHANGE_RANGE";
+    /** SelectionComponent id */
+    id: string;
+    /** The range to be changed */
+    rangeId: string;
+    /**
+     * Range to set in the input. Invalid ranges are also accepted.
+     * e.g. "B2:B3" or the invalid "A5:"
+     */
+    value: string;
+}
+interface CreateFigureCommand extends BaseCommand {
+    type: "CREATE_FIGURE";
+    figure: Figure<any>;
+    sheet: string;
+}
+interface SelectFigureCommand extends BaseCommand {
+    type: "SELECT_FIGURE";
+    id: string;
+}
+interface UpdateFigureCommand extends BaseCommand, Partial<Figure<any>> {
+    type: "UPDATE_FIGURE";
+    id: string;
+}
+interface DeleteFigureCommand extends BaseCommand {
+    type: "DELETE_FIGURE";
+    id: string;
+}
+interface CreateChartCommand extends BaseCommand {
+    type: "CREATE_CHART";
+    id: string;
+    sheetId: string;
+    definition: CreateChartDefinition;
+}
+interface UpdateChartCommand extends BaseCommand {
+    type: "UPDATE_CHART";
+    id: string;
+    definition: CreateChartDefinition;
+}
+declare type Command = NewInputCommand | RemoveInputCommand | FocusInputCommand | AddEmptyRangeCommand | RemoveRangeCommand | ChangeRangeCommand | UpdateCellCommand | CopyCommand | CutCommand | PasteCommand | PasteCellCommand | AutoFillCellCommand | PasteFromOSClipboardCommand | ActivatePaintFormatCommand | ResizeRowsCommand | ResizeColumnsCommand | AutoresizeColumnsCommand | AutoresizeRowsCommand | MovePositionCommand | CreateSheetCommand | MoveSheetCommand | RenameSheetCommand | DuplicateSheetCommand | DeleteSheetCommand | DeleteSheetConfirmationCommand | ActivateSheetCommand | StartSelectionCommand | StartExpansionCommand | PrepareExpansionCommand | StopSelectionCommand | SelectCellCommand | SetSelectionCommand | SelectColumnCommand | SelectRowCommand | SelectAllCommand | AlterSelectionCommand | DeleteContentCommand | EvaluateCellsCommand | AddConditionalFormatCommand | RemoveConditionalFormatCommand | AddHighlightsCommand | RemoveHighlightsCommand | RemoveAllHighlightsCommand | HighlightSelectionCommand | AddPendingHighlightCommand | ResetPendingHighlightCommand | SetColorCommand | StartComposerSelectionCommand | StopComposerSelectionCommand | StartEditionCommand | StopEditionCommand | AddMergeCommand | RemoveMergeCommand | SetCurrentContentCommand | SetValueCommand | AddFormattingCommand | ClearFormattingCommand | SetFormatterCommand | SetDecimalCommand | ClearCellCommand | UndoCommand | RedoCommand | StartCommand | RemoveRowsCommand | RemoveColumnsCommand | AddRowsCommand | CreateChartCommand | UpdateChartCommand | AddColumnsCommand | AutofillCommand | AutofillSelectCommand | ShowFormulaCommand | AutofillAutoCommand | CreateFigureCommand | SelectFigureCommand | UpdateFigureCommand | DeleteFigureCommand;
+interface CommandSuccess {
+    status: "SUCCESS";
+}
+interface CommandCancelled {
+    status: "CANCELLED";
+    reason: CancelledReason;
+}
+declare const enum CancelledReason {
+    Unknown = 0,
+    WillRemoveExistingMerge = 1,
+    MergeIsDestructive = 2,
+    EmptyUndoStack = 3,
+    EmptyRedoStack = 4,
+    NotEnoughColumns = 5,
+    NotEnoughRows = 6,
+    NotEnoughSheets = 7,
+    WrongSheetName = 8,
+    WrongSheetMove = 9,
+    SelectionOutOfBound = 10,
+    WrongPasteSelection = 11,
+    EmptyClipboard = 12,
+    InvalidRange = 13,
+    InputAlreadyFocused = 14,
+    MaximumRangesReached = 15,
+    InvalidChartDefinition = 16,
+    InvalidAutofillSelection = 17
+}
+declare type CommandResult = CommandSuccess | CommandCancelled;
+interface CommandHandler {
+    allowDispatch(command: Command): CommandResult;
+    beforeHandle(command: Command): void;
+    handle(command: Command): void;
+    finalize(command: Command): void;
+}
+interface CommandDispatcher {
+    dispatch<T extends CommandTypes, C extends Extract<Command, {
+        type: T;
+    }>>(type: {} extends Omit<C, "type"> ? T : never): CommandResult;
+    dispatch<T extends CommandTypes, C extends Extract<Command, {
+        type: T;
+    }>>(type: T, r: Omit<C, "type">): CommandResult;
+}
+declare type CommandTypes = Command["type"];
+
+interface SpreadsheetEnv extends Env {
+    openSidePanel: (panel: string, panelProps?: any) => void;
+    toggleSidePanel: (panel: string, panelProps?: any) => void;
+    dispatch: CommandDispatcher["dispatch"];
+    getters: Getters;
+    clipboard: Clipboard;
+    _t: TranslationFunction;
+}
+
+interface TopbarComponent {
+    component: any;
+    isVisible?: (env: SpreadsheetEnv) => boolean;
+}
+
+interface SidePanelContent {
+    title: string | ((env: SpreadsheetEnv) => string);
+    Body: any;
+    Footer?: any;
+}
+
+/**
+ * This function is meant to be used as a tag for a template strings.
+ *
+ * Its job is to convert a textual description of the list of arguments into an
+ * actual array of Arg, suitable for consumption.
+ */
+declare function args(strings: string): Arg[];
+
+declare class FunctionRegistry extends Registry<FunctionDescription> {
+    mapping: {
+        [key: string]: Function;
+    };
+    add(name: string, descr: FunctionDescription): this;
+}
+
+/**
+ * An ActionMenuItem represent a menu item for the menus of the topbar.
+ * Later, it will be reused for the context menu items as well.
+ *
+ * An ActionMenuItem has:
+ * - id, used for example to add child
+ * - name, which can be a string or a function to compute it
+ * - sequence, which represents its position inside the
+ *   menus (the lower sequence it has, the upper it is in the menu)
+ * - isVisible, which can be defined to compute the visibility of the item
+ * - action, the action associated to this item
+ * - children, subitems associated to this item
+ *    NB: an item without action or children is not displayed !
+ * - separator, whether it should add a separator below the item
+ *    NB: a separator defined on the last item is not displayed !
+ *
+ */
+interface MenuItem {
+    name: string | ((env: SpreadsheetEnv) => string);
+    sequence: number;
+    id?: string;
+    isVisible?: (env: SpreadsheetEnv) => boolean;
+    isEnabled?: (env: SpreadsheetEnv) => boolean;
+    action?: (env: SpreadsheetEnv) => void;
+    children?: menuChildren;
+    separator?: boolean;
+}
+declare type FullMenuItem = Required<MenuItem>;
+declare type menuChildren = FullMenuItem[] | ((env: SpreadsheetEnv) => FullMenuItem[]);
+declare function createFullMenuItem(key: string, value: MenuItem): FullMenuItem;
+/**
+ * The class Registry is extended in order to add the function addChild
+ *
+ */
+declare class MenuItemRegistry extends Registry<FullMenuItem> {
+    /**
+     * @override
+     */
+    add(key: string, value: MenuItem): MenuItemRegistry;
+    /**
+     * Add a subitem to an existing item
+     * @param path Path of items to add this subitem
+     * @param value Subitem to add
+     */
+    addChild(key: string, path: string[], value: MenuItem): MenuItemRegistry;
+    getChildren(node: FullMenuItem, env: SpreadsheetEnv): FullMenuItem[];
+    getName(node: FullMenuItem, env: SpreadsheetEnv): string;
+    /**
+     * Get a list of all elements in the registry, ordered by sequence
+     * @override
+     */
+    getAll(): FullMenuItem[];
+}
+
+/**
+ * An AutofillRule is used to generate what to do when we need to autofill
+ * a cell. (In a AutofillGenerator, see plugins/autofill.ts)
+ *
+ * When we generate the rules to autofill, we take the first matching rule
+ * (ordered by sequence), and we generate the AutofillModifier with generateRule
+ */
+interface AutofillRule {
+    condition: (cell: Cell, cells: (Cell | null)[]) => boolean;
+    generateRule: (cell: Cell, cells: (Cell | null)[]) => AutofillModifier;
+    sequence: number;
+}
+
+/**
+ * An AutofillModifierImplementation is used to describe how to handle a
+ * AutofillModifier.
+ */
+interface AutofillModifierImplementation {
+    apply: (rule: AutofillModifier, data: CellData, getters: Getters, direction: DIRECTION) => {
+        cellData: CellData;
+        tooltip?: Tooltip;
+    };
+}
+
+declare function toNumber(value: any): number;
+declare function toString(value: any): string;
+declare function toBoolean(value: any): boolean;
+
+/**
+ * Convert a (col) number to the corresponding letter.
+ *
+ * Examples:
+ *     0 => 'A'
+ *     25 => 'Z'
+ *     26 => 'AA'
+ *     27 => 'AB'
+ */
+declare function numberToLetters(n: number): string;
+/**
+ * Convert a "XC" coordinate to cartesian coordinates.
+ *
+ * Examples:
+ *   A1 => [0,0]
+ *   B3 => [1,2]
+ *
+ * Note: it also accepts lowercase coordinates, but not fixed references
+ */
+declare function toCartesian(xc: string): [number, number];
+/**
+ * Convert from cartesian coordinate to the "XC" coordinate system.
+ *
+ * Examples:
+ *   [0,0] => A1
+ *   [1,2] => B3
+ *
+ * Note: it does not support fixed references
+ */
+declare function toXC(col: number, row: number): string;
+
+declare const DEBUG: {
+    [key: string]: any;
+};
+
+declare function formatDecimal(n: number, decimals: number, sep?: string): string;
+
+declare function uuidv4(): string;
+
+/**
+ * Convert from a cartesian reference to a Zone
+ *
+ * Examples:
+ *    "A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *    "Sheet1!A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "Sheet1!B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *
+ */
+declare function toZone(xc: string): Zone;
+
+/**
+ * This registry is intended to map a type of figure (tag) to a class of
+ * component, that will be used in the UI to represent the figure.
+ *
+ * The most important type of figure will be the Chart
+ */
+interface FigureContent {
+    Component: any;
+    SidePanelComponent?: string;
+}
+
+interface MenuPosition {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface Props$5 {
+    position: MenuPosition;
+    menuItems: FullMenuItem[];
+    depth: number;
+}
+interface MenuState {
+    isOpen: boolean;
+    position: null | MenuPosition;
+    scrollOffset?: number;
+    menuItems: FullMenuItem[];
+}
+declare class Menu extends Component$a<Props$5, SpreadsheetEnv> {
+    static template: string;
+    static components: {
+        Menu: typeof Menu;
+    };
+    static style: string;
+    static defaultProps: {
+        depth: number;
+    };
+    private subMenu;
+    private subMenuRef;
+    constructor();
+    get subMenuPosition(): MenuPosition;
+    private get renderRight();
+    private get renderBottom();
+    private get menuHeight();
+    get style(): string;
+    activateMenu(menu: FullMenuItem): void;
+    private close;
+    private menuVerticalPosition;
+    private subMenuHorizontalPosition;
+    private subMenuVerticalPosition;
+    /**
+     * Return the number of pixels between the top of the menu
+     * and the menu item at a given index.
+     */
+    private menuItemVerticalOffset;
+    private onClick;
+    private onContextMenu;
+    getName(menu: FullMenuItem): string;
+    isRoot(menu: FullMenuItem): boolean;
+    isEnabled(menu: FullMenuItem): boolean;
+    closeSubMenus(): void;
+    onScroll(ev: any): void;
+    /**
+     * If the given menu is not disabled, open it's submenu at the
+     * correct position according to available surrounding space.
+     */
+    openSubMenu(menu: FullMenuItem, position: number): void;
+    onClickMenu(menu: FullMenuItem, position: number): void;
+    onMouseOver(menu: FullMenuItem, position: number): void;
+}
+
+declare const Component$9: typeof owl.Component;
+declare class BottomBar extends Component$9<{}, SpreadsheetEnv> {
+    static template: string;
+    static style: string;
+    static components: {
+        Menu: typeof Menu;
+    };
+    getters: Getters;
+    menuState: MenuState;
+    mounted(): void;
+    patched(): void;
+    focusSheet(): void;
+    addSheet(): void;
+    listSheets(ev: MouseEvent): void;
+    activateSheet(name: string): void;
+    onDblClick(sheet: string): void;
+    openContextMenu(target: HTMLElement, registry: MenuItemRegistry): void;
+    onIconClick(sheet: string, ev: MouseEvent): void;
+    onContextMenu(sheet: string, ev: MouseEvent): void;
+}
+
+declare const Component$8: typeof owl.Component;
+interface Props$4 {
+    position: Position;
+    viewport: Viewport;
+}
+interface Position {
+    top: number;
+    left: number;
+}
+interface State$1 {
+    position: Position;
+    handler: boolean;
+}
+declare class Autofill extends Component$8<Props$4, SpreadsheetEnv> {
+    static template: string;
+    static style: string;
+    state: State$1;
+    get style(): string;
+    get styleHandler(): string;
+    get styleNextvalue(): string;
+    getTooltip(): Tooltip | undefined;
+    onMouseDown(ev: MouseEvent): void;
+    onDblClick(): void;
+}
+
+declare const functionCache: {
+    [key: string]: CompiledFormula;
+};
+
+/**
+ * Enriched Token is used by the composer to add information on the tokens that
+ * are only needed during the edition of a formula.
+ *
+ * The information added are:
+ * - parenthesis matching
+ * - range detection (replaces the tokens that composes the range with 1 token)
+ * - length, start and end of each token
+ */
+interface EnrichedToken extends Token {
+    start: number;
+    end: number;
+    length: number;
+    parenIndex?: number;
+}
+
+/**
+ * parses a formula (as a string) into the same formula,
+ * but with the references to other cells as well as strings and numbers extracted
+ *
+ * =sum(a3:b1) + c3 --> =sum(|0|) + |1|
+ *
+ * = sum(a3, 5) --> =sum(|0|, |N1|)
+ *
+ * =CONCAT(CONCAT(1, "beta"), A1) --> =CONCAT(CONCAT(|N0|, |S1|), |2|)
+ *
+ * Strings and Numbers are marked with a prefix of their type (S and N) to be detected
+ * as their normalized form by the parser as they won't be processed like the references by the compiler.
+ *
+ * @param formula
+ */
+declare function normalize(formula: string): NormalizedFormula;
+
+interface ASTBase {
+    debug?: boolean;
+}
+interface ASTNumber extends ASTBase {
+    type: "NUMBER";
+    value: number;
+}
+interface ASTNormalizedNumber extends ASTBase {
+    type: "NORMALIZED_NUMBER";
+    value: string;
+}
+interface ASTReference extends ASTBase {
+    type: "REFERENCE";
+    value: number;
+}
+interface ASTString extends ASTBase {
+    type: "STRING";
+    value: string;
+}
+interface ASTNormalizedString extends ASTBase {
+    type: "NORMALIZED_STRING";
+    value: string;
+}
+interface ASTBoolean extends ASTBase {
+    type: "BOOLEAN";
+    value: boolean;
+}
+interface ASTUnaryOperation extends ASTBase {
+    type: "UNARY_OPERATION";
+    value: any;
+    right: AST;
+}
+interface ASTOperation extends ASTBase {
+    type: "BIN_OPERATION";
+    value: any;
+    left: AST;
+    right: AST;
+}
+interface ASTFuncall extends ASTBase {
+    type: "FUNCALL";
+    value: string;
+    args: AST[];
+}
+interface ASTAsyncFuncall extends ASTBase {
+    type: "ASYNC_FUNCALL";
+    value: string;
+    args: AST[];
+}
+interface ASTUnknown extends ASTBase {
+    type: "UNKNOWN";
+    value: string;
+}
+declare type AST = ASTOperation | ASTUnaryOperation | ASTFuncall | ASTAsyncFuncall | ASTNumber | ASTBoolean | ASTString | ASTReference | ASTNormalizedNumber | ASTNormalizedString | ASTUnknown;
+/**
+ * Parse an expression (as a string) into an AST.
+ */
+declare function parse(str: NormalizedFormulaString): AST;
+/**
+ * Converts an ast formula to the corresponding string
+ */
+declare function astToFormula(ast: AST, dependencies: Dependencies): string;
+
+declare type TokenType = "OPERATOR" | "NUMBER" | "STRING" | "BOOLEAN" | "FUNCTION" | "SYMBOL" | "SPACE" | "DEBUGGER" | "COMMA" | "LEFT_PAREN" | "RIGHT_PAREN" | "REFERENCE" | "NORMALIZED_NUMBER" | "NORMALIZED_STRING" | "UNKNOWN";
+interface Token {
+    type: TokenType;
+    value: string;
+}
+
+declare const Component$7: typeof owl.Component;
+interface AutocompleteValue {
+    text: string;
+    description: string;
+}
+interface Props$3 {
+    provider: string;
+    filter?: (searchTerm: string, vals: AutocompleteValue[]) => AutocompleteValue[];
+    search: string;
+}
+declare abstract class TextValueProvider extends Component$7<Props$3> {
+    static template: string;
+    static style: string;
+    state: {
+        values: AutocompleteValue[];
+        selectedIndex: number;
+    };
+    mounted(): void;
+    willUpdateProps(nextProps: any): Promise<void>;
+    filter(searchTerm: string): Promise<void>;
+    fillValue(index: any): void;
+    moveDown(): void;
+    moveUp(): void;
+    getValueToFill(): string | void;
+}
+
+declare class ContentEditableHelper {
+    el: HTMLElement;
+    constructor(el: HTMLElement | null);
+    updateEl(el: HTMLElement): void;
+    /**
+     * select the text at position start to end, no matter the children
+     */
+    selectRange(start: number, end: number): void;
+    /**
+     * finds the dom element that contains the character at `offset`
+     */
+    private findChildAtCharacterIndex;
+    /**
+     * Iterate over the dom tree starting at `el` and over all the children depth first.
+     * */
+    private iterateChildren;
+    /**
+     * insert text at the current selection point. If a selection of 1 or more elements is done,
+     * the selection is replaced by the text to be inserted
+     * */
+    insertText(value: string, color?: string): void;
+    /**
+     * remove the current selection of the user
+     * */
+    removeSelection(): void;
+    removeAll(): void;
+    /**
+     * finds the indexes of the current selection.
+     * */
+    getCurrentSelection(): {
+        start: number;
+        end: number;
+    };
+    /**
+     * Computes the text 'index' inside this.el based on the currently selected node and its offset.
+     * The selected node is either a Text node or an Element node.
+     *
+     * case 1 -Text node:
+     * the offset is the number of characters from the start of the node. We have to add this offset to the
+     * content length of all previous nodes.
+     *
+     * case 2 - Element node:
+     * the offset is the number of child nodes before the selected node. We have to add the content length of
+     * all the bnodes prior to the selected node as well as the content of the child node before the offset.
+     *
+     * See the MDN documentation for more details.
+     * https://developer.mozilla.org/en-US/docs/Web/API/Range/startOffset
+     * https://developer.mozilla.org/en-US/docs/Web/API/Range/endOffset
+     *
+     */
+    private findSelectionIndex;
+    private getStartAndEndSelection;
+}
+
+declare const Component$6: typeof owl.Component;
+declare class Composer extends Component$6<any, SpreadsheetEnv> {
+    static template: string;
+    static style: string;
+    static components: {
+        TextValueProvider: typeof TextValueProvider;
+    };
+    private composerRef;
+    private autoCompleteRef;
+    getters: Getters;
+    dispatch: {
+        <T extends "UPDATE_CELL" | "RESIZE_COLUMNS" | "RESIZE_ROWS" | "CREATE_SHEET" | "MOVE_SHEET" | "RENAME_SHEET" | "DUPLICATE_SHEET" | "DELETE_SHEET" | "DELETE_SHEET_CONFIRMATION" | "ADD_MERGE" | "REMOVE_MERGE" | "SET_FORMATTING" | "CLEAR_FORMATTING" | "SET_FORMATTER" | "SET_DECIMAL" | "ADD_CONDITIONAL_FORMAT" | "REMOVE_CONDITIONAL_FORMAT" | "REMOVE_COLUMNS" | "REMOVE_ROWS" | "ADD_COLUMNS" | "ADD_ROWS" | "COPY" | "CUT" | "PASTE" | "PASTE_CELL" | "AUTOFILL_CELL" | "ACTIVATE_PAINT_FORMAT" | "PASTE_FROM_OS_CLIPBOARD" | "AUTORESIZE_COLUMNS" | "AUTORESIZE_ROWS" | "MOVE_POSITION" | "ACTIVATE_SHEET" | "SELECT_CELL" | "SET_SELECTION" | "START_SELECTION" | "PREPARE_SELECTION_EXPANSION" | "START_SELECTION_EXPANSION" | "STOP_SELECTION" | "HIGHLIGHT_SELECTION" | "ADD_PENDING_HIGHLIGHTS" | "RESET_PENDING_HIGHLIGHT" | "SET_HIGHLIGHT_COLOR" | "SELECT_COLUMN" | "SELECT_ROW" | "SELECT_ALL" | "ALTER_SELECTION" | "EVALUATE_CELLS" | "ADD_HIGHLIGHTS" | "REMOVE_HIGHLIGHTS" | "REMOVE_ALL_HIGHLIGHTS" | "START_COMPOSER_SELECTION" | "STOP_COMPOSER_SELECTION" | "START_EDITION" | "STOP_EDITION" | "SET_CURRENT_CONTENT" | "SET_VALUE" | "SET_FORMULA_VISIBILITY" | "DELETE_CONTENT" | "CLEAR_CELL" | "UNDO" | "REDO" | "START" | "AUTOFILL" | "AUTOFILL_SELECT" | "AUTOFILL_AUTO" | "ENABLE_NEW_SELECTION_INPUT" | "DISABLE_SELECTION_INPUT" | "FOCUS_RANGE" | "ADD_EMPTY_RANGE" | "REMOVE_RANGE" | "CHANGE_RANGE" | "CREATE_FIGURE" | "SELECT_FIGURE" | "UPDATE_FIGURE" | "DELETE_FIGURE" | "CREATE_CHART" | "UPDATE_CHART", C extends Extract<UpdateCellCommand, {
+            type: T;
+        }> | Extract<ResizeColumnsCommand, {
+            type: T;
+        }> | Extract<ResizeRowsCommand, {
+            type: T;
+        }> | Extract<CreateSheetCommand, {
+            type: T;
+        }> | Extract<MoveSheetCommand, {
+            type: T;
+        }> | Extract<RenameSheetCommand, {
+            type: T;
+        }> | Extract<DuplicateSheetCommand, {
+            type: T;
+        }> | Extract<DeleteSheetCommand, {
+            type: T;
+        }> | Extract<DeleteSheetConfirmationCommand, {
+            type: T;
+        }> | Extract<AddMergeCommand, {
+            type: T;
+        }> | Extract<RemoveMergeCommand, {
+            type: T;
+        }> | Extract<AddFormattingCommand, {
+            type: T;
+        }> | Extract<ClearFormattingCommand, {
+            type: T;
+        }> | Extract<SetFormatterCommand, {
+            type: T;
+        }> | Extract<SetDecimalCommand, {
+            type: T;
+        }> | Extract<AddConditionalFormatCommand, {
+            type: T;
+        }> | Extract<RemoveConditionalFormatCommand, {
+            type: T;
+        }> | Extract<RemoveColumnsCommand, {
+            type: T;
+        }> | Extract<RemoveRowsCommand, {
+            type: T;
+        }> | Extract<AddColumnsCommand, {
+            type: T;
+        }> | Extract<AddRowsCommand, {
+            type: T;
+        }> | Extract<CopyCommand, {
+            type: T;
+        }> | Extract<CutCommand, {
+            type: T;
+        }> | Extract<PasteCommand, {
+            type: T;
+        }> | Extract<PasteCellCommand, {
+            type: T;
+        }> | Extract<AutoFillCellCommand, {
+            type: T;
+        }> | Extract<ActivatePaintFormatCommand, {
+            type: T;
+        }> | Extract<PasteFromOSClipboardCommand, {
+            type: T;
+        }> | Extract<AutoresizeColumnsCommand, {
+            type: T;
+        }> | Extract<AutoresizeRowsCommand, {
+            type: T;
+        }> | Extract<MovePositionCommand, {
+            type: T;
+        }> | Extract<ActivateSheetCommand, {
+            type: T;
+        }> | Extract<SelectCellCommand, {
+            type: T;
+        }> | Extract<SetSelectionCommand, {
+            type: T;
+        }> | Extract<StartSelectionCommand, {
+            type: T;
+        }> | Extract<PrepareExpansionCommand, {
+            type: T;
+        }> | Extract<StartExpansionCommand, {
+            type: T;
+        }> | Extract<StopSelectionCommand, {
+            type: T;
+        }> | Extract<HighlightSelectionCommand, {
+            type: T;
+        }> | Extract<AddPendingHighlightCommand, {
+            type: T;
+        }> | Extract<ResetPendingHighlightCommand, {
+            type: T;
+        }> | Extract<SetColorCommand, {
+            type: T;
+        }> | Extract<SelectColumnCommand, {
+            type: T;
+        }> | Extract<SelectRowCommand, {
+            type: T;
+        }> | Extract<SelectAllCommand, {
+            type: T;
+        }> | Extract<AlterSelectionCommand, {
+            type: T;
+        }> | Extract<EvaluateCellsCommand, {
+            type: T;
+        }> | Extract<AddHighlightsCommand, {
+            type: T;
+        }> | Extract<RemoveHighlightsCommand, {
+            type: T;
+        }> | Extract<RemoveAllHighlightsCommand, {
+            type: T;
+        }> | Extract<StartComposerSelectionCommand, {
+            type: T;
+        }> | Extract<StopComposerSelectionCommand, {
+            type: T;
+        }> | Extract<StartEditionCommand, {
+            type: T;
+        }> | Extract<StopEditionCommand, {
+            type: T;
+        }> | Extract<SetCurrentContentCommand, {
+            type: T;
+        }> | Extract<SetValueCommand, {
+            type: T;
+        }> | Extract<ShowFormulaCommand, {
+            type: T;
+        }> | Extract<DeleteContentCommand, {
+            type: T;
+        }> | Extract<ClearCellCommand, {
+            type: T;
+        }> | Extract<UndoCommand, {
+            type: T;
+        }> | Extract<RedoCommand, {
+            type: T;
+        }> | Extract<StartCommand, {
+            type: T;
+        }> | Extract<AutofillCommand, {
+            type: T;
+        }> | Extract<AutofillSelectCommand, {
+            type: T;
+        }> | Extract<AutofillAutoCommand, {
+            type: T;
+        }> | Extract<NewInputCommand, {
+            type: T;
+        }> | Extract<RemoveInputCommand, {
+            type: T;
+        }> | Extract<FocusInputCommand, {
+            type: T;
+        }> | Extract<AddEmptyRangeCommand, {
+            type: T;
+        }> | Extract<RemoveRangeCommand, {
+            type: T;
+        }> | Extract<ChangeRangeCommand, {
+            type: T;
+        }> | Extract<CreateFigureCommand, {
+            type: T;
+        }> | Extract<SelectFigureCommand, {
+            type: T;
+        }> | Extract<UpdateFigureCommand, {
+            type: T;
+        }> | Extract<DeleteFigureCommand, {
+            type: T;
+        }> | Extract<CreateChartCommand, {
+            type: T;
+        }> | Extract<UpdateChartCommand, {
+            type: T;
+        }>>(type: {} extends Omit<C, "type"> ? T : never): CommandResult;
+        <T_1 extends "UPDATE_CELL" | "RESIZE_COLUMNS" | "RESIZE_ROWS" | "CREATE_SHEET" | "MOVE_SHEET" | "RENAME_SHEET" | "DUPLICATE_SHEET" | "DELETE_SHEET" | "DELETE_SHEET_CONFIRMATION" | "ADD_MERGE" | "REMOVE_MERGE" | "SET_FORMATTING" | "CLEAR_FORMATTING" | "SET_FORMATTER" | "SET_DECIMAL" | "ADD_CONDITIONAL_FORMAT" | "REMOVE_CONDITIONAL_FORMAT" | "REMOVE_COLUMNS" | "REMOVE_ROWS" | "ADD_COLUMNS" | "ADD_ROWS" | "COPY" | "CUT" | "PASTE" | "PASTE_CELL" | "AUTOFILL_CELL" | "ACTIVATE_PAINT_FORMAT" | "PASTE_FROM_OS_CLIPBOARD" | "AUTORESIZE_COLUMNS" | "AUTORESIZE_ROWS" | "MOVE_POSITION" | "ACTIVATE_SHEET" | "SELECT_CELL" | "SET_SELECTION" | "START_SELECTION" | "PREPARE_SELECTION_EXPANSION" | "START_SELECTION_EXPANSION" | "STOP_SELECTION" | "HIGHLIGHT_SELECTION" | "ADD_PENDING_HIGHLIGHTS" | "RESET_PENDING_HIGHLIGHT" | "SET_HIGHLIGHT_COLOR" | "SELECT_COLUMN" | "SELECT_ROW" | "SELECT_ALL" | "ALTER_SELECTION" | "EVALUATE_CELLS" | "ADD_HIGHLIGHTS" | "REMOVE_HIGHLIGHTS" | "REMOVE_ALL_HIGHLIGHTS" | "START_COMPOSER_SELECTION" | "STOP_COMPOSER_SELECTION" | "START_EDITION" | "STOP_EDITION" | "SET_CURRENT_CONTENT" | "SET_VALUE" | "SET_FORMULA_VISIBILITY" | "DELETE_CONTENT" | "CLEAR_CELL" | "UNDO" | "REDO" | "START" | "AUTOFILL" | "AUTOFILL_SELECT" | "AUTOFILL_AUTO" | "ENABLE_NEW_SELECTION_INPUT" | "DISABLE_SELECTION_INPUT" | "FOCUS_RANGE" | "ADD_EMPTY_RANGE" | "REMOVE_RANGE" | "CHANGE_RANGE" | "CREATE_FIGURE" | "SELECT_FIGURE" | "UPDATE_FIGURE" | "DELETE_FIGURE" | "CREATE_CHART" | "UPDATE_CHART", C_1 extends Extract<UpdateCellCommand, {
+            type: T_1;
+        }> | Extract<ResizeColumnsCommand, {
+            type: T_1;
+        }> | Extract<ResizeRowsCommand, {
+            type: T_1;
+        }> | Extract<CreateSheetCommand, {
+            type: T_1;
+        }> | Extract<MoveSheetCommand, {
+            type: T_1;
+        }> | Extract<RenameSheetCommand, {
+            type: T_1;
+        }> | Extract<DuplicateSheetCommand, {
+            type: T_1;
+        }> | Extract<DeleteSheetCommand, {
+            type: T_1;
+        }> | Extract<DeleteSheetConfirmationCommand, {
+            type: T_1;
+        }> | Extract<AddMergeCommand, {
+            type: T_1;
+        }> | Extract<RemoveMergeCommand, {
+            type: T_1;
+        }> | Extract<AddFormattingCommand, {
+            type: T_1;
+        }> | Extract<ClearFormattingCommand, {
+            type: T_1;
+        }> | Extract<SetFormatterCommand, {
+            type: T_1;
+        }> | Extract<SetDecimalCommand, {
+            type: T_1;
+        }> | Extract<AddConditionalFormatCommand, {
+            type: T_1;
+        }> | Extract<RemoveConditionalFormatCommand, {
+            type: T_1;
+        }> | Extract<RemoveColumnsCommand, {
+            type: T_1;
+        }> | Extract<RemoveRowsCommand, {
+            type: T_1;
+        }> | Extract<AddColumnsCommand, {
+            type: T_1;
+        }> | Extract<AddRowsCommand, {
+            type: T_1;
+        }> | Extract<CopyCommand, {
+            type: T_1;
+        }> | Extract<CutCommand, {
+            type: T_1;
+        }> | Extract<PasteCommand, {
+            type: T_1;
+        }> | Extract<PasteCellCommand, {
+            type: T_1;
+        }> | Extract<AutoFillCellCommand, {
+            type: T_1;
+        }> | Extract<ActivatePaintFormatCommand, {
+            type: T_1;
+        }> | Extract<PasteFromOSClipboardCommand, {
+            type: T_1;
+        }> | Extract<AutoresizeColumnsCommand, {
+            type: T_1;
+        }> | Extract<AutoresizeRowsCommand, {
+            type: T_1;
+        }> | Extract<MovePositionCommand, {
+            type: T_1;
+        }> | Extract<ActivateSheetCommand, {
+            type: T_1;
+        }> | Extract<SelectCellCommand, {
+            type: T_1;
+        }> | Extract<SetSelectionCommand, {
+            type: T_1;
+        }> | Extract<StartSelectionCommand, {
+            type: T_1;
+        }> | Extract<PrepareExpansionCommand, {
+            type: T_1;
+        }> | Extract<StartExpansionCommand, {
+            type: T_1;
+        }> | Extract<StopSelectionCommand, {
+            type: T_1;
+        }> | Extract<HighlightSelectionCommand, {
+            type: T_1;
+        }> | Extract<AddPendingHighlightCommand, {
+            type: T_1;
+        }> | Extract<ResetPendingHighlightCommand, {
+            type: T_1;
+        }> | Extract<SetColorCommand, {
+            type: T_1;
+        }> | Extract<SelectColumnCommand, {
+            type: T_1;
+        }> | Extract<SelectRowCommand, {
+            type: T_1;
+        }> | Extract<SelectAllCommand, {
+            type: T_1;
+        }> | Extract<AlterSelectionCommand, {
+            type: T_1;
+        }> | Extract<EvaluateCellsCommand, {
+            type: T_1;
+        }> | Extract<AddHighlightsCommand, {
+            type: T_1;
+        }> | Extract<RemoveHighlightsCommand, {
+            type: T_1;
+        }> | Extract<RemoveAllHighlightsCommand, {
+            type: T_1;
+        }> | Extract<StartComposerSelectionCommand, {
+            type: T_1;
+        }> | Extract<StopComposerSelectionCommand, {
+            type: T_1;
+        }> | Extract<StartEditionCommand, {
+            type: T_1;
+        }> | Extract<StopEditionCommand, {
+            type: T_1;
+        }> | Extract<SetCurrentContentCommand, {
+            type: T_1;
+        }> | Extract<SetValueCommand, {
+            type: T_1;
+        }> | Extract<ShowFormulaCommand, {
+            type: T_1;
+        }> | Extract<DeleteContentCommand, {
+            type: T_1;
+        }> | Extract<ClearCellCommand, {
+            type: T_1;
+        }> | Extract<UndoCommand, {
+            type: T_1;
+        }> | Extract<RedoCommand, {
+            type: T_1;
+        }> | Extract<StartCommand, {
+            type: T_1;
+        }> | Extract<AutofillCommand, {
+            type: T_1;
+        }> | Extract<AutofillSelectCommand, {
+            type: T_1;
+        }> | Extract<AutofillAutoCommand, {
+            type: T_1;
+        }> | Extract<NewInputCommand, {
+            type: T_1;
+        }> | Extract<RemoveInputCommand, {
+            type: T_1;
+        }> | Extract<FocusInputCommand, {
+            type: T_1;
+        }> | Extract<AddEmptyRangeCommand, {
+            type: T_1;
+        }> | Extract<RemoveRangeCommand, {
+            type: T_1;
+        }> | Extract<ChangeRangeCommand, {
+            type: T_1;
+        }> | Extract<CreateFigureCommand, {
+            type: T_1;
+        }> | Extract<SelectFigureCommand, {
+            type: T_1;
+        }> | Extract<UpdateFigureCommand, {
+            type: T_1;
+        }> | Extract<DeleteFigureCommand, {
+            type: T_1;
+        }> | Extract<CreateChartCommand, {
+            type: T_1;
+        }> | Extract<UpdateChartCommand, {
+            type: T_1;
+        }>>(type: T_1, r: Omit<C_1, "type">): CommandResult;
+    };
+    zone: Zone;
+    rect: Rect;
+    selectionEnd: number;
+    selectionStart: number;
+    contentHelper: ContentEditableHelper;
+    autoCompleteState: {
+        showProvider: boolean;
+        provider: string;
+        search: string;
+    };
+    tokenAtCursor: EnrichedToken | void;
+    shouldProcessInputEvents: boolean;
+    isDone: boolean;
+    refSelectionStart: number;
+    tokens: EnrichedToken[];
+    keyMapping: {
+        [key: string]: Function;
+    };
+    constructor();
+    mounted(): void;
+    willUnmount(): void;
+    get containerStyle(): string;
+    get composerStyle(): string;
+    processArrowKeys(ev: KeyboardEvent): void;
+    processTabKey(ev: KeyboardEvent): void;
+    processEnterKey(ev: KeyboardEvent): void;
+    processEscapeKey(): void;
+    onKeydown(ev: KeyboardEvent): any;
+    onInput(ev: KeyboardEvent): void;
+    onKeyup(ev: KeyboardEvent): void;
+    onClick(ev: MouseEvent): void;
+    onCompleted(ev: CustomEvent): void;
+    processContent(): void;
+    /**
+     * Compute the state of the composer from the tokenAtCursor.
+     * If the token is a bool, function or symbol we have to initialize the autocomplete engine.
+     * If it's a comma, left_paren or operator we have to initialize the range selection.
+     */
+    processTokenAtCursor(): void;
+    addText(text: string): void;
+    addTextFromSelection(): void;
+    autoComplete(value: string): void;
+    /**
+     * Save the current selection
+     */
+    saveSelection(): void;
+}
+
+interface FigureInfo {
+    id: string;
+    isSelected: boolean;
+    figure: Figure<any>;
+}
+declare class FiguresContainer extends Component$a<{
+    viewport: Viewport;
+}, SpreadsheetEnv> {
+    static template: string;
+    static style: string;
+    static components: {};
+    figureRegistry: Registry<FigureContent>;
+    dnd: {
+        figureId: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    getters: Getters;
+    dispatch: {
+        <T extends "UPDATE_CELL" | "RESIZE_COLUMNS" | "RESIZE_ROWS" | "CREATE_SHEET" | "MOVE_SHEET" | "RENAME_SHEET" | "DUPLICATE_SHEET" | "DELETE_SHEET" | "DELETE_SHEET_CONFIRMATION" | "ADD_MERGE" | "REMOVE_MERGE" | "SET_FORMATTING" | "CLEAR_FORMATTING" | "SET_FORMATTER" | "SET_DECIMAL" | "ADD_CONDITIONAL_FORMAT" | "REMOVE_CONDITIONAL_FORMAT" | "REMOVE_COLUMNS" | "REMOVE_ROWS" | "ADD_COLUMNS" | "ADD_ROWS" | "COPY" | "CUT" | "PASTE" | "PASTE_CELL" | "AUTOFILL_CELL" | "ACTIVATE_PAINT_FORMAT" | "PASTE_FROM_OS_CLIPBOARD" | "AUTORESIZE_COLUMNS" | "AUTORESIZE_ROWS" | "MOVE_POSITION" | "ACTIVATE_SHEET" | "SELECT_CELL" | "SET_SELECTION" | "START_SELECTION" | "PREPARE_SELECTION_EXPANSION" | "START_SELECTION_EXPANSION" | "STOP_SELECTION" | "HIGHLIGHT_SELECTION" | "ADD_PENDING_HIGHLIGHTS" | "RESET_PENDING_HIGHLIGHT" | "SET_HIGHLIGHT_COLOR" | "SELECT_COLUMN" | "SELECT_ROW" | "SELECT_ALL" | "ALTER_SELECTION" | "EVALUATE_CELLS" | "ADD_HIGHLIGHTS" | "REMOVE_HIGHLIGHTS" | "REMOVE_ALL_HIGHLIGHTS" | "START_COMPOSER_SELECTION" | "STOP_COMPOSER_SELECTION" | "START_EDITION" | "STOP_EDITION" | "SET_CURRENT_CONTENT" | "SET_VALUE" | "SET_FORMULA_VISIBILITY" | "DELETE_CONTENT" | "CLEAR_CELL" | "UNDO" | "REDO" | "START" | "AUTOFILL" | "AUTOFILL_SELECT" | "AUTOFILL_AUTO" | "ENABLE_NEW_SELECTION_INPUT" | "DISABLE_SELECTION_INPUT" | "FOCUS_RANGE" | "ADD_EMPTY_RANGE" | "REMOVE_RANGE" | "CHANGE_RANGE" | "CREATE_FIGURE" | "SELECT_FIGURE" | "UPDATE_FIGURE" | "DELETE_FIGURE" | "CREATE_CHART" | "UPDATE_CHART", C extends Extract<UpdateCellCommand, {
+            type: T;
+        }> | Extract<ResizeColumnsCommand, {
+            type: T;
+        }> | Extract<ResizeRowsCommand, {
+            type: T;
+        }> | Extract<CreateSheetCommand, {
+            type: T;
+        }> | Extract<MoveSheetCommand, {
+            type: T;
+        }> | Extract<RenameSheetCommand, {
+            type: T;
+        }> | Extract<DuplicateSheetCommand, {
+            type: T;
+        }> | Extract<DeleteSheetCommand, {
+            type: T;
+        }> | Extract<DeleteSheetConfirmationCommand, {
+            type: T;
+        }> | Extract<AddMergeCommand, {
+            type: T;
+        }> | Extract<RemoveMergeCommand, {
+            type: T;
+        }> | Extract<AddFormattingCommand, {
+            type: T;
+        }> | Extract<ClearFormattingCommand, {
+            type: T;
+        }> | Extract<SetFormatterCommand, {
+            type: T;
+        }> | Extract<SetDecimalCommand, {
+            type: T;
+        }> | Extract<AddConditionalFormatCommand, {
+            type: T;
+        }> | Extract<RemoveConditionalFormatCommand, {
+            type: T;
+        }> | Extract<RemoveColumnsCommand, {
+            type: T;
+        }> | Extract<RemoveRowsCommand, {
+            type: T;
+        }> | Extract<AddColumnsCommand, {
+            type: T;
+        }> | Extract<AddRowsCommand, {
+            type: T;
+        }> | Extract<CopyCommand, {
+            type: T;
+        }> | Extract<CutCommand, {
+            type: T;
+        }> | Extract<PasteCommand, {
+            type: T;
+        }> | Extract<PasteCellCommand, {
+            type: T;
+        }> | Extract<AutoFillCellCommand, {
+            type: T;
+        }> | Extract<ActivatePaintFormatCommand, {
+            type: T;
+        }> | Extract<PasteFromOSClipboardCommand, {
+            type: T;
+        }> | Extract<AutoresizeColumnsCommand, {
+            type: T;
+        }> | Extract<AutoresizeRowsCommand, {
+            type: T;
+        }> | Extract<MovePositionCommand, {
+            type: T;
+        }> | Extract<ActivateSheetCommand, {
+            type: T;
+        }> | Extract<SelectCellCommand, {
+            type: T;
+        }> | Extract<SetSelectionCommand, {
+            type: T;
+        }> | Extract<StartSelectionCommand, {
+            type: T;
+        }> | Extract<PrepareExpansionCommand, {
+            type: T;
+        }> | Extract<StartExpansionCommand, {
+            type: T;
+        }> | Extract<StopSelectionCommand, {
+            type: T;
+        }> | Extract<HighlightSelectionCommand, {
+            type: T;
+        }> | Extract<AddPendingHighlightCommand, {
+            type: T;
+        }> | Extract<ResetPendingHighlightCommand, {
+            type: T;
+        }> | Extract<SetColorCommand, {
+            type: T;
+        }> | Extract<SelectColumnCommand, {
+            type: T;
+        }> | Extract<SelectRowCommand, {
+            type: T;
+        }> | Extract<SelectAllCommand, {
+            type: T;
+        }> | Extract<AlterSelectionCommand, {
+            type: T;
+        }> | Extract<EvaluateCellsCommand, {
+            type: T;
+        }> | Extract<AddHighlightsCommand, {
+            type: T;
+        }> | Extract<RemoveHighlightsCommand, {
+            type: T;
+        }> | Extract<RemoveAllHighlightsCommand, {
+            type: T;
+        }> | Extract<StartComposerSelectionCommand, {
+            type: T;
+        }> | Extract<StopComposerSelectionCommand, {
+            type: T;
+        }> | Extract<StartEditionCommand, {
+            type: T;
+        }> | Extract<StopEditionCommand, {
+            type: T;
+        }> | Extract<SetCurrentContentCommand, {
+            type: T;
+        }> | Extract<SetValueCommand, {
+            type: T;
+        }> | Extract<ShowFormulaCommand, {
+            type: T;
+        }> | Extract<DeleteContentCommand, {
+            type: T;
+        }> | Extract<ClearCellCommand, {
+            type: T;
+        }> | Extract<UndoCommand, {
+            type: T;
+        }> | Extract<RedoCommand, {
+            type: T;
+        }> | Extract<StartCommand, {
+            type: T;
+        }> | Extract<AutofillCommand, {
+            type: T;
+        }> | Extract<AutofillSelectCommand, {
+            type: T;
+        }> | Extract<AutofillAutoCommand, {
+            type: T;
+        }> | Extract<NewInputCommand, {
+            type: T;
+        }> | Extract<RemoveInputCommand, {
+            type: T;
+        }> | Extract<FocusInputCommand, {
+            type: T;
+        }> | Extract<AddEmptyRangeCommand, {
+            type: T;
+        }> | Extract<RemoveRangeCommand, {
+            type: T;
+        }> | Extract<ChangeRangeCommand, {
+            type: T;
+        }> | Extract<CreateFigureCommand, {
+            type: T;
+        }> | Extract<SelectFigureCommand, {
+            type: T;
+        }> | Extract<UpdateFigureCommand, {
+            type: T;
+        }> | Extract<DeleteFigureCommand, {
+            type: T;
+        }> | Extract<CreateChartCommand, {
+            type: T;
+        }> | Extract<UpdateChartCommand, {
+            type: T;
+        }>>(type: {} extends Omit<C, "type"> ? T : never): CommandResult;
+        <T_1 extends "UPDATE_CELL" | "RESIZE_COLUMNS" | "RESIZE_ROWS" | "CREATE_SHEET" | "MOVE_SHEET" | "RENAME_SHEET" | "DUPLICATE_SHEET" | "DELETE_SHEET" | "DELETE_SHEET_CONFIRMATION" | "ADD_MERGE" | "REMOVE_MERGE" | "SET_FORMATTING" | "CLEAR_FORMATTING" | "SET_FORMATTER" | "SET_DECIMAL" | "ADD_CONDITIONAL_FORMAT" | "REMOVE_CONDITIONAL_FORMAT" | "REMOVE_COLUMNS" | "REMOVE_ROWS" | "ADD_COLUMNS" | "ADD_ROWS" | "COPY" | "CUT" | "PASTE" | "PASTE_CELL" | "AUTOFILL_CELL" | "ACTIVATE_PAINT_FORMAT" | "PASTE_FROM_OS_CLIPBOARD" | "AUTORESIZE_COLUMNS" | "AUTORESIZE_ROWS" | "MOVE_POSITION" | "ACTIVATE_SHEET" | "SELECT_CELL" | "SET_SELECTION" | "START_SELECTION" | "PREPARE_SELECTION_EXPANSION" | "START_SELECTION_EXPANSION" | "STOP_SELECTION" | "HIGHLIGHT_SELECTION" | "ADD_PENDING_HIGHLIGHTS" | "RESET_PENDING_HIGHLIGHT" | "SET_HIGHLIGHT_COLOR" | "SELECT_COLUMN" | "SELECT_ROW" | "SELECT_ALL" | "ALTER_SELECTION" | "EVALUATE_CELLS" | "ADD_HIGHLIGHTS" | "REMOVE_HIGHLIGHTS" | "REMOVE_ALL_HIGHLIGHTS" | "START_COMPOSER_SELECTION" | "STOP_COMPOSER_SELECTION" | "START_EDITION" | "STOP_EDITION" | "SET_CURRENT_CONTENT" | "SET_VALUE" | "SET_FORMULA_VISIBILITY" | "DELETE_CONTENT" | "CLEAR_CELL" | "UNDO" | "REDO" | "START" | "AUTOFILL" | "AUTOFILL_SELECT" | "AUTOFILL_AUTO" | "ENABLE_NEW_SELECTION_INPUT" | "DISABLE_SELECTION_INPUT" | "FOCUS_RANGE" | "ADD_EMPTY_RANGE" | "REMOVE_RANGE" | "CHANGE_RANGE" | "CREATE_FIGURE" | "SELECT_FIGURE" | "UPDATE_FIGURE" | "DELETE_FIGURE" | "CREATE_CHART" | "UPDATE_CHART", C_1 extends Extract<UpdateCellCommand, {
+            type: T_1;
+        }> | Extract<ResizeColumnsCommand, {
+            type: T_1;
+        }> | Extract<ResizeRowsCommand, {
+            type: T_1;
+        }> | Extract<CreateSheetCommand, {
+            type: T_1;
+        }> | Extract<MoveSheetCommand, {
+            type: T_1;
+        }> | Extract<RenameSheetCommand, {
+            type: T_1;
+        }> | Extract<DuplicateSheetCommand, {
+            type: T_1;
+        }> | Extract<DeleteSheetCommand, {
+            type: T_1;
+        }> | Extract<DeleteSheetConfirmationCommand, {
+            type: T_1;
+        }> | Extract<AddMergeCommand, {
+            type: T_1;
+        }> | Extract<RemoveMergeCommand, {
+            type: T_1;
+        }> | Extract<AddFormattingCommand, {
+            type: T_1;
+        }> | Extract<ClearFormattingCommand, {
+            type: T_1;
+        }> | Extract<SetFormatterCommand, {
+            type: T_1;
+        }> | Extract<SetDecimalCommand, {
+            type: T_1;
+        }> | Extract<AddConditionalFormatCommand, {
+            type: T_1;
+        }> | Extract<RemoveConditionalFormatCommand, {
+            type: T_1;
+        }> | Extract<RemoveColumnsCommand, {
+            type: T_1;
+        }> | Extract<RemoveRowsCommand, {
+            type: T_1;
+        }> | Extract<AddColumnsCommand, {
+            type: T_1;
+        }> | Extract<AddRowsCommand, {
+            type: T_1;
+        }> | Extract<CopyCommand, {
+            type: T_1;
+        }> | Extract<CutCommand, {
+            type: T_1;
+        }> | Extract<PasteCommand, {
+            type: T_1;
+        }> | Extract<PasteCellCommand, {
+            type: T_1;
+        }> | Extract<AutoFillCellCommand, {
+            type: T_1;
+        }> | Extract<ActivatePaintFormatCommand, {
+            type: T_1;
+        }> | Extract<PasteFromOSClipboardCommand, {
+            type: T_1;
+        }> | Extract<AutoresizeColumnsCommand, {
+            type: T_1;
+        }> | Extract<AutoresizeRowsCommand, {
+            type: T_1;
+        }> | Extract<MovePositionCommand, {
+            type: T_1;
+        }> | Extract<ActivateSheetCommand, {
+            type: T_1;
+        }> | Extract<SelectCellCommand, {
+            type: T_1;
+        }> | Extract<SetSelectionCommand, {
+            type: T_1;
+        }> | Extract<StartSelectionCommand, {
+            type: T_1;
+        }> | Extract<PrepareExpansionCommand, {
+            type: T_1;
+        }> | Extract<StartExpansionCommand, {
+            type: T_1;
+        }> | Extract<StopSelectionCommand, {
+            type: T_1;
+        }> | Extract<HighlightSelectionCommand, {
+            type: T_1;
+        }> | Extract<AddPendingHighlightCommand, {
+            type: T_1;
+        }> | Extract<ResetPendingHighlightCommand, {
+            type: T_1;
+        }> | Extract<SetColorCommand, {
+            type: T_1;
+        }> | Extract<SelectColumnCommand, {
+            type: T_1;
+        }> | Extract<SelectRowCommand, {
+            type: T_1;
+        }> | Extract<SelectAllCommand, {
+            type: T_1;
+        }> | Extract<AlterSelectionCommand, {
+            type: T_1;
+        }> | Extract<EvaluateCellsCommand, {
+            type: T_1;
+        }> | Extract<AddHighlightsCommand, {
+            type: T_1;
+        }> | Extract<RemoveHighlightsCommand, {
+            type: T_1;
+        }> | Extract<RemoveAllHighlightsCommand, {
+            type: T_1;
+        }> | Extract<StartComposerSelectionCommand, {
+            type: T_1;
+        }> | Extract<StopComposerSelectionCommand, {
+            type: T_1;
+        }> | Extract<StartEditionCommand, {
+            type: T_1;
+        }> | Extract<StopEditionCommand, {
+            type: T_1;
+        }> | Extract<SetCurrentContentCommand, {
+            type: T_1;
+        }> | Extract<SetValueCommand, {
+            type: T_1;
+        }> | Extract<ShowFormulaCommand, {
+            type: T_1;
+        }> | Extract<DeleteContentCommand, {
+            type: T_1;
+        }> | Extract<ClearCellCommand, {
+            type: T_1;
+        }> | Extract<UndoCommand, {
+            type: T_1;
+        }> | Extract<RedoCommand, {
+            type: T_1;
+        }> | Extract<StartCommand, {
+            type: T_1;
+        }> | Extract<AutofillCommand, {
+            type: T_1;
+        }> | Extract<AutofillSelectCommand, {
+            type: T_1;
+        }> | Extract<AutofillAutoCommand, {
+            type: T_1;
+        }> | Extract<NewInputCommand, {
+            type: T_1;
+        }> | Extract<RemoveInputCommand, {
+            type: T_1;
+        }> | Extract<FocusInputCommand, {
+            type: T_1;
+        }> | Extract<AddEmptyRangeCommand, {
+            type: T_1;
+        }> | Extract<RemoveRangeCommand, {
+            type: T_1;
+        }> | Extract<ChangeRangeCommand, {
+            type: T_1;
+        }> | Extract<CreateFigureCommand, {
+            type: T_1;
+        }> | Extract<SelectFigureCommand, {
+            type: T_1;
+        }> | Extract<UpdateFigureCommand, {
+            type: T_1;
+        }> | Extract<DeleteFigureCommand, {
+            type: T_1;
+        }> | Extract<CreateChartCommand, {
+            type: T_1;
+        }> | Extract<UpdateChartCommand, {
+            type: T_1;
+        }>>(type: T_1, r: Omit<C_1, "type">): CommandResult;
+    };
+    getFigures(): FigureInfo[];
+    getDims(info: FigureInfo): string;
+    getStyle(info: FigureInfo): string;
+    mounted(): void;
+    resize(figure: Figure<any>, dirX: number, dirY: number, ev: MouseEvent): void;
+    onMouseDown(figure: Figure<any>, ev: MouseEvent): void;
+    onKeyDown(figure: Figure<any>, ev: KeyboardEvent): void;
+}
+
+declare const Component$5: typeof owl.Component;
+declare abstract class AbstractResizer extends Component$5<any, SpreadsheetEnv> {
+    PADDING: number;
+    MAX_SIZE_MARGIN: number;
+    MIN_ELEMENT_SIZE: number;
+    lastSelectedElement: number | null;
+    lastElement: number | null;
+    getters: Getters;
+    dispatch: {
+        <T extends "UPDATE_CELL" | "RESIZE_COLUMNS" | "RESIZE_ROWS" | "CREATE_SHEET" | "MOVE_SHEET" | "RENAME_SHEET" | "DUPLICATE_SHEET" | "DELETE_SHEET" | "DELETE_SHEET_CONFIRMATION" | "ADD_MERGE" | "REMOVE_MERGE" | "SET_FORMATTING" | "CLEAR_FORMATTING" | "SET_FORMATTER" | "SET_DECIMAL" | "ADD_CONDITIONAL_FORMAT" | "REMOVE_CONDITIONAL_FORMAT" | "REMOVE_COLUMNS" | "REMOVE_ROWS" | "ADD_COLUMNS" | "ADD_ROWS" | "COPY" | "CUT" | "PASTE" | "PASTE_CELL" | "AUTOFILL_CELL" | "ACTIVATE_PAINT_FORMAT" | "PASTE_FROM_OS_CLIPBOARD" | "AUTORESIZE_COLUMNS" | "AUTORESIZE_ROWS" | "MOVE_POSITION" | "ACTIVATE_SHEET" | "SELECT_CELL" | "SET_SELECTION" | "START_SELECTION" | "PREPARE_SELECTION_EXPANSION" | "START_SELECTION_EXPANSION" | "STOP_SELECTION" | "HIGHLIGHT_SELECTION" | "ADD_PENDING_HIGHLIGHTS" | "RESET_PENDING_HIGHLIGHT" | "SET_HIGHLIGHT_COLOR" | "SELECT_COLUMN" | "SELECT_ROW" | "SELECT_ALL" | "ALTER_SELECTION" | "EVALUATE_CELLS" | "ADD_HIGHLIGHTS" | "REMOVE_HIGHLIGHTS" | "REMOVE_ALL_HIGHLIGHTS" | "START_COMPOSER_SELECTION" | "STOP_COMPOSER_SELECTION" | "START_EDITION" | "STOP_EDITION" | "SET_CURRENT_CONTENT" | "SET_VALUE" | "SET_FORMULA_VISIBILITY" | "DELETE_CONTENT" | "CLEAR_CELL" | "UNDO" | "REDO" | "START" | "AUTOFILL" | "AUTOFILL_SELECT" | "AUTOFILL_AUTO" | "ENABLE_NEW_SELECTION_INPUT" | "DISABLE_SELECTION_INPUT" | "FOCUS_RANGE" | "ADD_EMPTY_RANGE" | "REMOVE_RANGE" | "CHANGE_RANGE" | "CREATE_FIGURE" | "SELECT_FIGURE" | "UPDATE_FIGURE" | "DELETE_FIGURE" | "CREATE_CHART" | "UPDATE_CHART", C extends Extract<UpdateCellCommand, {
+            type: T;
+        }> | Extract<ResizeColumnsCommand, {
+            type: T;
+        }> | Extract<ResizeRowsCommand, {
+            type: T;
+        }> | Extract<CreateSheetCommand, {
+            type: T;
+        }> | Extract<MoveSheetCommand, {
+            type: T;
+        }> | Extract<RenameSheetCommand, {
+            type: T;
+        }> | Extract<DuplicateSheetCommand, {
+            type: T;
+        }> | Extract<DeleteSheetCommand, {
+            type: T;
+        }> | Extract<DeleteSheetConfirmationCommand, {
+            type: T;
+        }> | Extract<AddMergeCommand, {
+            type: T;
+        }> | Extract<RemoveMergeCommand, {
+            type: T;
+        }> | Extract<AddFormattingCommand, {
+            type: T;
+        }> | Extract<ClearFormattingCommand, {
+            type: T;
+        }> | Extract<SetFormatterCommand, {
+            type: T;
+        }> | Extract<SetDecimalCommand, {
+            type: T;
+        }> | Extract<AddConditionalFormatCommand, {
+            type: T;
+        }> | Extract<RemoveConditionalFormatCommand, {
+            type: T;
+        }> | Extract<RemoveColumnsCommand, {
+            type: T;
+        }> | Extract<RemoveRowsCommand, {
+            type: T;
+        }> | Extract<AddColumnsCommand, {
+            type: T;
+        }> | Extract<AddRowsCommand, {
+            type: T;
+        }> | Extract<CopyCommand, {
+            type: T;
+        }> | Extract<CutCommand, {
+            type: T;
+        }> | Extract<PasteCommand, {
+            type: T;
+        }> | Extract<PasteCellCommand, {
+            type: T;
+        }> | Extract<AutoFillCellCommand, {
+            type: T;
+        }> | Extract<ActivatePaintFormatCommand, {
+            type: T;
+        }> | Extract<PasteFromOSClipboardCommand, {
+            type: T;
+        }> | Extract<AutoresizeColumnsCommand, {
+            type: T;
+        }> | Extract<AutoresizeRowsCommand, {
+            type: T;
+        }> | Extract<MovePositionCommand, {
+            type: T;
+        }> | Extract<ActivateSheetCommand, {
+            type: T;
+        }> | Extract<SelectCellCommand, {
+            type: T;
+        }> | Extract<SetSelectionCommand, {
+            type: T;
+        }> | Extract<StartSelectionCommand, {
+            type: T;
+        }> | Extract<PrepareExpansionCommand, {
+            type: T;
+        }> | Extract<StartExpansionCommand, {
+            type: T;
+        }> | Extract<StopSelectionCommand, {
+            type: T;
+        }> | Extract<HighlightSelectionCommand, {
+            type: T;
+        }> | Extract<AddPendingHighlightCommand, {
+            type: T;
+        }> | Extract<ResetPendingHighlightCommand, {
+            type: T;
+        }> | Extract<SetColorCommand, {
+            type: T;
+        }> | Extract<SelectColumnCommand, {
+            type: T;
+        }> | Extract<SelectRowCommand, {
+            type: T;
+        }> | Extract<SelectAllCommand, {
+            type: T;
+        }> | Extract<AlterSelectionCommand, {
+            type: T;
+        }> | Extract<EvaluateCellsCommand, {
+            type: T;
+        }> | Extract<AddHighlightsCommand, {
+            type: T;
+        }> | Extract<RemoveHighlightsCommand, {
+            type: T;
+        }> | Extract<RemoveAllHighlightsCommand, {
+            type: T;
+        }> | Extract<StartComposerSelectionCommand, {
+            type: T;
+        }> | Extract<StopComposerSelectionCommand, {
+            type: T;
+        }> | Extract<StartEditionCommand, {
+            type: T;
+        }> | Extract<StopEditionCommand, {
+            type: T;
+        }> | Extract<SetCurrentContentCommand, {
+            type: T;
+        }> | Extract<SetValueCommand, {
+            type: T;
+        }> | Extract<ShowFormulaCommand, {
+            type: T;
+        }> | Extract<DeleteContentCommand, {
+            type: T;
+        }> | Extract<ClearCellCommand, {
+            type: T;
+        }> | Extract<UndoCommand, {
+            type: T;
+        }> | Extract<RedoCommand, {
+            type: T;
+        }> | Extract<StartCommand, {
+            type: T;
+        }> | Extract<AutofillCommand, {
+            type: T;
+        }> | Extract<AutofillSelectCommand, {
+            type: T;
+        }> | Extract<AutofillAutoCommand, {
+            type: T;
+        }> | Extract<NewInputCommand, {
+            type: T;
+        }> | Extract<RemoveInputCommand, {
+            type: T;
+        }> | Extract<FocusInputCommand, {
+            type: T;
+        }> | Extract<AddEmptyRangeCommand, {
+            type: T;
+        }> | Extract<RemoveRangeCommand, {
+            type: T;
+        }> | Extract<ChangeRangeCommand, {
+            type: T;
+        }> | Extract<CreateFigureCommand, {
+            type: T;
+        }> | Extract<SelectFigureCommand, {
+            type: T;
+        }> | Extract<UpdateFigureCommand, {
+            type: T;
+        }> | Extract<DeleteFigureCommand, {
+            type: T;
+        }> | Extract<CreateChartCommand, {
+            type: T;
+        }> | Extract<UpdateChartCommand, {
+            type: T;
+        }>>(type: {} extends Omit<C, "type"> ? T : never): CommandResult;
+        <T_1 extends "UPDATE_CELL" | "RESIZE_COLUMNS" | "RESIZE_ROWS" | "CREATE_SHEET" | "MOVE_SHEET" | "RENAME_SHEET" | "DUPLICATE_SHEET" | "DELETE_SHEET" | "DELETE_SHEET_CONFIRMATION" | "ADD_MERGE" | "REMOVE_MERGE" | "SET_FORMATTING" | "CLEAR_FORMATTING" | "SET_FORMATTER" | "SET_DECIMAL" | "ADD_CONDITIONAL_FORMAT" | "REMOVE_CONDITIONAL_FORMAT" | "REMOVE_COLUMNS" | "REMOVE_ROWS" | "ADD_COLUMNS" | "ADD_ROWS" | "COPY" | "CUT" | "PASTE" | "PASTE_CELL" | "AUTOFILL_CELL" | "ACTIVATE_PAINT_FORMAT" | "PASTE_FROM_OS_CLIPBOARD" | "AUTORESIZE_COLUMNS" | "AUTORESIZE_ROWS" | "MOVE_POSITION" | "ACTIVATE_SHEET" | "SELECT_CELL" | "SET_SELECTION" | "START_SELECTION" | "PREPARE_SELECTION_EXPANSION" | "START_SELECTION_EXPANSION" | "STOP_SELECTION" | "HIGHLIGHT_SELECTION" | "ADD_PENDING_HIGHLIGHTS" | "RESET_PENDING_HIGHLIGHT" | "SET_HIGHLIGHT_COLOR" | "SELECT_COLUMN" | "SELECT_ROW" | "SELECT_ALL" | "ALTER_SELECTION" | "EVALUATE_CELLS" | "ADD_HIGHLIGHTS" | "REMOVE_HIGHLIGHTS" | "REMOVE_ALL_HIGHLIGHTS" | "START_COMPOSER_SELECTION" | "STOP_COMPOSER_SELECTION" | "START_EDITION" | "STOP_EDITION" | "SET_CURRENT_CONTENT" | "SET_VALUE" | "SET_FORMULA_VISIBILITY" | "DELETE_CONTENT" | "CLEAR_CELL" | "UNDO" | "REDO" | "START" | "AUTOFILL" | "AUTOFILL_SELECT" | "AUTOFILL_AUTO" | "ENABLE_NEW_SELECTION_INPUT" | "DISABLE_SELECTION_INPUT" | "FOCUS_RANGE" | "ADD_EMPTY_RANGE" | "REMOVE_RANGE" | "CHANGE_RANGE" | "CREATE_FIGURE" | "SELECT_FIGURE" | "UPDATE_FIGURE" | "DELETE_FIGURE" | "CREATE_CHART" | "UPDATE_CHART", C_1 extends Extract<UpdateCellCommand, {
+            type: T_1;
+        }> | Extract<ResizeColumnsCommand, {
+            type: T_1;
+        }> | Extract<ResizeRowsCommand, {
+            type: T_1;
+        }> | Extract<CreateSheetCommand, {
+            type: T_1;
+        }> | Extract<MoveSheetCommand, {
+            type: T_1;
+        }> | Extract<RenameSheetCommand, {
+            type: T_1;
+        }> | Extract<DuplicateSheetCommand, {
+            type: T_1;
+        }> | Extract<DeleteSheetCommand, {
+            type: T_1;
+        }> | Extract<DeleteSheetConfirmationCommand, {
+            type: T_1;
+        }> | Extract<AddMergeCommand, {
+            type: T_1;
+        }> | Extract<RemoveMergeCommand, {
+            type: T_1;
+        }> | Extract<AddFormattingCommand, {
+            type: T_1;
+        }> | Extract<ClearFormattingCommand, {
+            type: T_1;
+        }> | Extract<SetFormatterCommand, {
+            type: T_1;
+        }> | Extract<SetDecimalCommand, {
+            type: T_1;
+        }> | Extract<AddConditionalFormatCommand, {
+            type: T_1;
+        }> | Extract<RemoveConditionalFormatCommand, {
+            type: T_1;
+        }> | Extract<RemoveColumnsCommand, {
+            type: T_1;
+        }> | Extract<RemoveRowsCommand, {
+            type: T_1;
+        }> | Extract<AddColumnsCommand, {
+            type: T_1;
+        }> | Extract<AddRowsCommand, {
+            type: T_1;
+        }> | Extract<CopyCommand, {
+            type: T_1;
+        }> | Extract<CutCommand, {
+            type: T_1;
+        }> | Extract<PasteCommand, {
+            type: T_1;
+        }> | Extract<PasteCellCommand, {
+            type: T_1;
+        }> | Extract<AutoFillCellCommand, {
+            type: T_1;
+        }> | Extract<ActivatePaintFormatCommand, {
+            type: T_1;
+        }> | Extract<PasteFromOSClipboardCommand, {
+            type: T_1;
+        }> | Extract<AutoresizeColumnsCommand, {
+            type: T_1;
+        }> | Extract<AutoresizeRowsCommand, {
+            type: T_1;
+        }> | Extract<MovePositionCommand, {
+            type: T_1;
+        }> | Extract<ActivateSheetCommand, {
+            type: T_1;
+        }> | Extract<SelectCellCommand, {
+            type: T_1;
+        }> | Extract<SetSelectionCommand, {
+            type: T_1;
+        }> | Extract<StartSelectionCommand, {
+            type: T_1;
+        }> | Extract<PrepareExpansionCommand, {
+            type: T_1;
+        }> | Extract<StartExpansionCommand, {
+            type: T_1;
+        }> | Extract<StopSelectionCommand, {
+            type: T_1;
+        }> | Extract<HighlightSelectionCommand, {
+            type: T_1;
+        }> | Extract<AddPendingHighlightCommand, {
+            type: T_1;
+        }> | Extract<ResetPendingHighlightCommand, {
+            type: T_1;
+        }> | Extract<SetColorCommand, {
+            type: T_1;
+        }> | Extract<SelectColumnCommand, {
+            type: T_1;
+        }> | Extract<SelectRowCommand, {
+            type: T_1;
+        }> | Extract<SelectAllCommand, {
+            type: T_1;
+        }> | Extract<AlterSelectionCommand, {
+            type: T_1;
+        }> | Extract<EvaluateCellsCommand, {
+            type: T_1;
+        }> | Extract<AddHighlightsCommand, {
+            type: T_1;
+        }> | Extract<RemoveHighlightsCommand, {
+            type: T_1;
+        }> | Extract<RemoveAllHighlightsCommand, {
+            type: T_1;
+        }> | Extract<StartComposerSelectionCommand, {
+            type: T_1;
+        }> | Extract<StopComposerSelectionCommand, {
+            type: T_1;
+        }> | Extract<StartEditionCommand, {
+            type: T_1;
+        }> | Extract<StopEditionCommand, {
+            type: T_1;
+        }> | Extract<SetCurrentContentCommand, {
+            type: T_1;
+        }> | Extract<SetValueCommand, {
+            type: T_1;
+        }> | Extract<ShowFormulaCommand, {
+            type: T_1;
+        }> | Extract<DeleteContentCommand, {
+            type: T_1;
+        }> | Extract<ClearCellCommand, {
+            type: T_1;
+        }> | Extract<UndoCommand, {
+            type: T_1;
+        }> | Extract<RedoCommand, {
+            type: T_1;
+        }> | Extract<StartCommand, {
+            type: T_1;
+        }> | Extract<AutofillCommand, {
+            type: T_1;
+        }> | Extract<AutofillSelectCommand, {
+            type: T_1;
+        }> | Extract<AutofillAutoCommand, {
+            type: T_1;
+        }> | Extract<NewInputCommand, {
+            type: T_1;
+        }> | Extract<RemoveInputCommand, {
+            type: T_1;
+        }> | Extract<FocusInputCommand, {
+            type: T_1;
+        }> | Extract<AddEmptyRangeCommand, {
+            type: T_1;
+        }> | Extract<RemoveRangeCommand, {
+            type: T_1;
+        }> | Extract<ChangeRangeCommand, {
+            type: T_1;
+        }> | Extract<CreateFigureCommand, {
+            type: T_1;
+        }> | Extract<SelectFigureCommand, {
+            type: T_1;
+        }> | Extract<UpdateFigureCommand, {
+            type: T_1;
+        }> | Extract<DeleteFigureCommand, {
+            type: T_1;
+        }> | Extract<CreateChartCommand, {
+            type: T_1;
+        }> | Extract<UpdateChartCommand, {
+            type: T_1;
+        }>>(type: T_1, r: Omit<C_1, "type">): CommandResult;
+    };
+    state: {
+        isActive: boolean;
+        isResizing: boolean;
+        activeElement: number;
+        styleValue: number;
+        delta: number;
+    };
+    abstract _getEvOffset(ev: MouseEvent): number;
+    abstract _getStateOffset(): number;
+    abstract _getViewportOffset(): number;
+    abstract _getClientPosition(ev: MouseEvent): number;
+    abstract _getElementIndex(index: number): number;
+    abstract _getElement(index: number): Col | Row;
+    abstract _getHeaderSize(): number;
+    abstract _getMaxSize(): number;
+    abstract _updateSize(): void;
+    abstract _selectElement(index: number, ctrlKey: boolean): void;
+    abstract _increaseSelection(index: number): void;
+    abstract _fitElementSize(index: number): void;
+    abstract _getType(): ContextMenuType;
+    abstract _getActiveElements(): Set<number>;
+    abstract _getXY(ev: MouseEvent): {
+        x: number;
+        y: number;
+    };
+    _computeHandleDisplay(ev: MouseEvent): void;
+    onMouseMove(ev: MouseEvent): void;
+    onMouseLeave(): void;
+    onDblClick(): void;
+    onMouseDown(ev: MouseEvent): void;
+    select(ev: MouseEvent): void;
+    onMouseUp(ev: MouseEvent): void;
+    onContextMenu(ev: MouseEvent): void;
+}
+declare class ColResizer extends AbstractResizer {
+    static template: string;
+    static style: string;
+    constructor();
+    _getEvOffset(ev: MouseEvent): number;
+    _getStateOffset(): number;
+    _getViewportOffset(): number;
+    _getClientPosition(ev: MouseEvent): number;
+    _getElementIndex(index: number): number;
+    _getElement(index: number): Col;
+    _getBottomRightValue(element: Col): number;
+    _getHeaderSize(): number;
+    _getMaxSize(): number;
+    _updateSize(): void;
+    _selectElement(index: number, ctrlKey: boolean): void;
+    _increaseSelection(index: number): void;
+    _fitElementSize(index: number): void;
+    _getType(): ContextMenuType;
+    _getActiveElements(): Set<number>;
+    _getXY(ev: MouseEvent): {
+        x: number;
+        y: number;
+    };
+}
+declare class RowResizer extends AbstractResizer {
+    static template: string;
+    static style: string;
+    constructor();
+    _getEvOffset(ev: MouseEvent): number;
+    _getStateOffset(): number;
+    _getViewportOffset(): number;
+    _getClientPosition(ev: MouseEvent): number;
+    _getElementIndex(index: number): number;
+    _getElement(index: number): Row;
+    _getHeaderSize(): number;
+    _getMaxSize(): number;
+    _updateSize(): void;
+    _selectElement(index: number, ctrlKey: boolean): void;
+    _increaseSelection(index: number): void;
+    _fitElementSize(index: number): void;
+    _getType(): ContextMenuType;
+    _getActiveElements(): Set<number>;
+    _getXY(ev: MouseEvent): {
+        x: number;
+        y: number;
+    };
+}
+interface Props$2 {
+    viewport: Viewport;
+}
+declare class Overlay extends Component$5<Props$2, SpreadsheetEnv> {
+    static template: string;
+    static style: string;
+    static components: {
+        ColResizer: typeof ColResizer;
+        RowResizer: typeof RowResizer;
+    };
+    selectAll(): void;
+}
+
+declare const Component$4: typeof owl.Component;
+declare type ContextMenuType = "ROW" | "COL" | "CELL";
+interface ErrorTooltip {
+    isOpen: boolean;
+    text: string;
+    style: string;
+}
+declare class Grid extends Component$4<{
+    model: Model;
+}, SpreadsheetEnv> {
+    static template: string;
+    static style: string;
+    static components: {
+        Composer: typeof Composer;
+        Overlay: typeof Overlay;
+        Menu: typeof Menu;
+        Autofill: typeof Autofill;
+        FiguresContainer: typeof FiguresContainer;
+    };
+    private menuState;
+    private composer;
+    private vScrollbarRef;
+    private hScrollbarRef;
+    private vScrollbar;
+    private hScrollbar;
+    private canvas;
+    private getters;
+    private dispatch;
+    private currentPosition;
+    private currentSheet;
+    private currentPositionInViewport;
+    private clickedCol;
+    private clickedRow;
+    private viewport;
+    private snappedViewport;
+    errorTooltip: ErrorTooltip;
+    private keyDownMapping;
+    constructor();
+    mounted(): void;
+    willUpdateProps(): Promise<void>;
+    patched(): void;
+    focus(): void;
+    onScroll(): void;
+    checkChanges(): boolean;
+    getAutofillPosition(): {
+        left: number;
+        top: number;
+    };
+    drawGrid(): void;
+    private moveCanvas;
+    onMouseWheel(ev: WheelEvent): void;
+    getCartesianCoordinates(ev: MouseEvent): [number, number];
+    onMouseDown(ev: MouseEvent): void;
+    onDoubleClick(ev: any): void;
+    processTabKey(ev: KeyboardEvent): void;
+    processArrows(ev: KeyboardEvent): void;
+    onKeydown(ev: KeyboardEvent): void;
+    onCanvasContextMenu(ev: MouseEvent): void;
+    onOverlayContextMenu(ev: CustomEvent): void;
+    toggleContextMenu(type: ContextMenuType, x: number, y: number): void;
+}
+
+declare const Component$3: typeof owl.Component;
+interface Props$1 {
+    component: string;
+    panelProps: any;
+}
+declare class SidePanel extends Component$3<Props$1, SpreadsheetEnv> {
+    static template: string;
+    static style: string;
+    state: {
+        panel: SidePanelContent;
+    };
+    willUpdateProps(nextProps: Props$1): Promise<void>;
+    getTitle(): string;
+}
+
+interface FontSize {
+    pt: number;
+    px: number;
+}
+
+declare const Component$2: typeof owl.Component;
+declare class ColorPicker extends Component$2<any, SpreadsheetEnv> {
+    static template: string;
+    static style: string;
+    COLORS: string[][];
+    onColorClick(ev: MouseEvent): void;
+}
+
+declare const Component$1: typeof owl.Component;
+declare type Tool = "" | "formatTool" | "alignTool" | "textColorTool" | "fillColorTool" | "borderTool" | "fontSizeTool";
+interface State {
+    menuState: MenuState;
+    activeTool: Tool;
+}
+declare class TopBar extends Component$1<any, SpreadsheetEnv> {
+    static template: string;
+    static style: string;
+    static components: {
+        ColorPicker: typeof ColorPicker;
+        Menu: typeof Menu;
+    };
+    formats: ({
+        name: string;
+        text: string;
+        value?: undefined;
+    } | {
+        name: string;
+        text: string;
+        value: string;
+    })[];
+    currentFormat: string;
+    fontSizes: FontSize[];
+    dispatch: {
+        <T extends "UPDATE_CELL" | "RESIZE_COLUMNS" | "RESIZE_ROWS" | "CREATE_SHEET" | "MOVE_SHEET" | "RENAME_SHEET" | "DUPLICATE_SHEET" | "DELETE_SHEET" | "DELETE_SHEET_CONFIRMATION" | "ADD_MERGE" | "REMOVE_MERGE" | "SET_FORMATTING" | "CLEAR_FORMATTING" | "SET_FORMATTER" | "SET_DECIMAL" | "ADD_CONDITIONAL_FORMAT" | "REMOVE_CONDITIONAL_FORMAT" | "REMOVE_COLUMNS" | "REMOVE_ROWS" | "ADD_COLUMNS" | "ADD_ROWS" | "COPY" | "CUT" | "PASTE" | "PASTE_CELL" | "AUTOFILL_CELL" | "ACTIVATE_PAINT_FORMAT" | "PASTE_FROM_OS_CLIPBOARD" | "AUTORESIZE_COLUMNS" | "AUTORESIZE_ROWS" | "MOVE_POSITION" | "ACTIVATE_SHEET" | "SELECT_CELL" | "SET_SELECTION" | "START_SELECTION" | "PREPARE_SELECTION_EXPANSION" | "START_SELECTION_EXPANSION" | "STOP_SELECTION" | "HIGHLIGHT_SELECTION" | "ADD_PENDING_HIGHLIGHTS" | "RESET_PENDING_HIGHLIGHT" | "SET_HIGHLIGHT_COLOR" | "SELECT_COLUMN" | "SELECT_ROW" | "SELECT_ALL" | "ALTER_SELECTION" | "EVALUATE_CELLS" | "ADD_HIGHLIGHTS" | "REMOVE_HIGHLIGHTS" | "REMOVE_ALL_HIGHLIGHTS" | "START_COMPOSER_SELECTION" | "STOP_COMPOSER_SELECTION" | "START_EDITION" | "STOP_EDITION" | "SET_CURRENT_CONTENT" | "SET_VALUE" | "SET_FORMULA_VISIBILITY" | "DELETE_CONTENT" | "CLEAR_CELL" | "UNDO" | "REDO" | "START" | "AUTOFILL" | "AUTOFILL_SELECT" | "AUTOFILL_AUTO" | "ENABLE_NEW_SELECTION_INPUT" | "DISABLE_SELECTION_INPUT" | "FOCUS_RANGE" | "ADD_EMPTY_RANGE" | "REMOVE_RANGE" | "CHANGE_RANGE" | "CREATE_FIGURE" | "SELECT_FIGURE" | "UPDATE_FIGURE" | "DELETE_FIGURE" | "CREATE_CHART" | "UPDATE_CHART", C extends Extract<UpdateCellCommand, {
+            type: T;
+        }> | Extract<ResizeColumnsCommand, {
+            type: T;
+        }> | Extract<ResizeRowsCommand, {
+            type: T;
+        }> | Extract<CreateSheetCommand, {
+            type: T;
+        }> | Extract<MoveSheetCommand, {
+            type: T;
+        }> | Extract<RenameSheetCommand, {
+            type: T;
+        }> | Extract<DuplicateSheetCommand, {
+            type: T;
+        }> | Extract<DeleteSheetCommand, {
+            type: T;
+        }> | Extract<DeleteSheetConfirmationCommand, {
+            type: T;
+        }> | Extract<AddMergeCommand, {
+            type: T;
+        }> | Extract<RemoveMergeCommand, {
+            type: T;
+        }> | Extract<AddFormattingCommand, {
+            type: T;
+        }> | Extract<ClearFormattingCommand, {
+            type: T;
+        }> | Extract<SetFormatterCommand, {
+            type: T;
+        }> | Extract<SetDecimalCommand, {
+            type: T;
+        }> | Extract<AddConditionalFormatCommand, {
+            type: T;
+        }> | Extract<RemoveConditionalFormatCommand, {
+            type: T;
+        }> | Extract<RemoveColumnsCommand, {
+            type: T;
+        }> | Extract<RemoveRowsCommand, {
+            type: T;
+        }> | Extract<AddColumnsCommand, {
+            type: T;
+        }> | Extract<AddRowsCommand, {
+            type: T;
+        }> | Extract<CopyCommand, {
+            type: T;
+        }> | Extract<CutCommand, {
+            type: T;
+        }> | Extract<PasteCommand, {
+            type: T;
+        }> | Extract<PasteCellCommand, {
+            type: T;
+        }> | Extract<AutoFillCellCommand, {
+            type: T;
+        }> | Extract<ActivatePaintFormatCommand, {
+            type: T;
+        }> | Extract<PasteFromOSClipboardCommand, {
+            type: T;
+        }> | Extract<AutoresizeColumnsCommand, {
+            type: T;
+        }> | Extract<AutoresizeRowsCommand, {
+            type: T;
+        }> | Extract<MovePositionCommand, {
+            type: T;
+        }> | Extract<ActivateSheetCommand, {
+            type: T;
+        }> | Extract<SelectCellCommand, {
+            type: T;
+        }> | Extract<SetSelectionCommand, {
+            type: T;
+        }> | Extract<StartSelectionCommand, {
+            type: T;
+        }> | Extract<PrepareExpansionCommand, {
+            type: T;
+        }> | Extract<StartExpansionCommand, {
+            type: T;
+        }> | Extract<StopSelectionCommand, {
+            type: T;
+        }> | Extract<HighlightSelectionCommand, {
+            type: T;
+        }> | Extract<AddPendingHighlightCommand, {
+            type: T;
+        }> | Extract<ResetPendingHighlightCommand, {
+            type: T;
+        }> | Extract<SetColorCommand, {
+            type: T;
+        }> | Extract<SelectColumnCommand, {
+            type: T;
+        }> | Extract<SelectRowCommand, {
+            type: T;
+        }> | Extract<SelectAllCommand, {
+            type: T;
+        }> | Extract<AlterSelectionCommand, {
+            type: T;
+        }> | Extract<EvaluateCellsCommand, {
+            type: T;
+        }> | Extract<AddHighlightsCommand, {
+            type: T;
+        }> | Extract<RemoveHighlightsCommand, {
+            type: T;
+        }> | Extract<RemoveAllHighlightsCommand, {
+            type: T;
+        }> | Extract<StartComposerSelectionCommand, {
+            type: T;
+        }> | Extract<StopComposerSelectionCommand, {
+            type: T;
+        }> | Extract<StartEditionCommand, {
+            type: T;
+        }> | Extract<StopEditionCommand, {
+            type: T;
+        }> | Extract<SetCurrentContentCommand, {
+            type: T;
+        }> | Extract<SetValueCommand, {
+            type: T;
+        }> | Extract<ShowFormulaCommand, {
+            type: T;
+        }> | Extract<DeleteContentCommand, {
+            type: T;
+        }> | Extract<ClearCellCommand, {
+            type: T;
+        }> | Extract<UndoCommand, {
+            type: T;
+        }> | Extract<RedoCommand, {
+            type: T;
+        }> | Extract<StartCommand, {
+            type: T;
+        }> | Extract<AutofillCommand, {
+            type: T;
+        }> | Extract<AutofillSelectCommand, {
+            type: T;
+        }> | Extract<AutofillAutoCommand, {
+            type: T;
+        }> | Extract<NewInputCommand, {
+            type: T;
+        }> | Extract<RemoveInputCommand, {
+            type: T;
+        }> | Extract<FocusInputCommand, {
+            type: T;
+        }> | Extract<AddEmptyRangeCommand, {
+            type: T;
+        }> | Extract<RemoveRangeCommand, {
+            type: T;
+        }> | Extract<ChangeRangeCommand, {
+            type: T;
+        }> | Extract<CreateFigureCommand, {
+            type: T;
+        }> | Extract<SelectFigureCommand, {
+            type: T;
+        }> | Extract<UpdateFigureCommand, {
+            type: T;
+        }> | Extract<DeleteFigureCommand, {
+            type: T;
+        }> | Extract<CreateChartCommand, {
+            type: T;
+        }> | Extract<UpdateChartCommand, {
+            type: T;
+        }>>(type: {} extends Omit<C, "type"> ? T : never): CommandResult;
+        <T_1 extends "UPDATE_CELL" | "RESIZE_COLUMNS" | "RESIZE_ROWS" | "CREATE_SHEET" | "MOVE_SHEET" | "RENAME_SHEET" | "DUPLICATE_SHEET" | "DELETE_SHEET" | "DELETE_SHEET_CONFIRMATION" | "ADD_MERGE" | "REMOVE_MERGE" | "SET_FORMATTING" | "CLEAR_FORMATTING" | "SET_FORMATTER" | "SET_DECIMAL" | "ADD_CONDITIONAL_FORMAT" | "REMOVE_CONDITIONAL_FORMAT" | "REMOVE_COLUMNS" | "REMOVE_ROWS" | "ADD_COLUMNS" | "ADD_ROWS" | "COPY" | "CUT" | "PASTE" | "PASTE_CELL" | "AUTOFILL_CELL" | "ACTIVATE_PAINT_FORMAT" | "PASTE_FROM_OS_CLIPBOARD" | "AUTORESIZE_COLUMNS" | "AUTORESIZE_ROWS" | "MOVE_POSITION" | "ACTIVATE_SHEET" | "SELECT_CELL" | "SET_SELECTION" | "START_SELECTION" | "PREPARE_SELECTION_EXPANSION" | "START_SELECTION_EXPANSION" | "STOP_SELECTION" | "HIGHLIGHT_SELECTION" | "ADD_PENDING_HIGHLIGHTS" | "RESET_PENDING_HIGHLIGHT" | "SET_HIGHLIGHT_COLOR" | "SELECT_COLUMN" | "SELECT_ROW" | "SELECT_ALL" | "ALTER_SELECTION" | "EVALUATE_CELLS" | "ADD_HIGHLIGHTS" | "REMOVE_HIGHLIGHTS" | "REMOVE_ALL_HIGHLIGHTS" | "START_COMPOSER_SELECTION" | "STOP_COMPOSER_SELECTION" | "START_EDITION" | "STOP_EDITION" | "SET_CURRENT_CONTENT" | "SET_VALUE" | "SET_FORMULA_VISIBILITY" | "DELETE_CONTENT" | "CLEAR_CELL" | "UNDO" | "REDO" | "START" | "AUTOFILL" | "AUTOFILL_SELECT" | "AUTOFILL_AUTO" | "ENABLE_NEW_SELECTION_INPUT" | "DISABLE_SELECTION_INPUT" | "FOCUS_RANGE" | "ADD_EMPTY_RANGE" | "REMOVE_RANGE" | "CHANGE_RANGE" | "CREATE_FIGURE" | "SELECT_FIGURE" | "UPDATE_FIGURE" | "DELETE_FIGURE" | "CREATE_CHART" | "UPDATE_CHART", C_1 extends Extract<UpdateCellCommand, {
+            type: T_1;
+        }> | Extract<ResizeColumnsCommand, {
+            type: T_1;
+        }> | Extract<ResizeRowsCommand, {
+            type: T_1;
+        }> | Extract<CreateSheetCommand, {
+            type: T_1;
+        }> | Extract<MoveSheetCommand, {
+            type: T_1;
+        }> | Extract<RenameSheetCommand, {
+            type: T_1;
+        }> | Extract<DuplicateSheetCommand, {
+            type: T_1;
+        }> | Extract<DeleteSheetCommand, {
+            type: T_1;
+        }> | Extract<DeleteSheetConfirmationCommand, {
+            type: T_1;
+        }> | Extract<AddMergeCommand, {
+            type: T_1;
+        }> | Extract<RemoveMergeCommand, {
+            type: T_1;
+        }> | Extract<AddFormattingCommand, {
+            type: T_1;
+        }> | Extract<ClearFormattingCommand, {
+            type: T_1;
+        }> | Extract<SetFormatterCommand, {
+            type: T_1;
+        }> | Extract<SetDecimalCommand, {
+            type: T_1;
+        }> | Extract<AddConditionalFormatCommand, {
+            type: T_1;
+        }> | Extract<RemoveConditionalFormatCommand, {
+            type: T_1;
+        }> | Extract<RemoveColumnsCommand, {
+            type: T_1;
+        }> | Extract<RemoveRowsCommand, {
+            type: T_1;
+        }> | Extract<AddColumnsCommand, {
+            type: T_1;
+        }> | Extract<AddRowsCommand, {
+            type: T_1;
+        }> | Extract<CopyCommand, {
+            type: T_1;
+        }> | Extract<CutCommand, {
+            type: T_1;
+        }> | Extract<PasteCommand, {
+            type: T_1;
+        }> | Extract<PasteCellCommand, {
+            type: T_1;
+        }> | Extract<AutoFillCellCommand, {
+            type: T_1;
+        }> | Extract<ActivatePaintFormatCommand, {
+            type: T_1;
+        }> | Extract<PasteFromOSClipboardCommand, {
+            type: T_1;
+        }> | Extract<AutoresizeColumnsCommand, {
+            type: T_1;
+        }> | Extract<AutoresizeRowsCommand, {
+            type: T_1;
+        }> | Extract<MovePositionCommand, {
+            type: T_1;
+        }> | Extract<ActivateSheetCommand, {
+            type: T_1;
+        }> | Extract<SelectCellCommand, {
+            type: T_1;
+        }> | Extract<SetSelectionCommand, {
+            type: T_1;
+        }> | Extract<StartSelectionCommand, {
+            type: T_1;
+        }> | Extract<PrepareExpansionCommand, {
+            type: T_1;
+        }> | Extract<StartExpansionCommand, {
+            type: T_1;
+        }> | Extract<StopSelectionCommand, {
+            type: T_1;
+        }> | Extract<HighlightSelectionCommand, {
+            type: T_1;
+        }> | Extract<AddPendingHighlightCommand, {
+            type: T_1;
+        }> | Extract<ResetPendingHighlightCommand, {
+            type: T_1;
+        }> | Extract<SetColorCommand, {
+            type: T_1;
+        }> | Extract<SelectColumnCommand, {
+            type: T_1;
+        }> | Extract<SelectRowCommand, {
+            type: T_1;
+        }> | Extract<SelectAllCommand, {
+            type: T_1;
+        }> | Extract<AlterSelectionCommand, {
+            type: T_1;
+        }> | Extract<EvaluateCellsCommand, {
+            type: T_1;
+        }> | Extract<AddHighlightsCommand, {
+            type: T_1;
+        }> | Extract<RemoveHighlightsCommand, {
+            type: T_1;
+        }> | Extract<RemoveAllHighlightsCommand, {
+            type: T_1;
+        }> | Extract<StartComposerSelectionCommand, {
+            type: T_1;
+        }> | Extract<StopComposerSelectionCommand, {
+            type: T_1;
+        }> | Extract<StartEditionCommand, {
+            type: T_1;
+        }> | Extract<StopEditionCommand, {
+            type: T_1;
+        }> | Extract<SetCurrentContentCommand, {
+            type: T_1;
+        }> | Extract<SetValueCommand, {
+            type: T_1;
+        }> | Extract<ShowFormulaCommand, {
+            type: T_1;
+        }> | Extract<DeleteContentCommand, {
+            type: T_1;
+        }> | Extract<ClearCellCommand, {
+            type: T_1;
+        }> | Extract<UndoCommand, {
+            type: T_1;
+        }> | Extract<RedoCommand, {
+            type: T_1;
+        }> | Extract<StartCommand, {
+            type: T_1;
+        }> | Extract<AutofillCommand, {
+            type: T_1;
+        }> | Extract<AutofillSelectCommand, {
+            type: T_1;
+        }> | Extract<AutofillAutoCommand, {
+            type: T_1;
+        }> | Extract<NewInputCommand, {
+            type: T_1;
+        }> | Extract<RemoveInputCommand, {
+            type: T_1;
+        }> | Extract<FocusInputCommand, {
+            type: T_1;
+        }> | Extract<AddEmptyRangeCommand, {
+            type: T_1;
+        }> | Extract<RemoveRangeCommand, {
+            type: T_1;
+        }> | Extract<ChangeRangeCommand, {
+            type: T_1;
+        }> | Extract<CreateFigureCommand, {
+            type: T_1;
+        }> | Extract<SelectFigureCommand, {
+            type: T_1;
+        }> | Extract<UpdateFigureCommand, {
+            type: T_1;
+        }> | Extract<DeleteFigureCommand, {
+            type: T_1;
+        }> | Extract<CreateChartCommand, {
+            type: T_1;
+        }> | Extract<UpdateChartCommand, {
+            type: T_1;
+        }>>(type: T_1, r: Omit<C_1, "type">): CommandResult;
+    };
+    getters: Getters;
+    style: Style;
+    state: State;
+    isSelectingMenu: boolean;
+    openedEl: HTMLElement | null;
+    inMerge: boolean;
+    cannotMerge: boolean;
+    undoTool: boolean;
+    redoTool: boolean;
+    paintFormatTool: boolean;
+    fillColor: string;
+    textColor: string;
+    menus: FullMenuItem[];
+    private menuRef;
+    constructor();
+    get topbarComponents(): TopbarComponent[];
+    willStart(): Promise<void>;
+    willUpdateProps(): Promise<void>;
+    onClick(ev: MouseEvent): void;
+    toogleStyle(style: string): void;
+    toogleFormat(format: string): void;
+    toggleAlign(align: Align): void;
+    onMenuMouseOver(menu: FullMenuItem, ev: MouseEvent): void;
+    toggleDropdownTool(tool: Tool, ev: MouseEvent): void;
+    toggleContextMenu(menu: FullMenuItem, ev: MouseEvent): void;
+    closeMenus(): void;
+    updateCellState(): void;
+    getMenuName(menu: FullMenuItem): string;
+    toggleMerge(): void;
+    setColor(target: string, ev: CustomEvent): void;
+    setBorder(command: BorderCommand): void;
+    setFormat(ev: MouseEvent): void;
+    setDecimal(step: number): void;
+    paintFormat(): void;
+    clearFormatting(): void;
+    setSize(ev: MouseEvent): void;
+    doAction(action: (env: SpreadsheetEnv) => void): void;
+    undo(): void;
+    redo(): void;
+}
+
+declare const Component: typeof owl.Component;
+interface Props {
+    data?: any;
+}
+declare class Spreadsheet extends Component<Props> {
+    static template: string;
+    static style: string;
+    static components: {
+        TopBar: typeof TopBar;
+        Grid: typeof Grid;
+        BottomBar: typeof BottomBar;
+        SidePanel: typeof SidePanel;
+    };
+    static _t: (s: string) => string;
+    model: Model;
+    private grid;
+    sidePanel: {
+        isOpen: boolean;
+        component?: string | undefined;
+        panelProps: any;
+    };
+    private clipBoardString;
+    constructor();
+    mounted(): void;
+    willUnmount(): void;
+    destroy(): void;
+    openSidePanel(panel: string, panelProps: any): void;
+    toggleSidePanel(panel: string, panelProps: any): void;
+    focusGrid(): void;
+    copy(cut: boolean, ev: ClipboardEvent): void;
+    paste(ev: ClipboardEvent): void;
+    save(): void;
+    onKeyup(ev: KeyboardEvent): void;
+    onKeydown(ev: KeyboardEvent): void;
+}
+
+/**
+ * We export here all entities that needs to be accessed publicly by Odoo.
+ *
+ * Note that the __info__ key is actually completed by the build process (see
+ * the rollup.config.js file)
+ */
+declare const __info__: {};
+
+declare const SPREADSHEET_DIMENSIONS: {
+    MIN_ROW_HEIGHT: number;
+    MIN_COL_WIDTH: number;
+    HEADER_HEIGHT: number;
+    HEADER_WIDTH: number;
+    TOPBAR_HEIGHT: number;
+    BOTTOMBAR_HEIGHT: number;
+    DEFAULT_CELL_WIDTH: number;
+    DEFAULT_CELL_HEIGHT: number;
+    SCROLLBAR_WIDTH: number;
+};
+declare const registries: {
+    autofillModifiersRegistry: Registry<AutofillModifierImplementation>;
+    autofillRulesRegistry: Registry<AutofillRule>;
+    cellMenuRegistry: MenuItemRegistry;
+    colMenuRegistry: MenuItemRegistry;
+    functionRegistry: FunctionRegistry;
+    pluginRegistry: Registry<typeof BasePlugin>;
+    rowMenuRegistry: MenuItemRegistry;
+    sidePanelRegistry: Registry<SidePanelContent>;
+    sheetMenuRegistry: MenuItemRegistry;
+    topbarMenuRegistry: MenuItemRegistry;
+    topbarComponentRegistry: Registry<TopbarComponent>;
+};
+declare const helpers: {
+    args: typeof args;
+    toBoolean: typeof toBoolean;
+    toNumber: typeof toNumber;
+    toString: typeof toString;
+    toXC: typeof toXC;
+    toZone: typeof toZone;
+    toCartesian: typeof toCartesian;
+    numberToLetters: typeof numberToLetters;
+    createFullMenuItem: typeof createFullMenuItem;
+    uuidv4: typeof uuidv4;
+    formatDecimal: typeof formatDecimal;
+};
+
+export { BasePlugin, Model, SPREADSHEET_DIMENSIONS, Spreadsheet, DEBUG as __DEBUG__, __info__, astToFormula, functionCache, helpers, normalize, parse, registries, setTranslationMethod };