@odoo/o-spreadsheet 19.2.12 → 19.3.3

package/dist/types/actions/action.d.ts

@@ -0,0 +1,104 @@
+import { Color } from "../types";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+export type MenuItemOrSeparator = Action | "separator";
+export interface ActionSpec {
+    /**
+     * String or a function to compute the name
+     */
+    name: string | ((env: SpreadsheetChildEnv) => string);
+    description?: string | ((env: SpreadsheetChildEnv) => string);
+    shortcut?: string;
+    /**
+     * which represents its position inside the
+     * menus (the lower sequence it has, the upper it is in the menu)
+     */
+    sequence?: number;
+    /**
+     * used for example to add child
+     */
+    id?: string;
+    /**
+     * Can be defined to compute the visibility of the item
+     */
+    isVisible?: (env: SpreadsheetChildEnv) => boolean;
+    /**
+     * Can be defined to compute if the user can click on the action
+     */
+    isEnabled?: (env: SpreadsheetChildEnv) => boolean;
+    /**
+     * Can be defined to compute if the action is active
+     */
+    isActive?: (env: SpreadsheetChildEnv) => boolean;
+    /**
+     * Can be defined to display an icon
+     */
+    icon?: string | ((env: SpreadsheetChildEnv) => string);
+    iconColor?: Color;
+    /**
+     * Can be defined to display another icon on the right of the item.
+     */
+    secondaryIcon?: string | ((env: SpreadsheetChildEnv) => string);
+    /**
+     * is the action allowed when running spreadsheet in readonly mode
+     */
+    isReadonlyAllowed?: boolean;
+    /**
+     * is the action allowed when the active sheet is locked
+     */
+    isEnabledOnLockedSheet?: boolean;
+    /**
+     *
+     * Execute the action. The action can return a result.
+     * The result will be carried by a `menu-clicked` event to the menu parent component.
+     */
+    execute?: (env: SpreadsheetChildEnv, isMiddleClick?: boolean) => unknown;
+    /**
+     * subitems associated to this item
+     * NB: an action without an execute function or children is not displayed !
+     */
+    children?: ActionChildren;
+    /**
+     * whether it should add a separator below the item in menus
+     * NB: a separator defined on the last item is not displayed !
+     */
+    separator?: boolean;
+    textColor?: Color;
+    onStartHover?: (env: SpreadsheetChildEnv) => void;
+    onStopHover?: (env: SpreadsheetChildEnv) => void;
+}
+export interface Action {
+    name: (env: SpreadsheetChildEnv) => string;
+    description: (env: SpreadsheetChildEnv) => string;
+    shortcut: string;
+    sequence: number;
+    id: string;
+    isVisible: (env: SpreadsheetChildEnv) => boolean;
+    isEnabled: (env: SpreadsheetChildEnv) => boolean;
+    isActive?: (env: SpreadsheetChildEnv) => boolean;
+    icon: (env: SpreadsheetChildEnv) => string;
+    iconColor?: Color;
+    secondaryIcon: (env: SpreadsheetChildEnv) => string;
+    isReadonlyAllowed: boolean;
+    isEnabledOnLockedSheet: boolean;
+    execute?: (env: SpreadsheetChildEnv, isMiddleClick?: boolean) => unknown;
+    children: (env: SpreadsheetChildEnv) => Action[];
+    separator: boolean;
+    textColor?: Color;
+    onStartHover?: (env: SpreadsheetChildEnv) => void;
+    onStopHover?: (env: SpreadsheetChildEnv) => void;
+}
+export interface ComputedAction extends Omit<Action, "name" | "description" | "icon" | "secondaryIcon" | "children"> {
+    name: string;
+    description: string;
+    icon: string;
+    secondaryIcon: string;
+}
+export type ActionBuilder = (env: SpreadsheetChildEnv) => ActionSpec[];
+type ActionChildren = (ActionSpec | ActionBuilder)[];
+export declare function createActions(menuItems: ActionSpec[]): Action[];
+export declare function createAction(item: ActionSpec): Action;
+export declare function getMenuItemsAndSeparators(env: SpreadsheetChildEnv, actions: Action[]): MenuItemOrSeparator[];
+export declare function isRootMenu(menu: Action): boolean;
+export declare function hasVisibleChildren(env: SpreadsheetChildEnv, menu: Action): boolean;
+export declare function isMenuItemEnabled(env: SpreadsheetChildEnv, menu: Action): boolean;
+export {};

package/dist/types/actions/data_actions.d.ts

