@odoo/o-spreadsheet 18.0.55 → 18.0.68

package/dist/types/components/color_picker/color_picker_widget.d.ts

@@ -0,0 +1,52 @@
+import { Component } from "@odoo/owl";
+import { Pixel, Rect, SpreadsheetChildEnv } from "../../types";
+import { ColorPicker } from "./color_picker";
+interface Props {
+    currentColor: string | undefined;
+    toggleColorPicker: () => void;
+    showColorPicker: boolean;
+    onColorPicked: (color: string) => void;
+    icon: string;
+    title?: string;
+    disabled?: boolean;
+    dropdownMaxHeight?: Pixel;
+    class?: string;
+}
+export declare class ColorPickerWidget extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        currentColor: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        toggleColorPicker: FunctionConstructor;
+        showColorPicker: BooleanConstructor;
+        onColorPicked: FunctionConstructor;
+        icon: StringConstructor;
+        title: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        dropdownMaxHeight: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        ColorPicker: typeof ColorPicker;
+    };
+    colorPickerButtonRef: {
+        el: HTMLElement | null;
+    };
+    get iconStyle(): string;
+    get colorPickerAnchorRect(): Rect;
+}
+export {};

package/dist/types/components/composer/autocomplete_dropdown/autocomplete_dropdown.d.ts

@@ -0,0 +1,23 @@
+import { Component } from "@odoo/owl";
+import { AutoCompleteProposal } from "../../../registries";
+interface Props {
+    proposals: AutoCompleteProposal[];
+    selectedIndex: number | undefined;
+    onValueSelected: (value: string) => void;
+    onValueHovered: (index: string) => void;
+}
+export declare class TextValueProvider extends Component<Props> {
+    static template: string;
+    static props: {
+        proposals: ArrayConstructor;
+        selectedIndex: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        onValueSelected: FunctionConstructor;
+        onValueHovered: FunctionConstructor;
+    };
+    private autoCompleteListRef;
+    setup(): void;
+}
+export {};

package/dist/types/components/composer/autocomplete_dropdown/autocomplete_dropdown_store.d.ts

@@ -0,0 +1,12 @@
+import { AutoCompleteProposal, AutoCompleteProvider } from "../../../registries";
+import { SpreadsheetStore } from "../../../stores";
+export declare class AutoCompleteStore extends SpreadsheetStore {
+    mutators: readonly ["useProvider", "moveSelection", "hide", "selectIndex"];
+    selectedIndex: number | undefined;
+    provider: AutoCompleteProvider | undefined;
+    get selectedProposal(): AutoCompleteProposal | undefined;
+    useProvider(provider: AutoCompleteProvider): void;
+    hide(): void;
+    selectIndex(index: number): void;
+    moveSelection(direction: "previous" | "next"): void;
+}

package/dist/types/components/composer/composer/abstract_composer_store.d.ts

