@odoo/o-spreadsheet 19.2.11 → 19.4.0-alpha.4

package/dist/types/helpers/references.d.ts

@@ -0,0 +1,27 @@
+import { Token } from "../formulas/tokenizer";
+export declare const cellReference: RegExp;
+export declare const rangeReference: RegExp;
+export declare function isColReference(xc: string): boolean;
+export declare function isRowReference(xc: string): boolean;
+export declare function isColHeader(str: string): boolean;
+export declare function isRowHeader(str: string): boolean;
+export declare function isSingleCellReference(xc: string): boolean;
+export declare function splitReference(ref: string): {
+    sheetName?: string;
+    xc: string;
+};
+export declare function getFullReference(sheetName: string | undefined, xc: string): string;
+type FixedReferenceType = "col" | "row" | "colrow" | "none";
+/**
+ * Change the reference types inside the given token, if the token represent a range or a cell
+ *
+ * Eg. :
+ *   A1 => $A$1 => A$1 => $A1 => A1
+ *   A1:$B$1 => $A$1:B$1 => A$1:$B1 => $A1:B1 => A1:$B$1
+ */
+export declare function loopThroughReferenceType(token: Readonly<Token>): Token;
+/**
+ * Returns the given XC with the given reference type.
+ */
+export declare function setXcToFixedReferenceType(xc: string, referenceType: FixedReferenceType): string;
+export {};

package/dist/types/helpers/rendering.d.ts

@@ -0,0 +1,3 @@
+import { Highlight } from "../types/misc";
+import { GridRenderingContext, Rect } from "../types/rendering";
+export declare function drawHighlight(renderingContext: GridRenderingContext, highlight: Highlight, rect: Rect): void;

package/dist/types/helpers/search.d.ts

@@ -0,0 +1,19 @@
+/** Methods from Odoo Web Utils  */
+/**
+ * This function computes a score that represent the fact that the
+ * string contains the pattern, or not
+ *
+ * - If the score is 0, the string does not contain the letters of the pattern in
+ *   the correct order.
+ * - if the score is > 0, it actually contains the letters.
+ *
+ * Better matches will get a higher score: consecutive letters are better,
+ * and a match closer to the beginning of the string is also scored higher.
+ */
+export declare function fuzzyMatch(pattern: string, str: string): number;
+/**
+ * Return a list of things that matches a pattern, ordered by their 'score' (
+ * higher score first). An higher score means that the match is better. For
+ * example, consecutive letters are considered a better match.
+ */
+export declare function fuzzyLookup<T>(pattern: string, list: T[], fn: (t: T) => string): T[];

package/dist/types/helpers/selection_statistic_functions.d.ts

@@ -0,0 +1,16 @@
+import { CellValueType, EvaluatedCell } from "../types/cells";
+import { Locale } from "../types/locale";
+import { Lazy } from "../types/misc";
+export interface StatisticFnResults {
+    [name: string]: {
+        value: Lazy<number | string> | undefined;
+        format?: string;
+    } | undefined;
+}
+export interface SelectionStatisticFunction {
+    name: string;
+    compute: (data: EvaluatedCell[], locale: Locale) => number | string;
+    types: CellValueType[];
+    format?: string;
+}
+export declare function computeStatisticFnResults(selectionStatisticFunctions: SelectionStatisticFunction[], cells: EvaluatedCell[], locale: Locale): StatisticFnResults;

package/dist/types/helpers/sheet.d.ts

@@ -0,0 +1,8 @@
+import { HeaderIndex, Row } from "../types/misc";
+export declare function createDefaultRows(rowNumber: number): Row[];
+export declare function moveHeaderIndexesOnHeaderAddition(indexHeaderAdded: HeaderIndex, numberAdded: number, headers: HeaderIndex[]): HeaderIndex[];
+export declare function moveHeaderIndexesOnHeaderDeletion(deletedHeaders: HeaderIndex[], headers: HeaderIndex[]): HeaderIndex[];
+export declare function getNextSheetName(existingNames: string[], baseName?: string): string;
+export declare function getDuplicateSheetName(nameToDuplicate: string, existingNames: string[]): string;
+export declare const toStandardizedSheetName: (name: string) => string;
+export declare function isSheetNameEqual(name1: string | undefined, name2: string | undefined): boolean;

