@odoo/o-spreadsheet 19.2.12 → 19.3.3

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

@@ -0,0 +1,252 @@
+import { DivisionByZeroError, EvaluationError } from "../types/errors";
+import { AddFunctionDescription } from "../types/functions";
+import { Arg, FunctionResultNumber, FunctionResultObject, Matrix, Maybe } from "../types/misc";
+export declare const AVEDEV: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => number | DivisionByZeroError;
+    isExported: true;
+};
+export declare const AVERAGE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const AVERAGE_WEIGHTED: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => EvaluationError | {
+        value: number;
+        format: string | undefined;
+    };
+};
+export declare const AVERAGEA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => DivisionByZeroError | {
+        value: number;
+        format: string | undefined;
+    };
+    isExported: true;
+};
+export declare const AVERAGEIF: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, criteriaRange: Arg, criterion: Maybe<FunctionResultObject>, averageRange: Arg) => number | DivisionByZeroError;
+    isExported: true;
+};
+export declare const AVERAGEIFS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, averageRange: Matrix<FunctionResultObject>, ...args: Arg[]) => number | DivisionByZeroError;
+    isExported: true;
+};
+export declare const COUNT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => number;
+    isExported: true;
+};
+export declare const COUNTA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...values: Arg[]) => number;
+    isExported: true;
+};
+export declare const COVAR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (dataY: Arg, dataX: Arg) => number;
+    isExported: true;
+};
+export declare const COVARIANCE_P: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (dataY: Arg, dataX: Arg) => number;
+    isExported: true;
+};
+export declare const COVARIANCE_S: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (dataY: Arg, dataX: Arg) => 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("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, n: Maybe<FunctionResultObject>) => FunctionResultObject;
+    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("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MAXA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MAXIFS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, range: Matrix<FunctionResultObject>, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const MEDIAN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...values: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MINA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const MINIFS: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, range: Matrix<FunctionResultObject>, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const PEARSON: AddFunctionDescription;
+export declare const CORREL: AddFunctionDescription;
+export declare const PERCENTILE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, percentile: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const PERCENTILE_EXC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, percentile: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const PERCENTILE_INC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, percentile: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const POLYFIT_COEFFS: AddFunctionDescription;
+export declare const POLYFIT_FORECAST: AddFunctionDescription;
+export declare const QUARTILE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, quartileNumber: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const QUARTILE_EXC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, quartileNumber: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    isExported: true;
+};
+export declare const QUARTILE_INC: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, quartileNumber: Maybe<FunctionResultObject>) => FunctionResultNumber;
+    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("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, data: Arg, n: Maybe<FunctionResultObject>) => FunctionResultObject;
+    isExported: true;
+};
+export declare const SPEARMAN: AddFunctionDescription;
+export declare const STDEV: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STDEV_P: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STDEV_S: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STDEVA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STDEVP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STDEVPA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const STEYX: AddFunctionDescription;
+export declare const TREND: AddFunctionDescription;
+export declare const VAR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const VAR_P: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const VAR_S: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const VARA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const VARP: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};
+export declare const VARPA: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => number;
+    isExported: true;
+};

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