@@ -0,0 +1,13 @@
+import { ActionSpec } from "./action";
+export declare const sortRange: ActionSpec;
+export declare const sortAscending: ActionSpec;
+export declare const dataCleanup: ActionSpec;
+export declare const removeDuplicates: ActionSpec;
+export declare const trimWhitespace: ActionSpec;
+export declare const sortDescending: ActionSpec;
+export declare const createRemoveFilter: ActionSpec;
+export declare const createRemoveFilterTool: ActionSpec;
+export declare const splitToColumns: ActionSpec;
+export declare const columnStatistics: ActionSpec;
+export declare const reinsertDynamicPivotMenu: ActionSpec;
+export declare const reinsertStaticPivotMenu: ActionSpec;

package/dist/types/actions/edit_actions.d.ts

@@ -0,0 +1,23 @@
+import { ActionSpec } from "./action";
+export declare const undo: ActionSpec;
+export declare const redo: ActionSpec;
+export declare const copy: ActionSpec;
+export declare const cut: ActionSpec;
+export declare const paste: ActionSpec;
+export declare const pasteSpecial: ActionSpec;
+export declare const pasteSpecialValue: ActionSpec;
+export declare const pasteSpecialFormat: ActionSpec;
+export declare const findAndReplace: ActionSpec;
+export declare const deleteValues: ActionSpec;
+export declare const deleteRows: ActionSpec;
+export declare const deleteRow: ActionSpec;
+export declare const clearRows: ActionSpec;
+export declare const deleteCols: ActionSpec;
+export declare const deleteCol: ActionSpec;
+export declare const clearCols: ActionSpec;
+export declare const deleteCells: ActionSpec;
+export declare const deleteCellShiftUp: ActionSpec;
+export declare const deleteCellShiftLeft: ActionSpec;
+export declare const mergeCells: ActionSpec;
+export declare const editTable: ActionSpec;
+export declare const deleteTable: ActionSpec;

package/dist/types/actions/figure_menu_actions.d.ts

@@ -0,0 +1,6 @@
+import { UID } from "..";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+import { Action } from "./action";
+export declare function getChartMenuActions(figureId: UID, env: SpreadsheetChildEnv): Action[];
+export declare function getImageMenuActions(figureId: UID, env: SpreadsheetChildEnv): Action[];
+export declare function getCarouselMenuActions(figureId: UID, env: SpreadsheetChildEnv): Action[];

package/dist/types/actions/format_actions.d.ts

@@ -0,0 +1,64 @@
+import { CellValue, Format } from "../types";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+import { ActionSpec } from "./action";
+export interface NumberFormatActionSpec extends ActionSpec {
+    format?: Format | ((env: SpreadsheetChildEnv) => Format);
+}
+/**
+ * Create a format action specification for a given format.
+ * The format can be dynamically computed from the environment.
+ */
+export declare function createFormatActionSpec({ name, format, descriptionValue, }: {
+    name: string;
+    descriptionValue: CellValue;
+    format: Format | ((env: SpreadsheetChildEnv) => Format);
+}): NumberFormatActionSpec;
+export declare const formatNumberAutomatic: NumberFormatActionSpec;
+export declare const formatNumberPlainText: NumberFormatActionSpec;
+export declare const formatNumberNumber: NumberFormatActionSpec;
+export declare const formatPercent: ActionSpec;
+export declare const formatNumberPercent: NumberFormatActionSpec;
+export declare const formatNumberScientific: NumberFormatActionSpec;
+export declare const formatNumberCurrency: NumberFormatActionSpec;
+export declare const formatNumberCurrencyRounded: NumberFormatActionSpec;
+export declare const formatNumberAccounting: NumberFormatActionSpec;
+export declare const EXAMPLE_DATE: CellValue;
+export declare const formatCustomCurrency: ActionSpec;
+export declare const formatNumberDate: NumberFormatActionSpec;
+export declare const formatNumberTime: NumberFormatActionSpec;
+export declare const formatNumberDateTime: NumberFormatActionSpec;
+export declare const formatNumberDuration: NumberFormatActionSpec;
+export declare const customDateFormat: ActionSpec;
+export declare const customNumberFormat: ActionSpec;
+export declare const formatNumberFullDateTime: NumberFormatActionSpec;
+export declare const increaseDecimalPlaces: ActionSpec;
+export declare const decreaseDecimalPlaces: ActionSpec;
+export declare const formatBold: ActionSpec;
+export declare const formatItalic: ActionSpec;
+export declare const formatUnderline: ActionSpec;
+export declare const formatRotation: ActionSpec;
+export declare const formatNoRotation: ActionSpec;
+export declare const formatRotation45: ActionSpec;
+export declare const formatRotation90: ActionSpec;
+export declare const formatRotation270: ActionSpec;
+export declare const formatRotation315: ActionSpec;
+export declare const formatStrikethrough: ActionSpec;
+export declare const formatFontSize: ActionSpec;
+export declare const formatAlignment: ActionSpec;
+export declare const formatAlignmentHorizontal: ActionSpec;
+export declare const formatAlignmentLeft: ActionSpec;
+export declare const formatAlignmentCenter: ActionSpec;
+export declare const formatAlignmentRight: ActionSpec;
+export declare const formatAlignmentVertical: ActionSpec;
+export declare const formatAlignmentTop: ActionSpec;
+export declare const formatAlignmentMiddle: ActionSpec;
+export declare const formatAlignmentBottom: ActionSpec;
+export declare const formatWrappingIcon: ActionSpec;
+export declare const formatWrapping: ActionSpec;
+export declare const formatWrappingOverflow: ActionSpec;
+export declare const formatWrappingWrap: ActionSpec;
+export declare const formatWrappingClip: ActionSpec;
+export declare const textColor: ActionSpec;
+export declare const fillColor: ActionSpec;
+export declare const formatCF: ActionSpec;
+export declare const clearFormat: ActionSpec;