package/dist/types/helpers/sort.d.ts

@@ -0,0 +1,16 @@
+import { CellValue, CellValueType, EvaluatedCell } from "../types/cells";
+import { SortDirection } from "../types/misc";
+type CellWithIndex = {
+    index: number;
+    type: CellValueType;
+    value: any;
+};
+export declare function cellsSortingCriterion(sortingOrder: string): (left: {
+    type: CellValueType;
+    value: CellValue;
+}, right: {
+    type: CellValueType;
+    value: CellValue;
+}) => number;
+export declare function sortCells(cells: EvaluatedCell[], sortDirection: SortDirection, emptyCellAsZero: boolean): CellWithIndex[];
+export {};

package/dist/types/helpers/sort_interactive.d.ts

@@ -0,0 +1,4 @@
+import { Position, SortDirection, SortOptions, UID, Zone } from "../types/misc";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+export declare function interactiveSortSelection(env: SpreadsheetChildEnv, sheetId: UID, anchor: Position, zone: Zone, sortDirection: SortDirection): void;
+export declare function interactiveSort(env: SpreadsheetChildEnv, sheetId: UID, anchor: Position, zone: Zone, sortDirection: SortDirection, sortOptions?: SortOptions): void;

package/dist/types/helpers/state_manager_helpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Create an empty structure according to the type of the node key:
+ * string: object
+ * number: array
+ */
+export declare function createEmptyStructure(node: string | number | any): {};

package/dist/types/helpers/table_helpers.d.ts

@@ -0,0 +1,9 @@
+import { CellPosition, UID, Zone } from "../types/misc";
+import { Range } from "../types/range";
+import { ComputedTableStyle, CoreTable, Filter, StaticTable, Table, TableConfig, TableMetaData, TableStyle } from "../types/table";
+/** Return the content zone of the table, ie. the table zone without the headers */
+export declare function getTableContentZone(tableZone: Zone, tableConfig: TableConfig): Zone | undefined;
+export declare function getTableTopLeft(table: Table | CoreTable): CellPosition;
+export declare function createFilter(id: UID, range: Range, config: TableConfig, createRange: (sheetId: UID, zone: Zone) => Range): Filter;
+export declare function isStaticTable(table: CoreTable): table is StaticTable;
+export declare function getComputedTableStyle(tableConfig: TableConfig, style: TableStyle, tableMetaData: TableMetaData): ComputedTableStyle;

package/dist/types/helpers/table_presets.d.ts