@@ -0,0 +1,176 @@
+import { EvaluationError } from "../types/errors";
+import { Arg, FunctionResultNumber, FunctionResultObject, Maybe } from "../types/misc";
+export declare const CHAR: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, tableNumber: Maybe<FunctionResultObject>) => string | EvaluationError;
+    isExported: true;
+};
+export declare const CLEAN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const CONCATENATE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (...datas: Arg[]) => string;
+    isExported: true;
+};
+export declare const EXACT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (string1: Maybe<FunctionResultObject>, string2: Maybe<FunctionResultObject>) => boolean;
+    isExported: true;
+};
+export declare const FIND: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, searchFor: Maybe<FunctionResultObject>, textToSearch: Maybe<FunctionResultObject>, startingAt?: Maybe<FunctionResultObject>) => number | EvaluationError;
+    isExported: true;
+};
+export declare const FORMAT_LARGE_NUMBER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>, unite: Maybe<FunctionResultObject>) => FunctionResultNumber;
+};
+export declare const JOIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (delimiter: Maybe<FunctionResultObject>, ...valuesOrArrays: Arg[]) => string;
+};
+export declare const LEFT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => string | EvaluationError;
+    isExported: true;
+};
+export declare const LEN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const LOWER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const MID: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, starting_at: Maybe<FunctionResultObject>, extract_length: Maybe<FunctionResultObject>) => string | EvaluationError;
+    isExported: true;
+};
+export declare const PROPER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const REGEXTEST: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => boolean | EvaluationError;
+    isExported: true;
+};
+export declare const REGEXEXTRACT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, return_mode?: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => string | string[][] | EvaluationError | {
+        value: string;
+    };
+    isExported: true;
+};
+export declare const REGEXREPLACE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, replacement: Maybe<FunctionResultObject>, occurence?: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => string | EvaluationError;
+    isExported: true;
+};
+export declare const REPLACE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, position: Maybe<FunctionResultObject>, length: Maybe<FunctionResultObject>, newText: Maybe<FunctionResultObject>) => string | EvaluationError;
+    isExported: true;
+};
+export declare const RIGHT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => string | EvaluationError;
+    isExported: true;
+};
+export declare const SEARCH: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, searchFor: Maybe<FunctionResultObject>, textToSearch: Maybe<FunctionResultObject>, startingAt?: Maybe<FunctionResultObject>) => {
+        value: "#ERROR";
+        message: string;
+    } | {
+        value: number;
+        message?: undefined;
+    };
+    isExported: true;
+};
+export declare const SPLIT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>, delimiter: Maybe<FunctionResultObject>, splitByEach?: Maybe<FunctionResultObject>, removeEmptyText?: Maybe<FunctionResultObject>) => EvaluationError | import("..").Matrix<string>;
+    isExported: false;
+};
+export declare const SUBSTITUTE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, textToSearch: Maybe<FunctionResultObject>, searchFor: Maybe<FunctionResultObject>, replaceWith: Maybe<FunctionResultObject>, occurrenceNumber: Maybe<FunctionResultObject>) => string | EvaluationError;
+    isExported: true;
+};
+export declare const TEXTJOIN: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (delimiter: Maybe<FunctionResultObject>, ignoreEmpty?: Maybe<FunctionResultObject>, ...textsOrArrays: Arg[]) => string;
+    isExported: true;
+};
+export declare const TEXTSPLIT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: FunctionResultObject, colDelimiter: Arg, rowDelimiter: Arg, ignoreEmpty?: Maybe<FunctionResultObject>, matchMode?: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | import("..").Matrix<FunctionResultObject>;
+    isExported: true;
+};
+export declare const TRIM: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const UPPER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (text: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const TEXT: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, format: Maybe<FunctionResultObject>) => string;
+    isExported: true;
+};
+export declare const VALUE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    isExported: true;
+};
+export declare const TEXTAFTER: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: FunctionResultObject, delimiter: FunctionResultObject, matchIndex?: Maybe<FunctionResultObject>, matchMode?: Maybe<FunctionResultObject>, matchEnd?: Maybe<FunctionResultObject>, ifNotFound?: Maybe<FunctionResultObject>) => EvaluationError | FunctionResultObject;
+    isExported: true;
+};
+export declare const TEXTBEFORE: {
+    description: string;
+    args: import("..").ArgDefinition[];
+    compute: (this: import("..").EvalContext, text: FunctionResultObject, delimiter: FunctionResultObject, matchIndex?: Maybe<FunctionResultObject>, matchMode?: Maybe<FunctionResultObject>, matchEnd?: Maybe<FunctionResultObject>, ifNotFound?: Maybe<FunctionResultObject>) => EvaluationError | FunctionResultObject;
+    isExported: true;
+};

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

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

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

@@ -0,0 +1,6 @@
+import { ChartDefinition } from "../types/chart";
+import { CarouselItem } from "../types/figure";
+import { Getters } from "../types/getters";
+export declare const CAROUSEL_DEFAULT_CHART_DEFINITION: ChartDefinition;
+export declare function getCarouselItemPreview(getters: Getters, item: CarouselItem): string;
+export declare function getCarouselItemTitle(getters: Getters, item: CarouselItem): string;

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

@@ -0,0 +1,32 @@
+import { CompiledFormula } from "../../formulas/compiler";
+import { Cell, CellValue, EvaluatedCell, FormulaCell, LiteralCell } from "../../types/cells";
+import { CoreGetters } from "../../types/core_getters";
+import { Format, LocaleFormat } from "../../types/format";
+import { Locale } from "../../types/locale";
+import { CellPosition, FunctionResultObject, Style, UID } from "../../types/misc";
+export declare function evaluateLiteral(literalCell: LiteralCell, localeFormat: LocaleFormat, position?: CellPosition): EvaluatedCell;
+export declare function createCell(getters: CoreGetters, id: number, content: string, format: Format | undefined, style: Style | undefined, sheetId: UID, options?: {
+    avoidAutomaticDateFormat: boolean;
+}): Cell;
+export declare function createLiteralCell(getters: CoreGetters, id: number, content: string, format: Format | undefined, style: Style | undefined, options?: {
+    avoidAutomaticDateFormat: boolean;
+}): LiteralCell;
+export declare function createFormulaCell(getters: CoreGetters, id: number, content: string, format: Format | undefined, style: Style | undefined, sheetId: UID): FormulaCell;
+export declare function createFormulaCellFromCompiledFormula(id: number, compiledFormula: CompiledFormula, format: Format | undefined, style: Style | undefined): FormulaCell;
+export declare function parseLiteral(content: string, locale: Locale): CellValue;
+export declare function createEvaluatedCell(functionResult: FunctionResultObject, locale?: Locale, position?: CellPosition, cell?: Cell): EvaluatedCell;
+export declare function isNumberResult(result: FunctionResultObject | undefined): result is {
+    value: number;
+};
+export declare function isTextResult(result: FunctionResultObject | undefined): result is {
+    value: string;
+};
+export declare function isBooleanResult(result: FunctionResultObject | undefined): result is {
+    value: boolean;
+};
+export declare function isEmptyResult(result: FunctionResultObject | undefined): result is {
+    value: null;
+};
+export declare function isErrorResult(result: FunctionResultObject | undefined): result is {
+    value: string;
+};

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