package/dist/types/actions/insert_actions.d.ts

@@ -0,0 +1,33 @@
+import { ActionBuilder, ActionSpec } from "./action";
+export declare const insertRow: ActionSpec;
+export declare const rowInsertRowBefore: ActionSpec;
+export declare const topBarInsertRowsBefore: ActionSpec;
+export declare const cellInsertRowsBefore: ActionSpec;
+export declare const rowInsertRowsAfter: ActionSpec;
+export declare const topBarInsertRowsAfter: ActionSpec;
+export declare const insertCol: ActionSpec;
+export declare const colInsertColsBefore: ActionSpec;
+export declare const topBarInsertColsBefore: ActionSpec;
+export declare const cellInsertColsBefore: ActionSpec;
+export declare const colInsertColsAfter: ActionSpec;
+export declare const topBarInsertColsAfter: ActionSpec;
+export declare const insertCell: ActionSpec;
+export declare const insertCellShiftDown: ActionSpec;
+export declare const insertCellShiftRight: ActionSpec;
+export declare const insertChart: ActionSpec;
+export declare const insertCarousel: ActionSpec;
+export declare const insertPivot: ActionSpec;
+export declare const insertImage: ActionSpec;
+export declare const insertTable: ActionSpec;
+export declare const insertFunction: ActionSpec;
+export declare const insertFunctionSum: ActionSpec;
+export declare const insertFunctionAverage: ActionSpec;
+export declare const insertFunctionCount: ActionSpec;
+export declare const insertFunctionMax: ActionSpec;
+export declare const insertFunctionMin: ActionSpec;
+export declare const categorieFunctionAll: ActionSpec;
+export declare const categoriesFunctionListMenuBuilder: ActionBuilder;
+export declare const insertLink: ActionSpec;
+export declare const insertCheckbox: ActionSpec;
+export declare const insertDropdown: ActionSpec;
+export declare const insertSheet: ActionSpec;

package/dist/types/actions/menu_items_actions.d.ts