@@ -0,0 +1,84 @@
+import { Color } from "../types/misc";
+import { TableConfig, TableStyle, TableStyleTemplateName } from "../types/table";
+export declare const DEFAULT_TABLE_CONFIG: TableConfig;
+export declare const TABLE_STYLE_CATEGORIES: {
+    light: string;
+    medium: string;
+    dark: string;
+};
+export interface TableColorSet {
+    name: string;
+    coloredText: Color;
+    light: Color;
+    medium: Color;
+    dark: Color;
+    mediumBorder: Color;
+    highlight: Color;
+}
+export type TableStyleTemplate = (colorSet: TableColorSet) => Omit<TableStyle, "displayName">;
+export declare const TABLE_COLOR_SETS: {
+    black: {
+        name: string;
+        coloredText: string;
+        light: string;
+        medium: string;
+        dark: string;
+        mediumBorder: string;
+        highlight: string;
+    };
+    lightBlue: TableColorSet;
+    red: TableColorSet;
+    lightGreen: TableColorSet;
+    purple: TableColorSet;
+    gray: {
+        name: string;
+        coloredText: string;
+        light: string;
+        medium: string;
+        dark: string;
+        mediumBorder: string;
+        highlight: string;
+    };
+    orange: TableColorSet;
+};
+export declare const DARK_TABLE_COLOR_SETS: {
+    black: {
+        name: string;
+        coloredText: string;
+        light: string;
+        medium: string;
+        dark: string;
+        mediumBorder: string;
+        highlight: string;
+    };
+    orangeBlue: {
+        highlight: Color;
+        name: string;
+        coloredText: Color;
+        light: Color;
+        medium: Color;
+        dark: Color;
+        mediumBorder: Color;
+    };
+    purpleGreen: {
+        highlight: Color;
+        name: string;
+        coloredText: Color;
+        light: Color;
+        medium: Color;
+        dark: Color;
+        mediumBorder: Color;
+    };
+    redBlue: {
+        highlight: Color;
+        name: string;
+        coloredText: Color;
+        light: Color;
+        medium: Color;
+        dark: Color;
+        mediumBorder: Color;
+    };
+};
+export declare const TABLE_PRESETS: Record<string, TableStyle>;
+export declare const TABLE_STYLES_TEMPLATES: Record<TableStyleTemplateName, TableStyleTemplate>;
+export declare function buildTableStyle(name: string, templateName: TableStyleTemplateName, primaryColor: Color): TableStyle;

package/dist/types/helpers/text_helper.d.ts

@@ -0,0 +1,52 @@
+import { Canvas2DContext } from "../types/canvas";
+import { Cell } from "../types/cells";
+import { Locale } from "../types/locale";
+import { Pixel, PixelPosition, Style } from "../types/misc";
+export declare function computeTextLinesHeight(textLineHeight: number, numberOfLines?: number): number;
+export declare function getCanvas(width?: number, height?: number): Canvas2DContext;
+/**
+ * Get the default height of the cell given its style.
+ */
+export declare function getDefaultCellHeight(ctx: Canvas2DContext, cell: Cell | undefined, locale: Locale, colSize: number): number;
+export declare function getCellContentHeight(ctx: Canvas2DContext, content: string, style: Style | undefined, colSize: number): number;
+export declare function getDefaultContextFont(fontSize: number, bold?: boolean | undefined, italic?: boolean | undefined): string;
+export declare function computeMultilineTextSize(context: Canvas2DContext, textLines: string[], style?: Style, fontUnit?: "px" | "pt"): {
+    width: number;
+    height: number;
+};
+export declare function computeTextWidth(context: Canvas2DContext, text: string, style?: Style, fontUnit?: "px" | "pt"): number;
+export declare function computeTextDimension(context: Canvas2DContext, text: string, style: Style, fontUnit?: "px" | "pt"): {
+    width: number;
+    height: number;
+};
+export declare function fontSizeInPixels(fontSize: number): number;
+export declare function computeTextFont(style: Style, fontUnit?: "px" | "pt"): string;
+export declare function computeTextFontSizeInPixels(style?: Style): number;
+/**
+ * Return the given text, split in multiple lines if needed. The text will be split in multiple
+ * line if it contains NEWLINE characters, or if it's longer than the given width.
+ */
+export declare function splitTextToWidth(ctx: Canvas2DContext, text: string, style: Style | undefined, width: number | undefined): string[];
+/**
+ * Return the font size that makes the width of a text match the given line width.
+ * Minimum font size is 1.
+ *
+ * @param getTextWidth function that takes a fontSize as argument, and return the width of the text with this font size.
+ */
+export declare function getFontSizeMatchingWidth(lineWidth: number, maxFontSize: number, getTextWidth: (fontSize: number) => number, precision?: number): number;
+/** Transform a string to lowercase and removes whitespace from both ends of the string*/
+export declare function toTrimmedLowerCase(str: string | undefined): string;
+export declare function getContextFontSize(font: string): Pixel;
+export declare function clipTextWithEllipsis(ctx: Canvas2DContext, text: string, maxWidth: number): string;
+export declare function drawDecoratedText(context: Canvas2DContext, text: string, position: PixelPosition, underline?: boolean | undefined, strikethrough?: boolean | undefined, strokeWidth?: number): void;
+export declare function sliceTextToFitWidth(context: Canvas2DContext, width: number, text: string, style: Style, fontUnit?: "px" | "pt"): string;
+/**
+ * Return the position to draw text on a rotated canvas to ensure that the rotated text alignment correspond
+ * with to original's text vertical and horizontal alignment.
+ */
+export declare function computeRotationPosition(rect: {
+    x: number;
+    y: number;
+    textWidth: number;
+    textHeight: number;
+}, style: Style): PixelPosition;

