@odoo/o-spreadsheet 17.0.84 → 17.0.96

package/dist/types/functions/module_statistical.d.ts

@@ -0,0 +1,296 @@
+import { AddFunctionDescription, Arg, ArgValue, CellValue, Matrix, Maybe, ValueAndFormat } from "../types";
+export declare const AVEDEV: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const AVERAGE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (value1: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const AVERAGE_WEIGHTED: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (values: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+};
+export declare const AVERAGEA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (value1: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const AVERAGEIF: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, criteriaRange: ArgValue, criterion: Maybe<CellValue>, averageRange: ArgValue) => number;
+    isExported: true;
+};
+export declare const AVERAGEIFS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, averageRange: Matrix<CellValue>, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const COUNT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const COUNTA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const COVAR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (dataY: ArgValue, dataX: ArgValue) => number;
+    isExported: true;
+};
+export declare const COVARIANCE_P: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (dataY: ArgValue, dataX: ArgValue) => number;
+    isExported: true;
+};
+export declare const COVARIANCE_S: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (dataY: ArgValue, dataX: ArgValue) => number;
+    isExported: true;
+};
+export declare const FORECAST: AddFunctionDescription;
+export declare const GROWTH: AddFunctionDescription;
+export declare const INTERCEPT: AddFunctionDescription;
+export declare const LARGE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeValueAndFormat: (this: import("../types").EvalContext, data: Arg, n: Maybe<ValueAndFormat>) => ValueAndFormat;
+    isExported: true;
+};
+export declare const LINEST: AddFunctionDescription;
+export declare const LOGEST: AddFunctionDescription;
+export declare const MATTHEWS: AddFunctionDescription;
+export declare const MAX: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (value1: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const MAXA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (value1: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const MAXIFS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, range: Matrix<CellValue>, ...args: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const MEDIAN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (value1: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const MIN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (value1: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const MINA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (value1: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const MINIFS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, range: Matrix<CellValue>, ...args: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const PEARSON: AddFunctionDescription;
+export declare const CORREL: AddFunctionDescription;
+export declare const PERCENTILE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (data: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, data: ArgValue, percentile: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const PERCENTILE_EXC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (data: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, data: ArgValue, percentile: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const PERCENTILE_INC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (data: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, data: ArgValue, percentile: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const POLYFIT_COEFFS: AddFunctionDescription;
+export declare const POLYFIT_FORECAST: AddFunctionDescription;
+export declare const QUARTILE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (data: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, data: ArgValue, quartileNumber: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const QUARTILE_EXC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (data: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, data: ArgValue, quartileNumber: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const QUARTILE_INC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (data: Arg) => import("../types").Format | undefined;
+    compute: (this: import("../types").EvalContext, data: ArgValue, quartileNumber: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const RANK: AddFunctionDescription;
+export declare const RSQ: AddFunctionDescription;
+export declare const SLOPE: AddFunctionDescription;
+export declare const SMALL: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeValueAndFormat: (this: import("../types").EvalContext, data: Arg, n: Maybe<ValueAndFormat>) => ValueAndFormat;
+    isExported: true;
+};
+export declare const SPEARMAN: AddFunctionDescription;
+export declare const STDEV: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const STDEV_P: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const STDEV_S: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const STDEVA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const STDEVP: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const STDEVPA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const STEYX: AddFunctionDescription;
+export declare const TREND: AddFunctionDescription;
+export declare const VAR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const VAR_P: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const VAR_S: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const VARA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const VARP: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const VARPA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, ...values: ArgValue[]) => number;
+    isExported: true;
+};

package/dist/types/functions/module_text.d.ts

@@ -0,0 +1,147 @@
+import { ArgValue, CellValue, Matrix, Maybe } from "../types";
+export declare const CHAR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (this: import("../types").EvalContext, tableNumber: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const CLEAN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (text: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const CONCATENATE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (...values: ArgValue[]) => string;
+    isExported: true;
+};
+export declare const EXACT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (string1: Maybe<CellValue>, string2: Maybe<CellValue>) => boolean;
+    isExported: true;
+};
+export declare const FIND: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, searchFor: Maybe<CellValue>, textToSearch: Maybe<CellValue>, startingAt?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const JOIN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (delimiter: Maybe<CellValue>, ...valuesOrArrays: ArgValue[]) => string;
+};
+export declare const LEFT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (this: import("../types").EvalContext, text: Maybe<CellValue>, ...args: Maybe<CellValue>[]) => string;
+    isExported: true;
+};
+export declare const LEN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (text: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const LOWER: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (text: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const MID: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (this: import("../types").EvalContext, text: Maybe<CellValue>, starting_at: Maybe<CellValue>, extract_length: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const PROPER: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (text: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const REPLACE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (this: import("../types").EvalContext, text: Maybe<CellValue>, position: Maybe<CellValue>, length: Maybe<CellValue>, newText: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const RIGHT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (this: import("../types").EvalContext, text: Maybe<CellValue>, ...args: Maybe<CellValue>[]) => string;
+    isExported: true;
+};
+export declare const SEARCH: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, searchFor: Maybe<CellValue>, textToSearch: Maybe<CellValue>, startingAt?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const SPLIT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["RANGE<STRING>"];
+    compute: (text: Maybe<CellValue>, delimiter: Maybe<CellValue>, splitByEach?: Maybe<CellValue>, removeEmptyText?: Maybe<CellValue>) => Matrix<string>;
+    isExported: false;
+};
+export declare const SUBSTITUTE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, textToSearch: Maybe<CellValue>, searchFor: Maybe<CellValue>, replaceWith: Maybe<CellValue>, occurrenceNumber: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const TEXTJOIN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (delimiter: Maybe<CellValue>, ignoreEmpty: Maybe<CellValue>, ...textsOrArrays: ArgValue[]) => string;
+    isExported: true;
+};
+export declare const TRIM: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (text: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const UPPER: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (text: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const TEXT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (this: import("../types").EvalContext, number: Maybe<CellValue>, format: Maybe<CellValue>) => string;
+    isExported: true;
+};
+export declare const VALUE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, value: Maybe<CellValue>) => number;
+    isExported: true;
+};

package/dist/types/functions/module_web.d.ts

@@ -0,0 +1,8 @@
+import { CellValue, Maybe } from "../types";
+export declare const HYPERLINK: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (url: Maybe<CellValue>, linkLabel: Maybe<CellValue>) => string;
+    isExported: true;
+};

package/dist/types/helpers/cells/cell_evaluation.d.ts

@@ -0,0 +1,6 @@
+import { CellValue, ErrorCell, EvaluatedCell, Locale, LocaleFormat } from "../../types";
+import { EvaluationError } from "../../types/errors";
+export declare function evaluateLiteral(content: string | undefined, localeFormat: LocaleFormat): EvaluatedCell;
+export declare function parseLiteral(content: string, locale: Locale): Exclude<CellValue, null>;
+export declare function createEvaluatedCell(value: CellValue | null, localeFormat: LocaleFormat): EvaluatedCell;
+export declare function errorCell(error: EvaluationError): ErrorCell;

package/dist/types/helpers/cells/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../links";
+export * from "./cell_evaluation";

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

@@ -0,0 +1,8 @@
+import type { TimeScaleOptions } from "chart.js";
+import { DeepPartial, Format, Locale } from "../types";
+/**
+ * Regex to test if a format string is a date format that can be translated into a luxon time format
+ */
+export declare const timeFormatLuxonCompatible: RegExp;
+/** Get the time options for the XAxis of ChartJS */
+export declare function getChartTimeOptions(labels: string[], labelFormat: Format, locale: Locale): DeepPartial<TimeScaleOptions["time"]>;

package/dist/types/helpers/clipboard/clipboard_abstract_cell_state.d.ts

@@ -0,0 +1,26 @@
+import { SelectionStreamProcessor } from "../../selection_stream/selection_stream_processor";
+import { CommandDispatcher, CommandResult, Dimension, Getters, GridRenderingContext, HeaderIndex, UID, Zone } from "../../types";
+import { ClipboardMIMEType, ClipboardOperation, ClipboardOptions, ClipboardState } from "./../../types/clipboard";
+/** Abstract state of the clipboard when copying/cutting content that is pasted in cells of the sheet */
+export declare abstract class ClipboardCellsAbstractState implements ClipboardState {
+    protected getters: Getters;
+    protected dispatch: CommandDispatcher["dispatch"];
+    protected selection: SelectionStreamProcessor;
+    readonly operation: ClipboardOperation;
+    readonly sheetId: UID;
+    constructor(operation: ClipboardOperation, getters: Getters, dispatch: CommandDispatcher["dispatch"], selection: SelectionStreamProcessor);
+    isCutAllowed(target: Zone[]): CommandResult;
+    isPasteAllowed(target: Zone[], clipboardOption?: ClipboardOptions): CommandResult;
+    /**
+     * Paste the clipboard content in the given target
+     */
+    abstract paste(target: Zone[], options?: ClipboardOptions | undefined): void;
+    /**
+     * Add columns and/or rows to ensure that col + width and row + height are still
+     * in the sheet
+     */
+    protected addMissingDimensions(width: number, height: number, col: number, row: number): void;
+    abstract getClipboardContent(): Record<ClipboardMIMEType, string>;
+    isColRowDirtyingClipboard(position: HeaderIndex, dimension: Dimension): boolean;
+    drawClipboard(renderingContext: GridRenderingContext): void;
+}

package/dist/types/helpers/clipboard/clipboard_cells_state.d.ts

@@ -0,0 +1,70 @@
+import { SelectionStreamProcessor } from "../../selection_stream/selection_stream_processor";
+import { CommandDispatcher, CommandResult, Dimension, Getters, GridRenderingContext, HeaderIndex, Zone } from "../../types";
+import { ClipboardCopyOptions, ClipboardOperation, ClipboardOptions } from "../../types/clipboard";
+import { ClipboardCellsAbstractState } from "./clipboard_abstract_cell_state";
+/** State of the clipboard when copying/cutting cells */
+export declare class ClipboardCellsState extends ClipboardCellsAbstractState {
+    private readonly cells;
+    private readonly copiedTables;
+    private readonly zones;
+    private readonly uuidGenerator;
+    private queuedBordersToAdd;
+    private queuedCFChanges;
+    private queuedDVChanges;
+    constructor(zones: Zone[], operation: ClipboardOperation, getters: Getters, dispatch: CommandDispatcher["dispatch"], selection: SelectionStreamProcessor, mode?: ClipboardCopyOptions);
+    isCutAllowed(target: Zone[]): CommandResult;
+    isPasteAllowed(target: Zone[], clipboardOption?: ClipboardOptions): CommandResult;
+    /**
+     * Paste the clipboard content in the given target
+     */
+    paste(target: Zone[], options?: ClipboardOptions | undefined): void;
+    private pasteFromCopy;
+    private pasteFromCut;
+    /**
+     * The clipped zone is copied as many times as it fits in the target.
+     * This returns the list of zones where the clipped zone is copy-pasted.
+     */
+    private pastedZones;
+    /**
+     * Compute the complete zones where to paste the current clipboard
+     */
+    protected getPasteZones(target: Zone[]): Zone[];
+    /**
+     * Update the selection with the newly pasted zone
+     */
+    private selectPastedZone;
+    /**
+     * Clear the clipped zones: remove the cells and clear the formatting
+     */
+    private clearClippedZones;
+    private pasteZone;
+    /**
+     * Paste the cell at the given position to the target position
+     */
+    private pasteCell;
+    /**
+     * If the origin position given is the top left of a merge, merge the target
+     * position.
+     */
+    private pasteMergeIfExist;
+    /** Paste the filter tables that are in the state */
+    private pasteCopiedTables;
+    getClipboardContent(): Record<string, string>;
+    private getPlainTextContent;
+    private getHTMLContent;
+    isColRowDirtyingClipboard(position: HeaderIndex, dimension: Dimension): boolean;
+    drawClipboard(renderingContext: GridRenderingContext): void;
+    private pasteCf;
+    /**
+     * Add or remove cells to a given conditional formatting rule.
+     */
+    private adaptCFRules;
+    private getCFToCopyTo;
+    private pasteDataValidation;
+    private getDataValidationRuleToCopyTo;
+    /**
+     * Add or remove XCs to a given data validation rule.
+     */
+    private adaptDataValidationRule;
+    private executeQueuedChanges;
+}

package/dist/types/helpers/clipboard/clipboard_figure_state.d.ts

@@ -0,0 +1,41 @@
+import { CommandDispatcher, CommandResult, Dimension, FigureSize, Getters, GridRenderingContext, HeaderIndex, UID, Zone } from "../../types";
+import { ClipboardContent, ClipboardOperation, ClipboardOptions, ClipboardState } from "./../../types/clipboard";
+/** State of the clipboard when copying/cutting figures */
+export declare class ClipboardFigureState implements ClipboardState {
+    readonly operation: ClipboardOperation;
+    private readonly getters;
+    private readonly dispatch;
+    readonly sheetId: UID;
+    private readonly copiedFigure;
+    private readonly copiedFigureContent;
+    constructor(operation: ClipboardOperation, getters: Getters, dispatch: CommandDispatcher["dispatch"]);
+    isCutAllowed(target: Zone[]): CommandResult;
+    isPasteAllowed(target: Zone[], option?: ClipboardOptions): CommandResult;
+    /**
+     * Paste the clipboard content in the given target
+     */
+    paste(target: Zone[]): void;
+    getClipboardContent(): ClipboardContent;
+    isColRowDirtyingClipboard(position: HeaderIndex, dimension: Dimension): boolean;
+    drawClipboard(renderingContext: GridRenderingContext): void;
+}
+export declare class ClipboardFigureChart {
+    private dispatch;
+    readonly sheetId: UID;
+    private readonly copiedChart;
+    constructor(dispatch: CommandDispatcher["dispatch"], getters: Getters, sheetId: UID, copiedFigureId: string);
+    paste(sheetId: UID, figureId: UID, position: {
+        x: number;
+        y: number;
+    }, size: FigureSize): void;
+}
+export declare class ClipboardFigureImage {
+    private dispatch;
+    readonly sheetId: UID;
+    private readonly copiedImage;
+    constructor(dispatch: CommandDispatcher["dispatch"], getters: Getters, sheetId: UID, copiedFigureId: string);
+    paste(sheetId: UID, figureId: UID, position: {
+        x: number;
+        y: number;
+    }, size: FigureSize): void;
+}

package/dist/types/helpers/clipboard/clipboard_os_state.d.ts

@@ -0,0 +1,12 @@
+import { SelectionStreamProcessor } from "../../selection_stream/selection_stream_processor";
+import { ClipboardOptions, CommandDispatcher, CommandResult, Getters, Zone } from "../../types";
+import { ClipboardCellsAbstractState } from "./clipboard_abstract_cell_state";
+/** State of the clipboard when copying/cutting from the OS clipboard*/
+export declare class ClipboardOsState extends ClipboardCellsAbstractState {
+    private readonly values;
+    constructor(content: string, getters: Getters, dispatch: CommandDispatcher["dispatch"], selection: SelectionStreamProcessor);
+    isPasteAllowed(target: Zone[], clipboardOption?: ClipboardOptions | undefined): CommandResult;
+    paste(target: Zone[], clipboardOption?: ClipboardOptions): void;
+    getClipboardContent(): Record<string, string>;
+    private getPasteZone;
+}

package/dist/types/helpers/clipboard/navigator_clipboard_wrapper.d.ts

@@ -0,0 +1,13 @@
+import { ClipboardContent } from "./../../types/clipboard";
+export type ClipboardReadResult = {
+    status: "ok";
+    content: string;
+} | {
+    status: "permissionDenied" | "notImplemented";
+};
+export interface ClipboardInterface {
+    write(clipboardContent: ClipboardContent): Promise<void>;
+    writeText(text: string): Promise<void>;
+    readText(): Promise<ClipboardReadResult>;
+}
+export declare function instantiateClipboard(): ClipboardInterface;