@odoo/o-spreadsheet 19.2.11 → 19.3.2

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

@@ -0,0 +1,34 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { NumberEditor } from "../number_editor/number_editor";
+interface Props {
+    currentFontSize: number;
+    class: string;
+    onFontSizeChanged: (fontSize: number) => void;
+    onToggle?: () => void;
+    onFocusInput?: () => void;
+}
+export declare class FontSizeEditor extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        NumberEditor: typeof NumberEditor;
+    };
+    static props: {
+        currentFontSize: NumberConstructor;
+        onFontSizeChanged: FunctionConstructor;
+        onToggle: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onFocusInput: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        class: StringConstructor;
+    };
+    static defaultProps: {
+        onFocusInput: () => void;
+    };
+    fontSizes: number[];
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { ChartFigure } from "../figures/figure_chart/figure_chart";
+export declare class FullScreenFigure extends Component<{}, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {};
+    static components: {
+        ChartFigure: typeof ChartFigure;
+    };
+    private fullScreenFigureStore;
+    private ref;
+    spreadsheetRect: import("../..").Rect;
+    figureRegistry: import("../..").Registry<import("../../registries/figures_registry").FigureContent>;
+    setup(): void;
+    get figureUI(): import("../..").FigureUI | undefined;
+    get chartId(): import("../..").UID | undefined;
+    exitFullScreen(): void;
+    onKeyDown(ev: KeyboardEvent): void;
+    get figureComponent(): (new (...args: any) => Component) | undefined;
+}

package/dist/types/components/full_screen_figure/full_screen_figure_store.d.ts

@@ -0,0 +1,8 @@
+import { SpreadsheetStore } from "../../stores";
+import { FigureUI } from "../../types";
+export declare class FullScreenFigureStore extends SpreadsheetStore {
+    mutators: readonly ["toggleFullScreenFigure"];
+    fullScreenFigure: FigureUI | undefined;
+    toggleFullScreenFigure(figureId: string): void;
+    private makeFullScreen;
+}

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

@@ -0,0 +1,73 @@
+import { Component } from "@odoo/owl";
+import { Ref } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export interface GenericInputProps {
+    value: string | number;
+    onChange: (value: string) => void;
+    onInput?: (value: string) => void;
+    onFocused?: () => void;
+    onBlur?: () => void;
+    class?: string;
+    id?: string;
+    placeholder?: string;
+    autofocus?: boolean;
+    selectContentOnFocus?: boolean;
+    resetOnBlur?: boolean;
+}
+export declare class GenericInput<T extends GenericInputProps> extends Component<T, SpreadsheetChildEnv> {
+    static props: {
+        value: (StringConstructor | NumberConstructor)[];
+        onChange: FunctionConstructor;
+        onFocused: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onBlur: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onInput: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        id: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        placeholder: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        autofocus: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        alwaysShowBorder: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        selectContentOnFocus: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        resetOnBlur: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+    };
+    protected refName: string;
+    protected inputRef: Ref<HTMLInputElement>;
+    private lastOnChangeValue;
+    setup(): void;
+    onKeyDown(ev: KeyboardEvent): void;
+    save(): void;
+    onMouseDown(ev: MouseEvent): void;
+    onMouseUp(ev: MouseEvent): void;
+    onFocus(): void;
+    onBlur(): void;
+    onInput(ev: Event): void;
+}

package/dist/types/components/grid/delayed_hovered_cell_store.d.ts

@@ -0,0 +1,10 @@
+import { SpreadsheetStore } from "../../stores";
+import { Command, Position } from "../../types";
+export declare class DelayedHoveredCellStore extends SpreadsheetStore {
+    mutators: readonly ["clear", "hover"];
+    col: number | undefined;
+    row: number | undefined;
+    handle(cmd: Command): void;
+    hover(position: Partial<Position>): "noStateChange" | undefined;
+    clear(): "noStateChange" | undefined;
+}

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

