@odoo/o-spreadsheet 19.2.11 → 19.3.2

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";
+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";
+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";
+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,12 @@
+import { ClipboardPasteOptions, CopyPasteCellsAboveCommand, CopyPasteCellsOnLeftCommand, CopyPasteCellsOnZoneCommand, DispatchResult, ParsedOSClipboardContent, Zone } from "../../types";
+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";
+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,8 @@
+import { DispatchResult, UID } from "../../types";
+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";
+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 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.
+     *
+     */
+    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.
+     */
+    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 {};

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

@@ -0,0 +1,206 @@
+import { CellPosition, Position, UID, UnboundedZone, Zone, ZoneDimension } from "../types/misc";
+/**
+ * Convert from a cartesian reference to a (possibly unbounded) Zone
+ *
+ * Examples:
+ *    "A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *    "B:B" ==> Top 0, Bottom undefined, Left: 1, Right: 1
+ *    "B2:B" ==> Top 1, Bottom undefined, Left: 1, Right: 1, hasHeader: 1
+ *    "Sheet1!A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "Sheet1!B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *
+ * @param xc the string reference to convert
+ *
+ */
+export declare function toUnboundedZone(xc: string): UnboundedZone;
+/**
+ * Convert from a cartesian reference to a Zone.
+ * Will return throw an error if given a unbounded zone (eg : A:A).
+ *
+ * Examples:
+ *    "A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "B1:B3" ==> Top 0, Bottom 2, Left: 1, Right: 1
+ *    "Sheet1!A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "Sheet1!B1:B3" ==> Top 0, Bottom 2, Left: 1, Right: 1
+ *
+ * @param xc the string reference to convert
+ *
+ */
+export declare function toZone(xc: string): Zone;
+export declare function isXcValid(xc: string): boolean;
+/**
+ * Check that the given string is a correct xc representation (ie a valid zone). The try-catch
+ * added over the ixXcValid call is necessary because the function can throw an error if the
+ * string is not convertible to a zone by the toUnboundedZone function.
+ */
+export declare function isXcRepresentation(xc: string): boolean;
+/**
+ * Check that the zone has valid coordinates and in
+ * the correct order.
+ */
+export declare function isZoneValid(zone: Zone | UnboundedZone): boolean;
+/**
+ * Check that the zone properties are in the correct order.
+ */
+export declare function isZoneOrdered(zone: Zone | UnboundedZone): boolean;
+/**
+ * Convert from zone to a cartesian reference
+ *
+ */
+export declare function zoneToXc(zone: Zone | UnboundedZone): string;
+/**
+ * Expand a zone after inserting columns or rows.
+ *
+ * Don't resize the zone if a col/row was added right before/after the row but only move the zone.
+ */
+export declare function expandZoneOnInsertion<Z extends UnboundedZone | Zone>(zone: Z, start: "left" | "top", base: number, position: "after" | "before", quantity: number): Z;
+/**
+ * Update the selection after column/row addition
+ */
+export declare function updateSelectionOnInsertion(selection: Zone, start: "left" | "top", base: number, position: "after" | "before", quantity: number): Zone;
+/**
+ * Update the selection after column/row deletion
+ */
+export declare function updateSelectionOnDeletion(zone: Zone, start: "left" | "top", elements: number[]): Zone;
+/**
+ * Reduce a zone after deletion of elements
+ */
+export declare function reduceZoneOnDeletion<Z extends UnboundedZone | Zone>(zone: Z, start: "left" | "top", elements: number[]): Z | undefined;
+/**
+ * Compute the union of multiple zones.
+ */
+export declare function union(...zones: Zone[]): Zone;
+/**
+ * Compute the union of multiple unbounded zones.
+ */
+export declare function unionUnboundedZones(...zones: UnboundedZone[]): UnboundedZone;
+/**
+ * Compute the intersection of two zones. Returns nothing if the two zones don't overlap
+ */
+export declare function intersection(z1: UnboundedZone, z2: Zone): Zone | undefined;
+/**
+ * Two zones are equal if they represent the same area, so we clearly cannot use
+ * reference equality.
+ */
+export declare function isEqual(z1: UnboundedZone, z2: Zone): boolean;
+/**
+ * Return true if two zones overlap, false otherwise.
+ */
+export declare function overlap(z1: UnboundedZone, z2: Zone): boolean;
+/**
+ * Returns true if any two zones in the given list overlap.
+ */
+export declare function hasOverlappingZones(zones: Zone[]): boolean;
+export declare function isInside(col: number, row: number, zone: Zone): boolean;
+/**
+ * Check if a zone is inside another
+ */
+export declare function isZoneInside(smallZone: Zone, biggerZone: Zone): boolean;
+export declare function zoneToDimension(zone: Zone): ZoneDimension;
+export declare function isOneDimensional(zone: Zone): boolean;
+export declare function excludeTopLeft(zone: Zone): Zone[];
+/**
+ * Array of all positions in the zone.
+ */
+export declare function positions(zone: Zone): Position[];
+/**
+ * Array of all cell positions in the zone.
+ */
+export declare function cellPositions(sheetId: UID, zone: Zone): CellPosition[];
+export declare function reorderZone<Z extends UnboundedZone | Zone>(zone: Z): Z;
+/**
+ * This function returns a zone with coordinates modified according to the change
+ * applied to the zone. It may be possible to change the zone by resizing or moving
+ * it according to different dimensions.
+ *
+ * @param zone the zone to modify
+ * @param dimension the direction to change the zone among "columns", "rows" and
+ * "both"
+ * @param operation how to change the zone, modify its size "RESIZE" or modify
+ * its location "MOVE"
+ * @param by a number of how many units the change should be made. This parameter
+ * takes the form of a two-number array when the dimension is "both"
+ */
+export declare function createAdaptedZone<Dimension extends "columns" | "rows" | "both", Z extends UnboundedZone | Zone>(zone: Z, dimension: Dimension, operation: "MOVE" | "RESIZE", by: Dimension extends "both" ? [number, number] : number): Z;
+/**
+ * Returns a Zone array with unique occurrence of each zone.
+ * For each multiple occurrence, the occurrence with the largest index is kept.
+ * This allows to always have the last selection made in the last position.
+ * */
+export declare function uniqueZones(zones: Zone[]): Zone[];
+/**
+ * This function will find all overlapping zones in an array and transform them
+ * into an union of each one.
+ * */
+export declare function mergeOverlappingZones(zones: Zone[]): Zone[];
+/**
+ * This function will compare the modifications of selection to determine
+ * a cell that is part of the new zone and not the previous one.
+ */
+export declare function findCellInNewZone(oldZone: Zone, currentZone: Zone): Position;
+export declare function positionToZone(position: Position): Zone;
+/** Transform a zone into a zone with only its top-left position */
+export declare function zoneToTopLeft(zone: Zone): Zone;
+export declare function isFullRow(zone: UnboundedZone): boolean;
+export declare function isFullCol(zone: UnboundedZone): boolean;
+/** Returns the area of a zone */
+export declare function getZoneArea(zone: Zone): number;
+/**
+ * Checks if a single zone crosses any of the frozen panes based on the vertical and horizontal split.
+ */
+export declare function doesZoneCrossFrozenPane(zone: Zone, xSplit: number, ySplit: number): boolean;
+/**
+ * Checks if any of the given zones crosses any of the frozen panes.
+ */
+export declare function doesAnyZoneCrossFrozenPane(zones: Zone[], xSplit: number, ySplit: number): boolean;
+export declare function boundUnboundedZone(unboundedZone: Readonly<UnboundedZone>, sheetSize: ZoneDimension): Readonly<Zone>;
+/**
+ * Check if the zones are continuous, ie. if they can be merged into a single zone without
+ * including cells outside the zones
+ * */
+export declare function areZonesContinuous(zones: Zone[]): boolean;
+/** Return all the columns in the given list of zones */
+export declare function getZonesCols(zones: Zone[]): Set<number>;
+/**
+ * Returns one merged zone per column,
+ * spanning the full vertical range across all input zones.
+ */
+export declare function getZonesByColumns(zones: Zone[]): Zone[];
+/** Return all the rows in the given list of zones */
+export declare function getZonesRows(zones: Zone[]): Set<number>;
+export declare function unionPositionsToZone(positions: Position[]): Zone;
+/**
+ * Check if two zones are contiguous, ie. that they share a border
+ */
+export declare function areZoneContiguous(zone1: Zone, zone2: Zone): boolean;
+/**
+ * Merge contiguous and overlapping zones that are in the array into bigger zones
+ */
+export declare function mergeContiguousZones(zones: Zone[]): Zone[];
+/**
+ * Splits zone z2 by removing the overlapping zone z1 (fully inside z2).
+ * Returns the remaining parts of z2 that don't overlap with z1.
+ *
+ * Diagram:
+ * ┌──────────── z2 ─────────────┐
+ * │              1              │
+ * │--------─────────────--------│
+ * │  2    |     z1      |    3  │
+ * │--------─────────────--------│
+ * │              4              │
+ * └─────────────────────────────┘
+ *
+ * Input:
+ *   z1 = { top: 2, bottom: 3, left: 2, right: 3 }
+ *   z2 = { top: 1, bottom: 4, left: 1, right: 4 }
+ *
+ * Output:
+ * [
+ *   { top: 4, bottom: 4, left: 1, right: 4 },  // bottom
+ *   { top: 2, bottom: 3, left: 4, right: 4 },  // right
+ *   { top: 2, bottom: 3, left: 1, right: 1 },  // left
+ *   { top: 1, bottom: 1, left: 1, right: 4 }   // top
+ * ]
+ */
+export declare function splitZone(z1: Zone, z2: Zone): Zone[];