package/dist/types/helpers/ui/cut_interactive.d.ts

@@ -0,0 +1,2 @@
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare function interactiveCut(env: SpreadsheetChildEnv): void;

package/dist/types/helpers/ui/freeze_interactive.d.ts

@@ -0,0 +1,3 @@
+import { Dimension, HeaderIndex } from "../../types/misc";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare function interactiveFreezeColumnsRows(env: SpreadsheetChildEnv, dimension: Dimension, base: HeaderIndex): void;

package/dist/types/helpers/ui/merge_interactive.d.ts

@@ -0,0 +1,7 @@
+import { UID, Zone } from "../../types/misc";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare const AddMergeInteractiveContent: {
+    MergeIsDestructive: string;
+    MergeInFilter: string;
+};
+export declare function interactiveAddMerge(env: SpreadsheetChildEnv, sheetId: UID, target: Zone[]): void;

package/dist/types/helpers/ui/named_range_interactive.d.ts

@@ -0,0 +1,4 @@
+import { CreateNamedRangeCommand, UpdateNamedRangeCommand } from "../../types/commands";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare function interactiveCreateNamedRange(env: SpreadsheetChildEnv, payload: Omit<CreateNamedRangeCommand, "type">): void;
+export declare function interactiveUpdateNamedRange(env: SpreadsheetChildEnv, payload: Omit<UpdateNamedRangeCommand, "type">): void;

package/dist/types/helpers/ui/paste_interactive.d.ts

@@ -0,0 +1,14 @@
+import { ClipboardPasteOptions, ParsedOSClipboardContent } from "../../types/clipboard";
+import { CopyPasteCellsAboveCommand, CopyPasteCellsOnLeftCommand, CopyPasteCellsOnZoneCommand, DispatchResult } from "../../types/commands";
+import { Zone } from "../../types/misc";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare const handleCopyPasteResult: (env: SpreadsheetChildEnv, command: CopyPasteCellsAboveCommand | CopyPasteCellsOnLeftCommand | CopyPasteCellsOnZoneCommand) => void;
+export declare const PasteInteractiveContent: {
+    wrongPasteSelection: string;
+    willRemoveExistingMerge: string;
+    wrongFigurePasteOption: string;
+    frozenPaneOverlap: string;
+};
+export declare function handlePasteResult(env: SpreadsheetChildEnv, result: DispatchResult): void;
+export declare function interactivePaste(env: SpreadsheetChildEnv, target: Zone[], pasteOption?: ClipboardPasteOptions): void;
+export declare function interactivePasteFromOS(env: SpreadsheetChildEnv, target: Zone[], parsedClipboardContent: ParsedOSClipboardContent, pasteOption?: ClipboardPasteOptions): Promise<void>;

package/dist/types/helpers/ui/sheet_interactive.d.ts

@@ -0,0 +1,3 @@
+import { UID } from "../../types/misc";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare function interactiveRenameSheet(env: SpreadsheetChildEnv, sheetId: UID, name: string, errorCallback: () => void): void;

package/dist/types/helpers/ui/split_to_columns_interactive.d.ts

@@ -0,0 +1,6 @@
+import { DispatchResult } from "../../types/commands";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare const SplitToColumnsInteractiveContent: {
+    SplitIsDestructive: string;
+};
+export declare function interactiveSplitToColumns(env: SpreadsheetChildEnv, separator: string, addNewColumns: boolean): DispatchResult;