@@ -0,0 +1,123 @@
+import { Component } from "@odoo/owl";
+import { Store } from "../../store_engine";
+import { Client, DOMCoordinates, DOMDimension, GridClickModifiers, HeaderIndex, Pixel, Table } from "../../types/index";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { Autofill } from "../autofill/autofill";
+import { ClientTag } from "../collaborative_client_tag/collaborative_client_tag";
+import { ComposerSelection } from "../composer/composer/abstract_composer_store";
+import { GridComposer } from "../composer/grid_composer/grid_composer";
+import { GridOverlay } from "../grid_overlay/grid_overlay";
+import { GridPopover } from "../grid_popover/grid_popover";
+import { HeadersOverlay } from "../headers_overlay/headers_overlay";
+import { ZoomedMouseEvent } from "../helpers/zoom";
+import { Highlight } from "../highlight/highlight/highlight";
+import { MenuPopover } from "../menu_popover/menu_popover";
+import { Popover } from "../popover/popover";
+import { HorizontalScrollBar, VerticalScrollBar } from "../scrollbar/";
+import { Selection } from "../selection/selection";
+import { SidePanelStore } from "../side_panel/side_panel/side_panel_store";
+import { TableResizer } from "../tables/table_resizer/table_resizer";
+import { DelayedHoveredCellStore } from "./delayed_hovered_cell_store";
+/**
+ * The Grid component is the main part of the spreadsheet UI. It is responsible
+ * for displaying the actual grid, rendering it, managing events, ...
+ *
+ * The grid is rendered on a canvas. 3 sub components are (sometimes) displayed
+ * on top of the canvas:
+ * - a composer (to edit the cell content)
+ * - a horizontal resizer (to resize columns)
+ * - a vertical resizer (same, for rows)
+ */
+export type ContextMenuType = "ROW" | "COL" | "CELL" | "FILTER" | "GROUP_HEADERS" | "UNGROUP_HEADERS";
+interface Props {
+    exposeFocus: (focus: () => void) => void;
+    getGridSize: () => DOMDimension;
+}
+export declare class Grid extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        exposeFocus: FunctionConstructor;
+        getGridSize: FunctionConstructor;
+    };
+    static components: {
+        GridComposer: typeof GridComposer;
+        GridOverlay: typeof GridOverlay;
+        GridPopover: typeof GridPopover;
+        HeadersOverlay: typeof HeadersOverlay;
+        MenuPopover: typeof MenuPopover;
+        Autofill: typeof Autofill;
+        ClientTag: typeof ClientTag;
+        Highlight: typeof Highlight;
+        Popover: typeof Popover;
+        VerticalScrollBar: typeof VerticalScrollBar;
+        HorizontalScrollBar: typeof HorizontalScrollBar;
+        TableResizer: typeof TableResizer;
+        Selection: typeof Selection;
+    };
+    readonly HEADER_HEIGHT = 26;
+    readonly HEADER_WIDTH = 48;
+    private menuState;
+    private gridRef;
+    private highlightStore;
+    private cellPopovers;
+    private composerFocusStore;
+    private DOMFocusableElementStore;
+    private paintFormatStore;
+    private clientFocusStore;
+    dragNDropGrid: {
+        start: (initialPointerCoordinates: {
+            clientX: number;
+            clientY: number;
+        }, onPointerMove: (col: HeaderIndex, row: HeaderIndex, ev: MouseEvent) => void, onPointerUp: () => void, startScrollDirection?: import("../helpers/drag_and_drop_grid_hook").DnDDirection) => void;
+    };
+    onMouseWheel: (ev: WheelEvent) => void;
+    hoveredCell: Store<DelayedHoveredCellStore>;
+    sidePanel: Store<SidePanelStore>;
+    setup(): void;
+    get highlights(): import("../..").Highlight[];
+    get gridOverlayDimensions(): string;
+    onClosePopover(): void;
+    private keyDownMapping;
+    private focusComposerFromActiveCell;
+    private editOrMoveInSelection;
+    private moveInSelection;
+    private isSingleCellOrMergeSelection;
+    focusDefaultElement(): void;
+    get gridEl(): HTMLElement;
+    getAutofillPosition(): {
+        x: number;
+        y: number;
+    };
+    get isAutofillVisible(): boolean;
+    onGridResized(): void;
+    private moveCanvas;
+    private processSpaceKey;
+    getClientPositionKey(client: Client): string;
+    isCellHovered(col: HeaderIndex, row: HeaderIndex): boolean;
+    get focusedClients(): Set<string>;
+    private getGridRect;
+    onCellClicked(col: HeaderIndex, row: HeaderIndex, modifiers: GridClickModifiers, zoomedMouseEvent: ZoomedMouseEvent<PointerEvent>): void;
+    onCellDoubleClicked(col: HeaderIndex, row: HeaderIndex): void;
+    processArrows(ev: KeyboardEvent): void;
+    onKeydown(ev: KeyboardEvent): void;
+    onInputContextMenu(ev: MouseEvent): void;
+    onCellRightClicked(col: HeaderIndex, row: HeaderIndex, { x, y }: DOMCoordinates): void;
+    /**
+     * expects x and y coordinates in true pixels (not zoomed)
+     */
+    toggleContextMenu(type: ContextMenuType, x: Pixel, y: Pixel): void;
+    copy(cut: boolean, ev: ClipboardEvent): Promise<void>;
+    paste(ev: ClipboardEvent): Promise<void>;
+    private clearFormatting;
+    private setHorizontalAlign;
+    closeMenu(): void;
+    private processHeaderGroupingKey;
+    private processHeaderGroupingEventOnHeaders;
+    private processHeaderGroupingEventOnWholeSheet;
+    private processHeaderGroupingEventOnGrid;
+    onComposerCellFocused(content?: string, selection?: ComposerSelection): void;
+    onComposerContentFocused(): void;
+    get staticTables(): Table[];
+    get displaySelectionHandler(): boolean;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { ValidationMessages } from "../validation_messages/validation_messages";
+interface Props {
+}
+export declare class GridAddRowsFooter extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {};
+    static components: {
+        ValidationMessages: typeof ValidationMessages;
+    };
+    private DOMFocusableElementStore;
+    inputRef: {
+        el: HTMLInputElement | null;
+    };
+    state: {
+        inputValue: string;
+        errorFlag: boolean;
+    };
+    setup(): void;
+    get addRowsPosition(): string;
+    get errorMessages(): string[];
+    onKeydown(ev: KeyboardEvent): void;
+    onInput(ev: InputEvent): void;
+    onConfirm(): void;
+    private onExternalClick;
+    private focusDefaultElement;
+}
+export {};

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