@@ -0,0 +1,113 @@
+import { EnrichedToken } from "../../../formulas/composer_tokenizer";
+import { AutoCompleteProvider, AutoCompleteProviderDefinition } from "../../../registries/auto_completes/auto_complete_registry";
+import { Get } from "../../../store_engine";
+import { SpreadsheetStore } from "../../../stores";
+import { CellPosition, Command, Direction, EditionMode, HeaderIndex, Highlight, UID } from "../../../types";
+export interface ComposerSelection {
+    start: number;
+    end: number;
+}
+export declare abstract class AbstractComposerStore extends SpreadsheetStore {
+    mutators: readonly ["startEdition", "setCurrentContent", "stopEdition", "stopComposerRangeSelection", "cancelEdition", "cycleReferences", "changeComposerCursorSelection", "replaceComposerCursorSelection"];
+    protected col: HeaderIndex;
+    protected row: HeaderIndex;
+    editionMode: EditionMode;
+    sheetId: UID;
+    protected _currentContent: string;
+    currentTokens: EnrichedToken[];
+    protected selectionStart: number;
+    protected selectionEnd: number;
+    protected initialContent: string | undefined;
+    private colorIndexByRange;
+    protected notificationStore: {
+        readonly notifyUser: (notification: import("../../..").InformationNotification) => void;
+        readonly askConfirmation: (content: string, confirm: () => void, cancel?: (() => void) | undefined) => void;
+        readonly raiseError: (text: string, callback?: (() => void) | undefined) => void;
+        readonly updateNotificationCallbacks: (methods: Partial<import("../../../stores/notification_store").NotificationStoreMethods>) => void;
+        readonly mutators: readonly ["notifyUser", "raiseError", "askConfirmation", "updateNotificationCallbacks"];
+    };
+    private highlightStore;
+    constructor(get: Get);
+    protected abstract confirmEdition(content: string): void;
+    protected abstract getComposerContent(position: CellPosition): string;
+    abstract stopEdition(direction?: Direction): void;
+    private handleEvent;
+    changeComposerCursorSelection(start: number, end: number): void;
+    stopComposerRangeSelection(): void;
+    startEdition(text?: string, selection?: ComposerSelection): void;
+    cancelEdition(): void;
+    setCurrentContent(content: string, selection?: ComposerSelection): void;
+    replaceComposerCursorSelection(text: string): void;
+    handle(cmd: Command): void;
+    get currentContent(): string;
+    get composerSelection(): ComposerSelection;
+    get isSelectingRange(): boolean;
+    get showSelectionIndicator(): boolean;
+    /**
+     * Return the (enriched) token just before the cursor.
+     */
+    get tokenAtCursor(): EnrichedToken | undefined;
+    cycleReferences(): void;
+    private isSelectionValid;
+    /**
+     * Enable the selecting mode
+     */
+    private startComposerRangeSelection;
+    /**
+     * start the edition of a cell
+     * @param str the key that is used to start the edition if it is a "content" key like a letter or number
+     * @param selection
+     * @private
+     */
+    private _startEdition;
+    protected _stopEdition(): void;
+    protected getCurrentCanonicalContent(): string;
+    protected cancelEditionAndActivateSheet(): void;
+    protected _cancelEdition(): void;
+    /**
+     * Reset the current content to the active cell content
+     */
+    protected resetContent(): void;
+    protected setContent(text: string, selection?: ComposerSelection, raise?: boolean): void;
+    protected getAutoCompleteProviders(): AutoCompleteProviderDefinition[];
+    private insertSelectedRange;
+    /**
+     * Replace the current reference selected by the new one.
+     * */
+    private replaceSelectedRange;
+    /**
+     * Replace the reference of the old zone by the new one.
+     */
+    private updateComposerRange;
+    private getZoneReference;
+    private getRangeReference;
+    /**
+     * Replace the current selection by a new text.
+     * The cursor is then set at the end of the text.
+     */
+    private replaceSelection;
+    private replaceText;
+    /**
+     * Insert a text at the given position.
+     * The cursor is then set at the end of the text.
+     */
+    private insertText;
+    private updateRangeColor;
+    /**
+     * Highlight all ranges that can be found in the composer content.
+     */
+    get highlights(): Highlight[];
+    /**
+     * Return ranges currently referenced in the composer
+     */
+    private getReferencedRanges;
+    get autocompleteProvider(): AutoCompleteProvider | undefined;
+    /**
+     * Function used to determine when composer selection can start.
+     * Three conditions are necessary:
+     * - the previous token is among ["ARG_SEPARATOR", "LEFT_PAREN", "OPERATOR"], and is not a postfix unary operator
+     * - the next token is missing or is among ["ARG_SEPARATOR", "RIGHT_PAREN", "OPERATOR"]
+     * - Previous and next tokens can be separated by spaces
+     */
+    private canStartComposerRangeSelection;
+}

package/dist/types/components/composer/composer/cell_composer_store.d.ts

@@ -0,0 +1,18 @@
+import { CellPosition, Command, Direction } from "../../../types";
+import { AbstractComposerStore } from "./abstract_composer_store";
+export declare class CellComposerStore extends AbstractComposerStore {
+    private canStopEdition;
+    stopEdition(direction?: Direction): void;
+    handle(cmd: Command): void;
+    get placeholder(): string | undefined;
+    get currentEditedCell(): CellPosition;
+    private onColumnsRemoved;
+    private onRowsRemoved;
+    private onAddElements;
+    protected confirmEdition(content: string): void;
+    protected getComposerContent(position: CellPosition): string;
+    private numberComposerContent;
+    /** Add headers at the end of the sheet so the formula in the composer has enough space to spread */
+    private addHeadersForSpreadingFormula;
+    private checkDataValidation;
+}

package/dist/types/components/composer/composer/composer.d.ts