@@ -0,0 +1,57 @@
+import { Dimension, Format, Style } from "../types/index";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+import { ActionSpec } from "./action";
+export declare function setFormatter(env: SpreadsheetChildEnv, format: Format): void;
+export declare function setStyle(env: SpreadsheetChildEnv, style: Style): void;
+export declare const PASTE_ACTION: (env: SpreadsheetChildEnv) => Promise<void>;
+export declare const PASTE_AS_VALUE_ACTION: (env: SpreadsheetChildEnv) => Promise<void>;
+export declare const PASTE_FORMAT_ACTION: (env: SpreadsheetChildEnv) => Promise<void>;
+export declare const DELETE_CONTENT_ROWS_NAME: (env: SpreadsheetChildEnv) => string;
+export declare const DELETE_CONTENT_ROWS_ACTION: (env: SpreadsheetChildEnv) => void;
+export declare const DELETE_CONTENT_COLUMNS_NAME: (env: SpreadsheetChildEnv) => string;
+export declare const DELETE_CONTENT_COLUMNS_ACTION: (env: SpreadsheetChildEnv) => void;
+export declare const REMOVE_ROWS_NAME: (env: SpreadsheetChildEnv) => string;
+export declare const REMOVE_ROWS_ACTION: (env: SpreadsheetChildEnv) => void;
+export declare const CAN_REMOVE_COLUMNS_ROWS: (dimension: Dimension, env: SpreadsheetChildEnv) => boolean;
+export declare const REMOVE_COLUMNS_NAME: (env: SpreadsheetChildEnv) => string;
+export declare const NOT_ALL_VISIBLE_ROWS_SELECTED: (env: SpreadsheetChildEnv) => boolean;
+export declare const REMOVE_COLUMNS_ACTION: (env: SpreadsheetChildEnv) => void;
+export declare const NOT_ALL_VISIBLE_COLS_SELECTED: (env: SpreadsheetChildEnv) => boolean;
+export declare const INSERT_ROWS_BEFORE_ACTION: (env: SpreadsheetChildEnv) => void;
+export declare const INSERT_ROWS_AFTER_ACTION: (env: SpreadsheetChildEnv) => void;
+export declare const INSERT_COLUMNS_BEFORE_ACTION: (env: SpreadsheetChildEnv) => void;
+export declare const INSERT_COLUMNS_AFTER_ACTION: (env: SpreadsheetChildEnv) => void;
+export declare const HIDE_COLUMNS_NAME: (env: SpreadsheetChildEnv) => string;
+export declare const HIDE_ROWS_NAME: (env: SpreadsheetChildEnv) => string;
+export declare const CREATE_CHART: (env: SpreadsheetChildEnv) => void;
+export declare const CREATE_CAROUSEL: (env: SpreadsheetChildEnv) => void;
+export declare const CREATE_PIVOT: (env: SpreadsheetChildEnv) => void;
+export declare const REINSERT_DYNAMIC_PIVOT_CHILDREN: (env: SpreadsheetChildEnv) => {
+    id: string;
+    name: string;
+    sequence: number;
+    execute: (env: SpreadsheetChildEnv) => void;
+    isVisible: (env: SpreadsheetChildEnv) => boolean;
+}[];
+export declare const REINSERT_STATIC_PIVOT_CHILDREN: (env: SpreadsheetChildEnv) => {
+    id: string;
+    name: string;
+    sequence: number;
+    execute: (env: SpreadsheetChildEnv) => void;
+    isVisible: (env: SpreadsheetChildEnv) => boolean;
+}[];
+export declare const CREATE_IMAGE: (env: SpreadsheetChildEnv) => Promise<void>;
+export declare const FORMAT_PERCENT_ACTION: (env: SpreadsheetChildEnv) => void;
+export declare const OPEN_CF_SIDEPANEL_ACTION: (env: SpreadsheetChildEnv) => void;
+export declare const INSERT_LINK: (env: SpreadsheetChildEnv) => void;
+export declare const INSERT_LINK_NAME: (env: SpreadsheetChildEnv) => string;
+export declare const SELECTED_TABLE_HAS_FILTERS: (env: SpreadsheetChildEnv) => boolean;
+export declare const SELECTION_CONTAINS_SINGLE_TABLE: (env: SpreadsheetChildEnv) => boolean;
+export declare const IS_SELECTION_CONTINUOUS: (env: SpreadsheetChildEnv) => boolean;
+export declare const ADD_DATA_FILTER: (env: SpreadsheetChildEnv) => void;
+export declare const REMOVE_DATA_FILTER: (env: SpreadsheetChildEnv) => void;
+export declare const INSERT_TABLE: (env: SpreadsheetChildEnv) => void;
+export declare const DELETE_SELECTED_TABLE: (env: SpreadsheetChildEnv) => void;
+export declare const IS_ONLY_ONE_RANGE: (env: SpreadsheetChildEnv) => boolean;
+export declare const CAN_INSERT_HEADER: (env: SpreadsheetChildEnv, dimension: Dimension) => boolean;
+export declare const CREATE_OR_REMOVE_FILTER_ACTION: ActionSpec;

package/dist/types/actions/sheet_actions.d.ts

@@ -0,0 +1,15 @@
+import { ActionSpec } from "./action";
+export declare const linkSheet: ActionSpec;
+export declare const deleteSheet: ActionSpec;
+export declare const duplicateSheet: ActionSpec;
+export declare const renameSheet: (args: {
+    renameSheetCallback: () => void;
+}) => ActionSpec;
+export declare const changeSheetColor: (args: {
+    openSheetColorPickerCallback: () => void;
+}) => ActionSpec;
+export declare const sheetMoveRight: ActionSpec;
+export declare const sheetMoveLeft: ActionSpec;
+export declare const hideSheet: ActionSpec;
+export declare const lockSheet: ActionSpec;
+export declare const unlockSheet: ActionSpec;