@@ -0,0 +1,68 @@
+import { Component } from "@odoo/owl";
+import { DOMCoordinates, GridClickModifiers, HeaderIndex, Pixel } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { FiguresContainer } from "../figures/figure_container/figure_container";
+import { GridAddRowsFooter } from "../grid_add_rows_footer/grid_add_rows_footer";
+import { ZoomedMouseEvent } from "../helpers/zoom";
+interface Props {
+    onCellDoubleClicked: (col: HeaderIndex, row: HeaderIndex) => void;
+    onCellClicked: (col: HeaderIndex, row: HeaderIndex, modifiers: GridClickModifiers, zoomedMouseEvent: ZoomedMouseEvent<MouseEvent | PointerEvent>) => void;
+    onCellRightClicked: (col: HeaderIndex, row: HeaderIndex, coordinates: DOMCoordinates) => void;
+    onGridResized: () => void;
+    onGridMoved: (deltaX: Pixel, deltaY: Pixel) => void;
+    gridOverlayDimensions: string;
+}
+export declare class GridOverlay extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        onCellDoubleClicked: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onCellClicked: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onCellRightClicked: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onGridResized: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onGridMoved: FunctionConstructor;
+        gridOverlayDimensions: StringConstructor;
+        slots: {
+            type: ObjectConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        FiguresContainer: typeof FiguresContainer;
+        GridAddRowsFooter: typeof GridAddRowsFooter;
+    };
+    static defaultProps: {
+        onCellDoubleClicked: () => void;
+        onCellClicked: () => void;
+        onCellRightClicked: () => void;
+        onGridResized: () => void;
+    };
+    private gridOverlay;
+    private cellPopovers;
+    private paintFormatStore;
+    private hoveredIconStore;
+    setup(): void;
+    get gridOverlayEl(): HTMLElement;
+    get style(): string;
+    get isPaintingFormat(): boolean;
+    onPointerMove(ev: MouseEvent): void;
+    onPointerDown(ev: PointerEvent): void;
+    onClick(ev: MouseEvent): void;
+    onCellClicked(zoomedMouseEvent: ZoomedMouseEvent<MouseEvent | PointerEvent>): void;
+    onDoubleClick(ev: MouseEvent): void;
+    onContextMenu(ev: MouseEvent): void;
+    private getCartesianCoordinates;
+    private getInteractiveIconAtEvent;
+}
+export {};