@@ -0,0 +1,172 @@
+import { Component } from "@odoo/owl";
+import { EnrichedToken } from "../../../formulas/composer_tokenizer";
+import { Store } from "../../../store_engine";
+import { CSSProperties, Color, ComposerFocusType, DOMDimension, FunctionDescription, Rect, SpreadsheetChildEnv } from "../../../types/index";
+import { TextValueProvider } from "../autocomplete_dropdown/autocomplete_dropdown";
+import { AutoCompleteStore } from "../autocomplete_dropdown/autocomplete_dropdown_store";
+import { ContentEditableHelper } from "../content_editable_helper";
+import { FunctionDescriptionProvider } from "../formula_assistant/formula_assistant";
+import { CellComposerStore } from "./cell_composer_store";
+export declare const selectionIndicatorClass = "selector-flag";
+export type HtmlContent = {
+    value: string;
+    color?: Color;
+    class?: string;
+};
+export declare const tokenColors: {
+    readonly OPERATOR: "#3da4ab";
+    readonly NUMBER: "#02c39a";
+    readonly STRING: "#00a82d";
+    readonly FUNCTION: "#4a4e4d";
+    readonly DEBUGGER: "#3da4ab";
+    readonly LEFT_PAREN: "#4a4e4d";
+    readonly RIGHT_PAREN: "#4a4e4d";
+    readonly ARG_SEPARATOR: "#4a4e4d";
+    readonly MATCHING_PAREN: "#000000";
+};
+export interface CellComposerProps {
+    focus: ComposerFocusType;
+    inputStyle?: string;
+    rect?: Rect;
+    delimitation?: DOMDimension;
+    onComposerContentFocused: () => void;
+    onComposerCellFocused?: (content: String) => void;
+    onInputContextMenu?: (event: MouseEvent) => void;
+    isDefaultFocus?: boolean;
+    composerStore: Store<CellComposerStore>;
+    placeholder?: string;
+}
+interface ComposerState {
+    positionStart: number;
+    positionEnd: number;
+}
+interface FunctionDescriptionState {
+    showDescription: boolean;
+    functionName: string;
+    functionDescription: FunctionDescription;
+    argToFocus: number;
+}
+export declare class Composer extends Component<CellComposerProps, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        focus: {
+            validate: (value: string) => boolean;
+        };
+        inputStyle: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        rect: {
+            type: ObjectConstructor;
+            optional: boolean;
+        };
+        delimitation: {
+            type: ObjectConstructor;
+            optional: boolean;
+        };
+        onComposerCellFocused: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onComposerContentFocused: FunctionConstructor;
+        isDefaultFocus: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        onInputContextMenu: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        composerStore: ObjectConstructor;
+        placeholder: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        TextValueProvider: typeof TextValueProvider;
+        FunctionDescriptionProvider: typeof FunctionDescriptionProvider;
+    };
+    static defaultProps: {
+        inputStyle: string;
+        isDefaultFocus: boolean;
+    };
+    private DOMFocusableElementStore;
+    composerRef: {
+        el: HTMLElement | null;
+    };
+    contentHelper: ContentEditableHelper;
+    composerState: ComposerState;
+    autoCompleteState: Store<AutoCompleteStore>;
+    functionDescriptionState: FunctionDescriptionState;
+    assistant: {
+        forcedClosed: boolean;
+    };
+    private compositionActive;
+    private spreadsheetRect;
+    get assistantStyleProperties(): CSSProperties;
+    get assistantStyle(): string;
+    get assistantContainerStyle(): string;
+    shouldProcessInputEvents: boolean;
+    tokens: EnrichedToken[];
+    keyMapping: {
+        [key: string]: Function;
+    };
+    keyCodeMapping: {
+        [keyCode: string]: Function;
+    };
+    setup(): void;
+    private processArrowKeys;
+    private handleArrowKeysForAutocomplete;
+    private processTabKey;
+    private processEnterKey;
+    private processNewLineEvent;
+    private processEscapeKey;
+    private processF4Key;
+    private processNumpadDecimal;
+    onCompositionStart(): void;
+    onCompositionEnd(): void;
+    onKeydown(ev: KeyboardEvent): void;
+    onPaste(ev: ClipboardEvent): void;
+    onInput(ev: InputEvent): void;
+    onKeyup(ev: KeyboardEvent): void;
+    onBlur(ev: FocusEvent): void;
+    updateAutoCompleteIndex(index: number): void;
+    /**
+     * This is required to ensure the content helper selection is
+     * properly updated on "onclick" events. Depending on the browser,
+     * the callback onClick from the composer will be executed before
+     * the selection was updated in the dom, which means we capture an
+     * wrong selection which is then forced upon the content helper on
+     * processContent.
+     */
+    onMousedown(ev: MouseEvent): void;
+    onClick(): void;
+    onDblClick(): void;
+    onContextMenu(ev: MouseEvent): void;
+    closeAssistant(): void;
+    openAssistant(): void;
+    onWheel(event: WheelEvent): void;
+    get canBeToggled(): boolean;
+    private processContent;
+    /**
+     * Get the HTML content corresponding to the current composer token, divided by lines.
+     */
+    private getContentLines;
+    private getColoredTokens;
+    /**
+     * Split an array of HTMLContents into lines. Each NEWLINE character encountered will create a new
+     * line. Contents can be split into multiple parts if they contain multiple NEWLINE characters.
+     */
+    private splitHtmlContentIntoLines;
+    private isContentEmpty;
+    private rangeColor;
+    /**
+     * Compute the state of the composer from the tokenAtCursor.
+     * If the token is a function or symbol (that isn't a cell/range reference) we have to initialize
+     * the autocomplete engine otherwise we initialize the formula assistant.
+     */
+    private processTokenAtCursor;
+    private autoComplete;
+}
+export {};