package/dist/types/helpers/ui/table_interactive.d.ts

@@ -0,0 +1,9 @@
+import { DispatchResult } from "../../types/commands";
+import { UID } from "../../types/misc";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { TableConfig } from "../../types/table";
+/**
+ * Create a table on the selected zone, with UI warnings to the user if the creation fails.
+ * If a single cell is selected, expand the selection to non-empty adjacent cells to create a table.
+ */
+export declare function interactiveCreateTable(env: SpreadsheetChildEnv, sheetId: UID, tableConfig?: TableConfig): DispatchResult;

package/dist/types/helpers/ui/toggle_group_interactive.d.ts

@@ -0,0 +1,7 @@
+import { Dimension, HeaderIndex, UID } from "../../types/misc";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare const ToggleGroupInteractiveContent: {
+    CannotHideAllRows: string;
+    CannotHideAllColumns: string;
+};
+export declare function interactiveToggleGroup(env: SpreadsheetChildEnv, sheetId: UID, dimension: Dimension, start: HeaderIndex, end: HeaderIndex): void;

package/dist/types/helpers/uuid.d.ts

@@ -0,0 +1,18 @@
+export declare class UuidGenerator {
+    private static getCrypto;
+    /**
+     * Generates a custom UUID using a simple 36^12 method (8-character alphanumeric string with lowercase letters)
+     * This has a higher chance of collision than a UUIDv4, but not only faster to generate than an UUIDV4,
+     * it also has a smaller size, which is preferable to alleviate the overall data size.
+     *
+     * This method is preferable when generating uuids for the core data (sheetId, figureId, etc)
+     * as they will appear several times in the revisions and local history.
+     *
+     */
+    static smallUuid(): string;
+    /**
+     * Generates an UUIDV4, has astronomically low chance of collision, but is larger in size than the smallUuid.
+     * This method should be used when you need to avoid collisions at all costs, like the id of a revision.
+     */
+    static uuidv4(): string;
+}

package/dist/types/helpers/viewport_collection.d.ts