package/dist/types/components/grid_overlay/hovered_icon_store.d.ts

@@ -0,0 +1,12 @@
+import { SpreadsheetStore } from "../../stores";
+import { CellPosition } from "../../types";
+interface HoveredIcon {
+    id: string;
+    position: CellPosition;
+}
+export declare class HoveredIconStore extends SpreadsheetStore {
+    mutators: readonly ["setHoveredIcon"];
+    hoveredIcon: HoveredIcon | undefined;
+    setHoveredIcon(icon: HoveredIcon | undefined): void;
+}
+export {};

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

@@ -0,0 +1,27 @@
+import { Component } from "@odoo/owl";
+import { Rect } from "../../types";
+import { ClosedCellPopover, PositionedCellPopoverComponent } from "../../types/cell_popovers";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { Store } from "../../types/store_engine";
+import { CellPopoverStore } from "../popover";
+import { Popover } from "../popover/popover";
+interface Props {
+    gridRect: Rect;
+    onClosePopover: () => void;
+    onMouseWheel: (ev: WheelEvent) => void;
+}
+export declare class GridPopover extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        onClosePopover: FunctionConstructor;
+        onMouseWheel: FunctionConstructor;
+        gridRect: ObjectConstructor;
+    };
+    static components: {
+        Popover: typeof Popover;
+    };
+    protected cellPopovers: Store<CellPopoverStore>;
+    setup(): void;
+    get cellPopover(): PositionedCellPopoverComponent | ClosedCellPopover;
+}
+export {};

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

@@ -0,0 +1,46 @@
+import { Component } from "@odoo/owl";
+import { Action } from "../../actions/action";
+import { DOMCoordinates, Dimension, HeaderGroup, Rect } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+interface Props {
+    group: HeaderGroup;
+    layerOffset: number;
+    openContextMenu(position: DOMCoordinates, menuItems: Action[]): void;
+}
+interface GroupBox {
+    groupRect: Rect;
+    headerRect: Rect;
+    isEndHidden: boolean;
+}
+declare abstract class AbstractHeaderGroup extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        group: ObjectConstructor;
+        layerOffset: NumberConstructor;
+        openContextMenu: FunctionConstructor;
+    };
+    abstract dimension: Dimension;
+    toggleGroup(): void;
+    get groupBoxStyle(): string;
+    abstract get groupBorderStyle(): string;
+    abstract get groupHeaderStyle(): string;
+    get groupButtonStyle(): string;
+    get groupButtonIcon(): string;
+    get isGroupFolded(): boolean;
+    /** The box that will be used to draw the header group. */
+    abstract get groupBox(): GroupBox;
+    onContextMenu(ev: MouseEvent): void;
+}
+export declare class RowGroup extends AbstractHeaderGroup {
+    dimension: Dimension;
+    get groupBorderStyle(): string;
+    get groupHeaderStyle(): string;
+    get groupBox(): GroupBox;
+}
+export declare class ColGroup extends AbstractHeaderGroup {
+    dimension: Dimension;
+    get groupBorderStyle(): string;
+    get groupHeaderStyle(): string;
+    get groupBox(): GroupBox;
+}
+export {};

package/dist/types/components/header_group/header_group_container.d.ts

@@ -0,0 +1,34 @@
+import { Component } from "@odoo/owl";
+import { Action } from "../../actions/action";
+import { DOMCoordinates } from "../../types";
+import { Dimension, HeaderGroup, Pixel } from "../../types/misc";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { MenuPopover, MenuState } from "../menu_popover/menu_popover";
+import { ColGroup, RowGroup } from "./header_group";
+interface Props {
+    dimension: Dimension;
+    layers: HeaderGroup[][];
+}
+export declare class HeaderGroupContainer extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        dimension: StringConstructor;
+        layers: ArrayConstructor;
+    };
+    static components: {
+        RowGroup: typeof RowGroup;
+        ColGroup: typeof ColGroup;
+        MenuPopover: typeof MenuPopover;
+    };
+    menu: MenuState;
+    getLayerOffset(layerIndex: number): number;
+    onContextMenu(event: MouseEvent): void;
+    openContextMenu(position: DOMCoordinates, menuItems: Action[]): void;
+    closeMenu(): void;
+    get groupComponent(): typeof RowGroup;
+    get hasFrozenPane(): boolean;
+    get scrollContainerStyle(): string;
+    get frozenPaneContainerStyle(): string;
+    get frozenPaneContainerSize(): Pixel;
+}
+export {};

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