package/dist/types/actions/view_actions.d.ts

@@ -0,0 +1,29 @@
+import { Dimension } from "../types/misc";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+import { ActionSpec } from "./action";
+export declare const hideCols: ActionSpec;
+export declare const unhideCols: ActionSpec;
+export declare const unhideAllCols: ActionSpec;
+export declare const hideRows: ActionSpec;
+export declare const unhideRows: ActionSpec;
+export declare const unhideAllRows: ActionSpec;
+export declare const unFreezePane: ActionSpec;
+export declare const freezePane: ActionSpec;
+export declare const unFreezeRows: ActionSpec;
+export declare const freezeFirstRow: ActionSpec;
+export declare const freezeSecondRow: ActionSpec;
+export declare const freezeCurrentRow: ActionSpec;
+export declare const unFreezeCols: ActionSpec;
+export declare const freezeFirstCol: ActionSpec;
+export declare const freezeSecondCol: ActionSpec;
+export declare const freezeCurrentCol: ActionSpec;
+export declare const viewGridlines: ActionSpec;
+export declare const irregularityMap: ActionSpec;
+export declare function zoomAction(zoom: number): ActionSpec;
+export declare const viewFormulas: ActionSpec;
+export declare const groupColumns: ActionSpec;
+export declare const groupRows: ActionSpec;
+export declare const ungroupColumns: ActionSpec;
+export declare const ungroupRows: ActionSpec;
+export declare function canUngroupHeaders(env: SpreadsheetChildEnv, dimension: Dimension): boolean;
+export declare const togglePinPanel: ActionSpec;

package/dist/types/clipboard_handlers/abstract_cell_clipboard_handler.d.ts

@@ -0,0 +1,8 @@
+import { ClipboardCellData, ClipboardCopyOptions, ClipboardOptions } from "../types/clipboard";
+import { HeaderIndex, UID, Zone } from "../types/misc";
+import { ClipboardHandler } from "./abstract_clipboard_handler";
+export declare class AbstractCellClipboardHandler<T, T1> extends ClipboardHandler<T> {
+    copy(data: ClipboardCellData, isCutOperation: boolean, mode?: ClipboardCopyOptions): T | undefined;
+    pasteFromCopy(sheetId: UID, target: Zone[], content: T1[][], options?: ClipboardOptions): void;
+    protected pasteZone(sheetId: UID, col: HeaderIndex, row: HeaderIndex, data: T1[][], clipboardOptions?: ClipboardOptions): void;
+}

package/dist/types/clipboard_handlers/abstract_clipboard_handler.d.ts

@@ -0,0 +1,15 @@
+import { ClipboardCopyOptions, ClipboardData, ClipboardOptions, ClipboardPasteTarget } from "../types/clipboard";
+import { CommandDispatcher, CommandResult } from "../types/commands";
+import { Getters } from "../types/getters";
+import { UID, Zone } from "../types/misc";
+export declare class ClipboardHandler<T> {
+    protected getters: Getters;
+    protected dispatch: CommandDispatcher["dispatch"];
+    constructor(getters: Getters, dispatch: CommandDispatcher["dispatch"]);
+    copy(data: ClipboardData, isCutOperation: boolean, mode?: ClipboardCopyOptions): T | undefined;
+    paste(target: ClipboardPasteTarget, clippedContent: T, options: ClipboardOptions): void;
+    isPasteAllowed(sheetId: UID, target: Zone[], content: T, option: ClipboardOptions): CommandResult;
+    isCutAllowed(data: ClipboardData): CommandResult;
+    getPasteTarget(sheetId: UID, target: Zone[], content: T, options: ClipboardOptions): ClipboardPasteTarget;
+    convertTextToClipboardData(data: string): T | undefined;
+}

package/dist/types/clipboard_handlers/abstract_figure_clipboard_handler.d.ts

@@ -0,0 +1,5 @@
+import { ClipboardFigureData } from "../types/clipboard";
+import { ClipboardHandler } from "./abstract_clipboard_handler";
+export declare class AbstractFigureClipboardHandler<T> extends ClipboardHandler<T> {
+    copy(data: ClipboardFigureData): T | undefined;
+}

package/dist/types/clipboard_handlers/borders_clipboard.d.ts