package/dist/types/components/composer/composer_focus_store.d.ts

@@ -0,0 +1,28 @@
+import { SpreadsheetStore } from "../../stores/spreadsheet_store";
+import { ComposerFocusType, EditionMode } from "../../types";
+import { ComposerSelection } from "./composer/abstract_composer_store";
+export interface ComposerInterface {
+    id: string;
+    editionMode: EditionMode;
+    startEdition(content?: string, selection?: ComposerSelection): void;
+    stopEdition(): void;
+    setCurrentContent(content: string, selection?: ComposerSelection): void;
+}
+interface Args {
+    focusMode?: ComposerFocusType;
+    content?: string;
+    selection?: ComposerSelection;
+}
+export declare class ComposerFocusStore extends SpreadsheetStore {
+    mutators: readonly ["focusComposer", "focusActiveComposer"];
+    activeComposer: ComposerInterface;
+    private _focusMode;
+    get focusMode(): ComposerFocusType;
+    focusComposer(listener: ComposerInterface, args: Args): "noStateChange" | undefined;
+    focusActiveComposer(args: Args): "noStateChange" | undefined;
+    /**
+     * Start the edition or update the content if it's already started.
+     */
+    private setComposerContent;
+}
+export {};

package/dist/types/components/composer/content_editable_helper.d.ts

@@ -0,0 +1,60 @@
+import { HtmlContent } from "./composer/composer";
+export declare class ContentEditableHelper {
+    el: HTMLElement;
+    constructor(el: HTMLElement);
+    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;
+    /**
+     * Sets (or Replaces all) the text inside the root element in the form of distinctive paragraphs and
+     * span for each element provided in `contents`.
+     *
+     * The function will apply the diff between the current content and the new content to avoid the systematic
+     * destruction of DOM elements which interferes with IME[1]
+     *
+     * Each line of text will be encapsulated in a paragraph element.
+     * Each span will have its own fontcolor and specific class if provided in the HtmlContent object.
+     *
+     * [1] https://developer.mozilla.org/en-US/docs/Glossary/Input_method_editor
+     */
+    setText(contents: HtmlContent[][]): void;
+    scrollSelectionIntoView(): void;
+    /**
+     * remove the current selection of the user
+     * */
+    removeSelection(): void;
+    private removeAll;
+    /**
+     * 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;
+    getText(): string;
+}

package/dist/types/components/composer/formula_assistant/formula_assistant.d.ts

@@ -0,0 +1,18 @@
+import { Component } from "@odoo/owl";
+import { FunctionDescription, SpreadsheetChildEnv } from "../../../types";
+interface Props {
+    functionName: string;
+    functionDescription: FunctionDescription;
+    argToFocus: number;
+}
+export declare class FunctionDescriptionProvider extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        functionName: StringConstructor;
+        functionDescription: ObjectConstructor;
+        argToFocus: NumberConstructor;
+    };
+    getContext(): Props;
+    get formulaArgSeparator(): string;
+}
+export {};

package/dist/types/components/composer/grid_composer/grid_composer.d.ts

@@ -0,0 +1,47 @@
+import { Component } from "@odoo/owl";
+import { Store } from "../../../store_engine";
+import { ComposerFocusType, DOMDimension, SpreadsheetChildEnv } from "../../../types/index";
+import { CellComposerProps, Composer } from "../composer/composer";
+import { ComposerFocusStore } from "../composer_focus_store";
+interface Props {
+    gridDims: DOMDimension;
+    onInputContextMenu: (event: MouseEvent) => void;
+}
+/**
+ * This component is a composer which positions itself on the grid at the anchor cell.
+ * It also applies the style of the cell to the composer input.
+ */
+export declare class GridComposer extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        gridDims: ObjectConstructor;
+        onInputContextMenu: FunctionConstructor;
+    };
+    static components: {
+        Composer: typeof Composer;
+    };
+    private rect;
+    private isEditing;
+    private isCellReferenceVisible;
+    private currentEditedCell;
+    private composerStore;
+    composerFocusStore: Store<ComposerFocusStore>;
+    private composerInterface;
+    get defaultRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    setup(): void;
+    get shouldDisplayCellReference(): boolean;
+    get cellReference(): string;
+    get cellReferenceStyle(): string;
+    get focus(): ComposerFocusType;
+    get composerProps(): CellComposerProps;
+    get containerStyle(): string;
+    private updateComponentPosition;
+    private updateCellReferenceVisibility;
+    onFocus(): void;
+}
+export {};