@@ -0,0 +1,196 @@
+import { CommandResult, ResizeViewportCommand, SetViewportOffsetCommand } from "../types/commands";
+import { AnchorOffset, Figure, FigureUI } from "../types/figure";
+import { RenderingGetters } from "../types/getters";
+import { CellPosition, Dimension, HeaderDimensions, HeaderIndex, PaneDivision, Pixel, PixelPosition, Position, UID, Zone } from "../types/misc";
+import { DOMCoordinates, DOMDimension, EdgeScrollInfo, Rect, SheetDOMScrollInfo, Viewport } from "../types/rendering";
+import { InternalViewport } from "./internal_viewport";
+type SheetViewports = {
+    topLeft: InternalViewport | undefined;
+    bottomLeft: InternalViewport | undefined;
+    topRight: InternalViewport | undefined;
+    bottomRight: InternalViewport;
+};
+/**
+ *   EdgeScrollCases Schema
+ *
+ *  The dots/double dots represent a freeze (= a split of viewports)
+ *  In this example, we froze vertically between columns D and E
+ *  and horizontally between rows 4 and 5.
+ *
+ *  One can see that we scrolled horizontally from column E to G and
+ *  vertically from row 5 to 7.
+ *
+ *     A  B  C  D   G  H  I  J  K  L  M  N  O  P  Q  R  S  T
+ *     _______________________________________________________
+ *  1 |           :                                           |
+ *  2 |           :                                           |
+ *  3 |           :        B   ↑                 6            |
+ *  4 |           :        |   |                 |            |
+ *     ····················+···+·················+············|
+ *  7 |           :        |   |                 |            |
+ *  8 |           :        ↓   2                 |            |
+ *  9 |           :                              |            |
+ * 10 |       A --+--→                           |            |
+ * 11 |           :                              |            |
+ * 12 |           :                              |            |
+ * 13 |        ←--+-- 1                          |            |
+ * 14 |           :                              |        3 --+--→
+ * 15 |           :                              |            |
+ * 16 |           :                              |            |
+ * 17 |       5 --+-------------------------------------------+--→
+ * 18 |           :                              |            |
+ * 19 |           :                  4           |            |
+ * 20 |           :                  |           |            |
+ *     ______________________________+___________| ____________
+ *                                   |           |
+ *                                   ↓           ↓
+ */
+export declare class ViewportCollection {
+    private paneDivision;
+    private sheetViewWidth;
+    private sheetViewHeight;
+    private zoomLevel;
+    getters: RenderingGetters;
+    viewports: Record<UID, SheetViewports | undefined>;
+    private gridOffsetX;
+    private gridOffsetY;
+    constructor(getters: RenderingGetters, paneDivision: Record<UID, PaneDivision>, sheetViewWidth?: Pixel, sheetViewHeight?: Pixel, zoomLevel?: number);
+    /**
+     * Return the index of a column given an offset x, based on the viewport left
+     * visible cell.
+     * It returns -1 if no column is found.
+     */
+    getColIndex(sheetId: UID, x: Pixel): HeaderIndex;
+    /**
+     * Return the index of a row given an offset y, based on the viewport top
+     * visible cell.
+     * It returns -1 if no row is found.
+     */
+    getRowIndex(sheetId: UID, y: Pixel): HeaderIndex;
+    getSheetViewDimensionWithHeaders(): DOMDimension;
+    getSheetViewDimension(): DOMDimension;
+    getGridOffset(): DOMCoordinates;
+    /**
+     * Return the DOM scroll info of the given sheet, ie. the offset between the viewport left/top side and
+     * the grid left/top side, corresponding to the scroll of the scrollbars and not snapped to the grid.
+     */
+    getSheetScrollInfo(sheetId: UID): SheetDOMScrollInfo;
+    getSheetViewVisibleCols(sheetId: UID): HeaderIndex[];
+    getSheetViewVisibleRows(sheetId: UID): HeaderIndex[];
+    /**
+     * Get the positions of all the cells that are visible in the viewport, taking merges into account.
+     */
+    getVisibleCellPositions(sheetId: UID): CellPosition[];
+    /**
+     * Return the main viewport maximum size relative to the client size.
+     */
+    getMainViewportRect(sheetId: UID): Rect;
+    getMaximumSheetOffset(sheetId: UID): {
+        maxOffsetX: Pixel;
+        maxOffsetY: Pixel;
+    };
+    getColRowOffsetInViewport(sheetId: UID, dimension: Dimension, referenceHeaderIndex: HeaderIndex, targetHeaderIndex: HeaderIndex): Pixel;
+    /**
+     * Check if a given position is visible in the viewport.
+     */
+    isVisibleInViewport({ sheetId, col, row }: CellPosition): boolean;
+    getScrollBarWidth(): Pixel;
+    getEdgeScrollCol(sheetId: UID, x: number, previousX: number, startingX: number): EdgeScrollInfo;
+    getEdgeScrollRow(sheetId: UID, y: number, previousY: number, startingY: number): EdgeScrollInfo;
+    /**
+     * Computes the coordinates and size to draw the zone on the canvas
+     */
+    getVisibleRect(sheetId: UID, zone: Zone): Rect;
+    /**
+     * Computes the coordinates and size to draw the zone on the canvas after it has been zoomed
+     */
+    getVisibleRectWithZoom(sheetId: UID, zone: Zone): Rect;
+    /**
+     * Computes the coordinates and size to draw the zone without taking the grid offset into account
+     */
+    getVisibleRectWithoutHeaders(sheetId: UID, zone: Zone): Rect;
+    /**
+     * Computes the actual size and position (:Rect) of the zone on the canvas
+     * regardless of the viewport dimensions.
+     */
+    getRect(sheetId: UID, zone: Zone): Rect;
+    /**
+     * Computes the actual size and position (:Rect) of the zone on the canvas
+     * regardless of the viewport dimensions.
+     */
+    getRectWithoutHeaders(sheetId: UID, zone: Zone): Rect;
+    /**
+     * Returns the position of the MainViewport relatively to the start of the grid (without headers)
+     * It corresponds to the summed dimensions of the visible cols/rows (in x/y respectively)
+     * situated before the pane divisions.
+     */
+    getMainViewportCoordinates(sheetId: UID): DOMCoordinates;
+    /**
+     * Returns the size, start and end coordinates of a column relative to the left
+     * column of the current viewport
+     */
+    getColDimensionsInViewport(sheetId: UID, col: HeaderIndex): HeaderDimensions;
+    /**
+     * Returns the size, start and end coordinates of a row relative to the top row
+     * of the current viewport
+     */
+    getRowDimensionsInViewport(sheetId: UID, row: HeaderIndex): HeaderDimensions;
+    getAllSheetViewportsZonesAndRect(sheetId: UID): {
+        zone: Zone;
+        rect: Rect;
+    }[];
+    getViewportZoomLevel(): number;
+    ensureMainViewportExist(sheetId: UID): void;
+    getSubViewports(sheetId: UID): InternalViewport[];
+    checkPositiveDimension(cmd: ResizeViewportCommand): CommandResult.Success | CommandResult.InvalidViewportSize;
+    checkValuesAreDifferent(cmd: ResizeViewportCommand): CommandResult.Success | CommandResult.ValuesNotChanged;
+    checkScrollingDirection(sheetId: UID, { offsetX, offsetY }: {
+        offsetX: Pixel;
+        offsetY: Pixel;
+    }): CommandResult;
+    checkIfViewportsWillChange(sheetId: UID, { offsetX, offsetY }: SetViewportOffsetCommand): CommandResult.Success | CommandResult.ViewportScrollLimitsReached;
+    getMainViewport(sheetId: UID): Viewport;
+    getMainInternalViewport(sheetId: UID): InternalViewport;
+    /** gets rid of deprecated sheetIds */
+    cleanViewports(): void;
+    resizeSheetView(height: Pixel, width: Pixel, gridOffsetX?: Pixel, gridOffsetY?: Pixel): void;
+    recomputeViewports(): void;
+    setSheetViewOffset(sheetId: UID, offsetX: Pixel, offsetY: Pixel): void;
+    getViewportOffset(sheetId: UID): {
+        x: number | Pixel;
+        y: number | Pixel;
+    };
+    resetViewports(sheetId: UID): void;
+    /**
+     * Adjust the viewport such that the anchor position is visible
+     */
+    refreshViewport(sheetId: UID, anchorPosition: Position): void;
+    /**
+     * Return the index of a col given a negative offset x, based on the main viewport top
+     * visible cell of the main viewport.
+     * It returns -1 if no col is found.
+     */
+    getColIndexLeftOfMainViewport(sheetId: UID, x: Pixel): HeaderIndex;
+    /**
+     * Return the index of a row given a negative offset y, based on the main viewport top
+     * visible cell of the main viewport.
+     * It returns -1 if no row is found.
+     */
+    getRowIndexTopOfMainViewport(sheetId: UID, y: Pixel): HeaderIndex;
+    getVisibleFigures(sheetId: UID): FigureUI[];
+    getFigureUI(sheetId: UID, figure: Figure): FigureUI;
+    getPositionAnchorOffset(sheetId: UID, position: PixelPosition): AnchorOffset;
+    isPixelPositionVisible(sheetId: UID, position: PixelPosition): boolean;
+    getFrozenSheetViewRatio(sheetId: UID): {
+        xRatio: number;
+        yRatio: number;
+    };
+    private mapViewportsToRect;
+    getGridOffsetX(): Pixel;
+    getGridOffsetY(): Pixel;
+    getZoomLevel(): number;
+    setZoomLevel(zoomLevel: number): void;
+    private getPaneDivisions;
+    setPaneDivision(sheetId: UID, paneDivision: PaneDivision): void;
+}
+export {};