@@ -0,0 +1,17 @@
+import { Border, ClipboardCellData, ClipboardOptions, ClipboardPasteTarget, HeaderIndex, UID } from "../types";
+import { AbstractCellClipboardHandler } from "./abstract_cell_clipboard_handler";
+type ClipboardContent = {
+    borders: (Border | null)[][];
+};
+export declare class BorderClipboardHandler extends AbstractCellClipboardHandler<ClipboardContent, Border | null> {
+    private queuedBordersToAdd;
+    copy(data: ClipboardCellData): ClipboardContent | undefined;
+    paste(target: ClipboardPasteTarget, content: ClipboardContent, options: ClipboardOptions): void;
+    pasteZone(sheetId: UID, col: HeaderIndex, row: HeaderIndex, borders: (Border | null)[][]): void;
+    /**
+     * Paste the border at the given position to the target position
+     */
+    private pasteBorder;
+    private executeQueuedChanges;
+}
+export {};

package/dist/types/clipboard_handlers/carousel_clipboard.d.ts

@@ -0,0 +1,19 @@
+import { SpreadsheetChart } from "../helpers/figures/chart";
+import { Carousel, ClipboardFigureData, ClipboardOptions, ClipboardPasteTarget, CommandResult, Figure, UID, Zone } from "../types";
+import { AbstractFigureClipboardHandler } from "./abstract_figure_clipboard_handler";
+type ClipboardContent = {
+    figureId: UID;
+    copiedSheetId: UID;
+    copiedFigure: Figure;
+    copiedCarousel: Carousel;
+    copiedCharts: {
+        [chartId: UID]: SpreadsheetChart;
+    };
+};
+export declare class CarouselClipboardHandler extends AbstractFigureClipboardHandler<ClipboardContent> {
+    copy(data: ClipboardFigureData): ClipboardContent | undefined;
+    getPasteTarget(sheetId: UID): ClipboardPasteTarget;
+    paste(target: ClipboardPasteTarget, clippedContent: ClipboardContent, options: ClipboardOptions): void;
+    isPasteAllowed(sheetId: UID, target: Zone[], content: any, option?: ClipboardOptions): CommandResult.Success | CommandResult.WrongFigurePasteOption | CommandResult.EmptyTarget;
+}
+export {};

package/dist/types/clipboard_handlers/cell_clipboard.d.ts

@@ -0,0 +1,29 @@
+import { ClipboardCell, ClipboardCellData, ClipboardCopyOptions, ClipboardOptions, ClipboardPasteTarget, CommandResult, HeaderIndex, UID, Zone } from "../types";
+import { AbstractCellClipboardHandler } from "./abstract_cell_clipboard_handler";
+interface ClipboardContent {
+    cells: ClipboardCell[][];
+    zones: Zone[];
+    sheetId: UID;
+}
+export declare class CellClipboardHandler extends AbstractCellClipboardHandler<ClipboardContent, ClipboardCell> {
+    isCutAllowed(data: ClipboardCellData): CommandResult.Success | CommandResult.WrongCutSelection;
+    copy(data: ClipboardCellData, isCutOperation: boolean, mode?: ClipboardCopyOptions): ClipboardContent | undefined;
+    isPasteAllowed(sheetId: UID, target: Zone[], content: ClipboardContent, clipboardOptions: ClipboardOptions): CommandResult;
+    /**
+     * Paste the clipboard content in the given target
+     */
+    paste(target: ClipboardPasteTarget, content: ClipboardContent, options: ClipboardOptions): void;
+    getPasteTarget(sheetId: UID, target: Zone[], content: ClipboardContent, options?: ClipboardOptions): ClipboardPasteTarget;
+    private pasteFromCut;
+    /**
+     * Clear the clipped zones: remove the cells and clear the formatting
+     */
+    private clearClippedZones;
+    pasteZone(sheetId: UID, col: HeaderIndex, row: HeaderIndex, cells: ClipboardCell[][], clipboardOptions?: ClipboardOptions): void;
+    /**
+     * Paste the cell at the given position to the target position
+     */
+    private pasteCell;
+    convertTextToClipboardData(text: string): ClipboardContent;
+}
+export {};

package/dist/types/clipboard_handlers/chart_clipboard.d.ts