@@ -0,0 +1,15 @@
+import { CellPosition, UID } from "../../types/misc";
+export declare class PositionMap<T> {
+    private map;
+    constructor(entries?: Iterable<readonly [CellPosition, T]>);
+    set({ sheetId, col, row }: CellPosition, value: T): void;
+    setMany(values: Iterable<[CellPosition, T]>): void;
+    get({ sheetId, col, row }: CellPosition): T | undefined;
+    getSheet(sheetId: UID): Record<number, Record<number, T>> | undefined;
+    clearSheet(sheetId: UID): void;
+    has({ sheetId, col, row }: CellPosition): boolean;
+    delete({ sheetId, col, row }: CellPosition): void;
+    keys(): CellPosition[];
+    keysForSheet(sheetId: UID): CellPosition[];
+    entries(): IterableIterator<[CellPosition, T]>;
+}

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

@@ -0,0 +1,16 @@
+import type { TimeScaleOptions } from "chart.js";
+import { Alias, DeepPartial, Format, Locale } from "../types";
+type LuxonFormat = string & Alias;
+/**
+ * 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"]>;
+/**
+ * Convert the given date format into a format that moment.js understands.
+ *
+ * https://github.com/moment/luxon/blob/master/docs/formatting.md#table-of-tokens
+ */
+export declare function convertDateFormatForLuxon(format: Format): LuxonFormat;
+export {};

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

@@ -0,0 +1,44 @@
+import { ClipboardHandler } from "../../clipboard_handlers/abstract_clipboard_handler";
+import { ClipboardCellData, ClipboardOptions, ClipboardPasteTarget, MinimalClipboardData, OSClipboardContent, ParsedOSClipboardContent } from "../../types/clipboard";
+import { UID, Zone } from "../../types/misc";
+import { SelectionStreamProcessor } from "../../types/selection_stream_processor";
+export declare function getClipboardDataPositions(sheetId: UID, zones: Zone[]): ClipboardCellData;
+/**
+ * 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.
+ */
+export declare function splitZoneForPaste(selection: Zone, splitWidth: number, splitHeight: number): Zone[];
+/**
+ * Compute the complete zones where to paste the current clipboard
+ */
+export declare function getPasteZones<T>(target: Zone[], content: T[][]): Zone[];
+export declare function parseOSClipboardContent(content: OSClipboardContent): ParsedOSClipboardContent;
+/**
+ * Fast-path extraction used to detect an internal o-spreadsheet paste without
+ * instantiating a DOMParser on large HTML payloads. Reads the dedicated
+ * `data-osheet-clipboard-id` marker instead of parsing the embedded JSON.
+ */
+export declare function getOSheetClipboardIdFromHTML(htmlContent: string | undefined): string | undefined;
+/**
+ * Applies each clipboard handler to paste its corresponding data into the target.
+ */
+export declare const applyClipboardHandlersPaste: (handlers: {
+    handlerName: string;
+    handler: ClipboardHandler<any>;
+}[], copiedData: MinimalClipboardData, target: ClipboardPasteTarget, options: ClipboardOptions) => void;
+/**
+ * Returns the paste target based on clipboard handlers.
+ * Also includes the full affected zone and the list of pasted zones for selection.
+ */
+export declare function getPasteTargetFromHandlers(sheetId: string, zones: Zone[], copiedData: MinimalClipboardData, handlers: {
+    handlerName: string;
+    handler: ClipboardHandler<any>;
+}[], options: ClipboardOptions): {
+    target: ClipboardPasteTarget;
+    zone?: Zone;
+    selectedZones: Zone[];
+};
+/**
+ * Updates the selection after a paste operation.
+ */
+export declare const selectPastedZone: (selection: SelectionStreamProcessor, sourceZones: Zone[], pastedZones: Zone[]) => void;

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

@@ -0,0 +1,2 @@
+import { ClipboardInterface } from "../../types/clipboard/clipboard_interface";
+export declare function instantiateClipboard(): ClipboardInterface;