@@ -0,0 +1,177 @@
+import { Component } from "@odoo/owl";
+import { EdgeScrollInfo, HeaderDimensions, HeaderIndex, Pixel } from "../../types/index";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { ContextMenuType } from "../grid/grid";
+import { ZoomedMouseEvent } from "../helpers/zoom";
+import { UnhideColumnHeaders, UnhideRowHeaders } from "./unhide_headers";
+interface ResizerState {
+    resizerIsActive: boolean;
+    isResizing: boolean;
+    isMoving: boolean;
+    isSelecting: boolean;
+    waitingForMove: boolean;
+    activeElement: Pixel;
+    draggerLinePosition: Pixel;
+    draggerShadowPosition: Pixel;
+    draggerShadowThickness: number;
+    delta: number;
+    base: number;
+    position: "before" | "after";
+}
+interface ResizerProps {
+    onOpenContextMenu: (type: ContextMenuType, x: Pixel, y: Pixel) => void;
+}
+declare abstract class AbstractResizer extends Component<ResizerProps, SpreadsheetChildEnv> {
+    static props: {
+        onOpenContextMenu: FunctionConstructor;
+    };
+    private composerFocusStore;
+    PADDING: number;
+    MAX_SIZE_MARGIN: number;
+    MIN_ELEMENT_SIZE: number;
+    lastSelectedElementIndex: HeaderIndex | null;
+    state: ResizerState;
+    dragNDropGrid: {
+        start: (initialPointerCoordinates: {
+            clientX: number;
+            clientY: number;
+        }, onPointerMove: (col: HeaderIndex, row: HeaderIndex, ev: MouseEvent) => void, onPointerUp: () => void, startScrollDirection?: import("../helpers/drag_and_drop_grid_hook").DnDDirection) => void;
+    };
+    abstract _getEvOffset(zoomedMouseEvent: ZoomedMouseEvent<MouseEvent>): Pixel;
+    abstract _getViewportOffset(): Pixel;
+    abstract _getClientPosition(zoomedMouseEvent: ZoomedMouseEvent<MouseEvent>): Pixel;
+    abstract _getElementIndex(position: Pixel): HeaderIndex;
+    abstract _getSelectedZoneStart(): HeaderIndex;
+    abstract _getSelectedZoneEnd(): HeaderIndex;
+    abstract _getEdgeScroll(position: Pixel): EdgeScrollInfo;
+    abstract _getDimensionsInViewport(index: HeaderIndex): HeaderDimensions;
+    abstract _getElementSize(index: HeaderIndex): Pixel;
+    abstract _getMaxSize(): Pixel;
+    abstract _updateSize(): void;
+    abstract _moveElements(): void;
+    abstract _selectElement(index: HeaderIndex, addDistinctHeader: boolean): void;
+    abstract _increaseSelection(index: HeaderIndex): void;
+    abstract _fitElementSize(index: HeaderIndex): void;
+    abstract _getType(): ContextMenuType;
+    abstract _getActiveElements(): Set<HeaderIndex>;
+    abstract _getPreviousVisibleElement(index: HeaderIndex): HeaderIndex;
+    setup(): void;
+    _computeHandleDisplay(zoomedMouseEvent: ZoomedMouseEvent<MouseEvent>): void;
+    _computeGrabDisplay(zoomedMouseEvent: ZoomedMouseEvent<MouseEvent>): void;
+    onMouseMove(ev: MouseEvent): void;
+    onMouseLeave(): void;
+    onDblClick(ev: MouseEvent): void;
+    onMouseDown(ev: MouseEvent): void;
+    onClick(ev: MouseEvent): void;
+    select(ev: PointerEvent): void;
+    private startMovement;
+    private startSelection;
+    onContextMenu(ev: MouseEvent): void;
+}
+export declare class ColResizer extends AbstractResizer {
+    static props: {
+        onOpenContextMenu: FunctionConstructor;
+    };
+    static template: string;
+    static components: {
+        UnhideColumnHeaders: typeof UnhideColumnHeaders;
+    };
+    private colResizerRef;
+    setup(): void;
+    get sheetId(): import("../..").UID;
+    _getEvOffset(zoomedMouseEvent: ZoomedMouseEvent<MouseEvent>): Pixel;
+    _getViewportOffset(): Pixel;
+    _getClientPosition(zoomedMouseEvent: ZoomedMouseEvent<MouseEvent>): Pixel;
+    _getElementIndex(position: Pixel): HeaderIndex;
+    _getSelectedZoneStart(): HeaderIndex;
+    _getSelectedZoneEnd(): HeaderIndex;
+    _getEdgeScroll(position: Pixel): EdgeScrollInfo;
+    _getDimensionsInViewport(index: HeaderIndex): HeaderDimensions;
+    _getElementSize(index: HeaderIndex): Pixel;
+    _getMaxSize(): Pixel;
+    _updateSize(): void;
+    _moveElements(): void;
+    _selectElement(index: HeaderIndex, addDistinctHeader: boolean): void;
+    _increaseSelection(index: HeaderIndex): void;
+    _fitElementSize(index: HeaderIndex): void;
+    _getType(): ContextMenuType;
+    _getActiveElements(): Set<HeaderIndex>;
+    _getPreviousVisibleElement(index: HeaderIndex): HeaderIndex;
+    unhide(hiddenElements: HeaderIndex[]): void;
+    get mainUnhideHeadersProps(): {
+        headersGroups: import("../..").ConsecutiveIndexes[];
+        offset: Pixel;
+        headerRange: {
+            start: HeaderIndex;
+            end: HeaderIndex;
+        };
+    };
+    get frozenUnhideHeadersProps(): {
+        headersGroups: import("../..").ConsecutiveIndexes[];
+        headerRange: {
+            start: number;
+            end: number;
+        };
+    };
+    get frozenContainerStyle(): string;
+    get hasFrozenPane(): boolean;
+}
+export declare class RowResizer extends AbstractResizer {
+    static props: {
+        onOpenContextMenu: FunctionConstructor;
+    };
+    static template: string;
+    static components: {
+        UnhideRowHeaders: typeof UnhideRowHeaders;
+    };
+    setup(): void;
+    private rowResizerRef;
+    get sheetId(): import("../..").UID;
+    _getEvOffset(zoomedMouseEvent: ZoomedMouseEvent<MouseEvent>): Pixel;
+    _getViewportOffset(): Pixel;
+    _getClientPosition(zoomedMouseEvent: ZoomedMouseEvent<MouseEvent>): Pixel;
+    _getElementIndex(position: Pixel): HeaderIndex;
+    _getSelectedZoneStart(): HeaderIndex;
+    _getSelectedZoneEnd(): HeaderIndex;
+    _getEdgeScroll(position: Pixel): EdgeScrollInfo;
+    _getDimensionsInViewport(index: HeaderIndex): HeaderDimensions;
+    _getElementSize(index: HeaderIndex): Pixel;
+    _getMaxSize(): Pixel;
+    _updateSize(): void;
+    _moveElements(): void;
+    _selectElement(index: HeaderIndex, addDistinctHeader: boolean): void;
+    _increaseSelection(index: HeaderIndex): void;
+    _fitElementSize(index: HeaderIndex): void;
+    _getType(): ContextMenuType;
+    _getActiveElements(): Set<HeaderIndex>;
+    _getPreviousVisibleElement(index: HeaderIndex): HeaderIndex;
+    get mainUnhideHeadersProps(): {
+        headersGroups: import("../..").ConsecutiveIndexes[];
+        offset: Pixel;
+        headerRange: {
+            start: HeaderIndex;
+            end: HeaderIndex;
+        };
+    };
+    get frozenUnhideHeadersProps(): {
+        headersGroups: import("../..").ConsecutiveIndexes[];
+        headerRange: {
+            start: number;
+            end: number;
+        };
+    };
+    get frozenContainerStyle(): string;
+    get hasFrozenPane(): boolean;
+}
+export declare class HeadersOverlay extends Component<any, SpreadsheetChildEnv> {
+    static props: {
+        onOpenContextMenu: FunctionConstructor;
+    };
+    static template: string;
+    static components: {
+        ColResizer: typeof ColResizer;
+        RowResizer: typeof RowResizer;
+    };
+    selectAll(): void;
+}
+export {};