@@ -0,0 +1,15 @@
+import { SpreadsheetChart } from "../helpers/figures/chart";
+import { ClipboardFigureData, ClipboardOptions, ClipboardPasteTarget, CommandResult, Figure, UID, Zone } from "../types";
+import { AbstractFigureClipboardHandler } from "./abstract_figure_clipboard_handler";
+type ClipboardContent = {
+    figureId: UID;
+    copiedFigure: Figure;
+    copiedChart: SpreadsheetChart;
+};
+export declare class ChartClipboardHandler extends AbstractFigureClipboardHandler<ClipboardContent> {
+    copy(data: ClipboardFigureData): ClipboardContent | undefined;
+    getPasteTarget(sheetId: UID, target: Zone[], content: ClipboardContent, options?: ClipboardOptions): ClipboardPasteTarget;
+    paste(target: ClipboardPasteTarget, clippedContent: ClipboardContent, options: ClipboardOptions): void;
+    isPasteAllowed(sheetId: UID, target: Zone[], content: any, option?: ClipboardOptions): CommandResult.Success | CommandResult.WrongFigurePasteOption | CommandResult.EmptyTarget;
+}
+export {};

package/dist/types/clipboard_handlers/conditional_format_clipboard.d.ts

@@ -0,0 +1,25 @@
+import { CellPosition, ClipboardCellData, ClipboardOptions, ClipboardPasteTarget, ConditionalFormat, HeaderIndex, Maybe, UID } from "../types";
+import { AbstractCellClipboardHandler } from "./abstract_cell_clipboard_handler";
+interface ClipboardConditionalFormat {
+    position: CellPosition;
+    rules: ConditionalFormat[];
+}
+interface ClipboardContent {
+    cfRules: Maybe<ClipboardConditionalFormat>[][];
+}
+export declare class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler<ClipboardContent, Maybe<ClipboardConditionalFormat>> {
+    private readonly uuidGenerator;
+    private queuedChanges;
+    copy(data: ClipboardCellData): ClipboardContent | undefined;
+    paste(target: ClipboardPasteTarget, clippedContent: ClipboardContent, options: ClipboardOptions): void;
+    private pasteFromCut;
+    pasteZone(sheetId: UID, col: HeaderIndex, row: HeaderIndex, cfRules: Maybe<ClipboardConditionalFormat>[][], clipboardOptions?: ClipboardOptions): void;
+    private pasteCf;
+    /**
+     * Add or remove cells to a given conditional formatting rule.
+     */
+    private adaptCFRules;
+    private executeQueuedChanges;
+    private getCFToCopyTo;
+}
+export {};

package/dist/types/clipboard_handlers/data_validation_clipboard.d.ts

@@ -0,0 +1,25 @@
+import { CellPosition, ClipboardCellData, ClipboardOptions, ClipboardPasteTarget, DataValidationRule, HeaderIndex, Maybe, UID } from "../types";
+import { AbstractCellClipboardHandler } from "./abstract_cell_clipboard_handler";
+interface ClipboardDataValidationRule {
+    position: CellPosition;
+    rule: Maybe<DataValidationRule>;
+}
+interface ClipboardContent {
+    dvRules: Maybe<ClipboardDataValidationRule>[][];
+}
+export declare class DataValidationClipboardHandler extends AbstractCellClipboardHandler<ClipboardContent, Maybe<ClipboardDataValidationRule>> {
+    private readonly uuidGenerator;
+    private queuedChanges;
+    copy(data: ClipboardCellData): ClipboardContent | undefined;
+    paste(target: ClipboardPasteTarget, clippedContent: ClipboardContent, options: ClipboardOptions): void;
+    private pasteFromCut;
+    pasteZone(sheetId: UID, col: HeaderIndex, row: HeaderIndex, dvRules: Maybe<ClipboardDataValidationRule>[][], clipboardOptions?: ClipboardOptions): void;
+    private pasteDataValidation;
+    private getDataValidationRuleToCopyTo;
+    /**
+     * Add or remove XCs to a given data validation rule.
+     */
+    private adaptDataValidationRule;
+    private executeQueuedChanges;
+}
+export {};

package/dist/types/clipboard_handlers/image_clipboard.d.ts

@@ -0,0 +1,16 @@
+import { ClipboardFigureData, ClipboardOptions, ClipboardPasteTarget, CommandResult, Figure, UID, Zone } from "../types";
+import { Image } from "../types/image";
+import { AbstractFigureClipboardHandler } from "./abstract_figure_clipboard_handler";
+type ClipboardContent = {
+    figureId: UID;
+    copiedFigure: Figure;
+    copiedImage: Image;
+    sheetId: UID;
+};
+export declare class ImageClipboardHandler extends AbstractFigureClipboardHandler<ClipboardContent> {
+    copy(data: ClipboardFigureData): ClipboardContent | undefined;
+    getPasteTarget(sheetId: UID, target: Zone[], content: ClipboardContent, options?: ClipboardOptions): ClipboardPasteTarget;
+    paste(target: ClipboardPasteTarget, clippedContent: ClipboardContent, options: ClipboardOptions): void;
+    isPasteAllowed(sheetId: UID, target: Zone[], content: ClipboardContent, option?: ClipboardOptions): CommandResult.Success | CommandResult.WrongFigurePasteOption | CommandResult.EmptyTarget;
+}
+export {};