package/dist/types/components/composer/standalone_composer/standalone_composer.d.ts

@@ -0,0 +1,60 @@
+import { Component } from "@odoo/owl";
+import { AutoCompleteProviderDefinition } from "../../../registries";
+import { ComposerFocusType, SpreadsheetChildEnv, UID } from "../../../types/index";
+import { ComposerSelection } from "../composer/abstract_composer_store";
+import { Composer } from "../composer/composer";
+interface Props {
+    onConfirm: (content: string) => void;
+    composerContent: string;
+    defaultRangeSheetId: UID;
+    contextualAutocomplete?: AutoCompleteProviderDefinition;
+    placeholder?: string;
+    class?: string;
+    invalid?: boolean;
+}
+export declare class StandaloneComposer extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        composerContent: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        defaultRangeSheetId: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        onConfirm: FunctionConstructor;
+        contextualAutocomplete: {
+            type: ObjectConstructor;
+            optional: boolean;
+        };
+        placeholder: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        invalid: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        Composer: typeof Composer;
+    };
+    static defaultProps: {
+        composerContent: string;
+    };
+    private composerFocusStore;
+    private standaloneComposerStore;
+    private composerInterface;
+    readonly spreadsheetRect: import("../../..").Rect;
+    setup(): void;
+    get focus(): ComposerFocusType;
+    get composerStyle(): string;
+    get containerClass(): string;
+    onFocus(selection: ComposerSelection): void;
+}
+export {};

package/dist/types/components/composer/standalone_composer/standalone_composer_store.d.ts

@@ -0,0 +1,22 @@
+import { AutoCompleteProviderDefinition } from "../../../registries";
+import { Get } from "../../../store_engine";
+import { UID } from "../../../types";
+import { AbstractComposerStore } from "../composer/abstract_composer_store";
+export interface StandaloneComposerArgs {
+    onConfirm: (content: string) => void;
+    content: string;
+    /**
+     * the sheet id to which unqualified references (A1 vs Sheet1!A1)
+     * will be resolved.
+     */
+    defaultRangeSheetId: UID;
+    contextualAutocomplete?: AutoCompleteProviderDefinition;
+}
+export declare class StandaloneComposerStore extends AbstractComposerStore {
+    private args;
+    constructor(get: Get, args: () => StandaloneComposerArgs);
+    protected getAutoCompleteProviders(): AutoCompleteProviderDefinition[];
+    protected getComposerContent(): string;
+    stopEdition(): void;
+    protected confirmEdition(content: string): void;
+}

package/dist/types/components/composer/top_bar_composer/top_bar_composer.d.ts

@@ -0,0 +1,19 @@
+import { Component } from "@odoo/owl";
+import { ComposerFocusType, SpreadsheetChildEnv } from "../../../types/index";
+import { ComposerSelection } from "../composer/abstract_composer_store";
+import { Composer } from "../composer/composer";
+export declare class TopBarComposer extends Component<any, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {};
+    static components: {
+        Composer: typeof Composer;
+    };
+    private composerFocusStore;
+    private composerStore;
+    private composerInterface;
+    setup(): void;
+    get focus(): ComposerFocusType;
+    get composerStyle(): string;
+    get containerStyle(): string;
+    onFocus(selection: ComposerSelection): void;
+}

package/dist/types/components/dashboard/clickable_cell_store.d.ts

@@ -0,0 +1,15 @@
+import { SpreadsheetStore } from "../../stores/spreadsheet_store";
+import { CellPosition, Command, Rect, SpreadsheetChildEnv } from "../../types";
+export interface ClickableCell {
+    coordinates: Rect;
+    position: CellPosition;
+    action: (position: CellPosition, env: SpreadsheetChildEnv) => void;
+}
+export declare class ClickableCellsStore extends SpreadsheetStore {
+    private _clickableCells;
+    private _registryItems;
+    handle(cmd: Command): void;
+    private getClickableAction;
+    private findClickableAction;
+    get clickableCells(): ClickableCell[];
+}