package/dist/types/clipboard_handlers/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/clipboard_handlers/merge_clipboard.d.ts

@@ -0,0 +1,16 @@
+import { ClipboardCellData, ClipboardOptions, ClipboardPasteTarget, HeaderIndex, Maybe, Merge, UID } from "../types";
+import { AbstractCellClipboardHandler } from "./abstract_cell_clipboard_handler";
+interface ClipboardContent {
+    sheetId: UID;
+    merges: Maybe<Merge>[][];
+}
+export declare class MergeClipboardHandler extends AbstractCellClipboardHandler<ClipboardContent, Maybe<Merge>> {
+    copy(data: ClipboardCellData): ClipboardContent | undefined;
+    /**
+     * Paste the clipboard content in the given target
+     */
+    paste(target: ClipboardPasteTarget, content: ClipboardContent, options: ClipboardOptions): void;
+    pasteZone(sheetId: UID, col: HeaderIndex, row: HeaderIndex, merges: Maybe<Merge>[][]): void;
+    private pasteMerge;
+}
+export {};

package/dist/types/clipboard_handlers/references_clipboard.d.ts

@@ -0,0 +1,11 @@
+import { ClipboardCellData, ClipboardOptions, ClipboardPasteTarget, UID, Zone } from "../types";
+import { AbstractCellClipboardHandler } from "./abstract_cell_clipboard_handler";
+interface ClipboardContent {
+    zones: Zone[];
+    sheetId: UID;
+}
+export declare class ReferenceClipboardHandler extends AbstractCellClipboardHandler<ClipboardContent, {}> {
+    copy(data: ClipboardCellData): ClipboardContent | undefined;
+    paste(target: ClipboardPasteTarget, content: ClipboardContent, options: ClipboardOptions): void;
+}
+export {};

package/dist/types/clipboard_handlers/sheet_clipboard.d.ts

@@ -0,0 +1,11 @@
+import { ClipboardOptions, CommandResult, UID, Zone } from "../types";
+import { AbstractCellClipboardHandler } from "./abstract_cell_clipboard_handler";
+type ClipboardContent = {
+    cells: any[][];
+    zones: Zone[];
+    sheetId: UID;
+};
+export declare class SheetClipboardHandler extends AbstractCellClipboardHandler<ClipboardContent, any> {
+    isPasteAllowed(sheetId: UID, target: Zone[], content: ClipboardContent, options: ClipboardOptions): CommandResult;
+}
+export {};

package/dist/types/clipboard_handlers/tables_clipboard.d.ts

@@ -0,0 +1,33 @@
+import { Border, ClipboardCellData, ClipboardCopyOptions, ClipboardOptions, ClipboardPasteTarget, CoreTableType, HeaderIndex, RangeData, Style, TableConfig, UID } from "../types";
+import { AbstractCellClipboardHandler } from "./abstract_cell_clipboard_handler";
+interface TableStyle {
+    style?: Style;
+    border?: Border;
+}
+interface CopiedTable {
+    range: RangeData;
+    config: TableConfig;
+    type: CoreTableType;
+}
+interface TableCell {
+    style?: TableStyle;
+    table?: CopiedTable;
+    isWholeTableCopied?: boolean;
+}
+interface ClipboardContent {
+    tableCells: TableCell[][];
+    sheetId: UID;
+}
+export declare class TableClipboardHandler extends AbstractCellClipboardHandler<ClipboardContent, TableCell> {
+    copy(data: ClipboardCellData, isCutOperation: boolean, mode?: ClipboardCopyOptions): ClipboardContent;
+    /**
+     * Get the style to copy for a cell. We need to copy both the table style and the cell style, because
+     * UPDATE_CELL replace the whole style of the cell with the style of the command, it doesn't merge the two.
+     */
+    private getTableStyleToCopy;
+    paste(target: ClipboardPasteTarget, content: ClipboardContent, options: ClipboardOptions): void;
+    private pasteFromCut;
+    protected pasteZone(sheetId: UID, col: HeaderIndex, row: HeaderIndex, tableCells: TableCell[][], clipboardOptions?: ClipboardOptions): void;
+    private pasteTableCell;
+}
+export {};