@odoo/o-spreadsheet 19.2.11 → 19.3.2

package/dist/types/types/chart/chartjs_tree_map_type.d.ts

@@ -0,0 +1,131 @@
+/*!
+ * chartjs-chart-treemap v3.1.0
+ * https://chartjs-chart-treemap.pages.dev/
+ * (c) 2024 Jukka Kurkela
+ * Released under the MIT license
+ */
+import { Color, CoreChartOptions, DatasetController, Element, FontSpec, Scriptable, ScriptableContext, VisualElement } from "chart.js";
+import { TreeMapGroupColor } from "./tree_map_chart";
+type AnyObject = Record<string, unknown>;
+type TreemapScriptableContext = ScriptableContext<"treemap"> & {
+    raw: TreemapDataPoint;
+};
+type TreemapControllerDatasetCaptionsOptions = {
+    align?: Scriptable<LabelAlign, TreemapScriptableContext>;
+    color?: Scriptable<Color, TreemapScriptableContext>;
+    display?: boolean;
+    formatter?: Scriptable<string, TreemapScriptableContext>;
+    font?: FontSpec;
+    hoverColor?: Scriptable<Color, TreemapScriptableContext>;
+    hoverFont?: FontSpec;
+    padding?: number;
+};
+type TreemapControllerDatasetLabelsOptions = {
+    align?: Scriptable<LabelAlign, TreemapScriptableContext>;
+    color?: Scriptable<Color | Color[], TreemapScriptableContext>;
+    display?: boolean;
+    formatter?: Scriptable<string | Array<string>, TreemapScriptableContext>;
+    font?: Scriptable<FontSpec | FontSpec[], TreemapScriptableContext>;
+    hoverColor?: Scriptable<Color | Color[], TreemapScriptableContext>;
+    hoverFont?: Scriptable<FontSpec | FontSpec[], TreemapScriptableContext>;
+    overflow?: Scriptable<LabelOverflow, TreemapScriptableContext>;
+    padding?: number;
+    position?: Scriptable<LabelPosition, TreemapScriptableContext>;
+};
+export type LabelPosition = "top" | "middle" | "bottom";
+export type LabelAlign = "left" | "center" | "right";
+export type LabelOverflow = "cut" | "hidden" | "fit";
+type TreemapControllerDatasetDividersOptions = {
+    display?: boolean;
+    lineCapStyle?: string;
+    lineColor?: string;
+    lineDash?: number[];
+    lineDashOffset?: number;
+    lineWidth?: number;
+};
+export interface TreemapControllerDatasetOptions<DType> {
+    spacing?: number;
+    rtl?: boolean;
+    backgroundColor?: Scriptable<Color, TreemapScriptableContext>;
+    borderColor?: Scriptable<Color, TreemapScriptableContext>;
+    borderWidth?: number;
+    hoverBackgroundColor?: Scriptable<Color, TreemapScriptableContext>;
+    hoverBorderColor?: Scriptable<Color, TreemapScriptableContext>;
+    hoverBorderWidth?: number;
+    captions?: TreemapControllerDatasetCaptionsOptions;
+    dividers?: TreemapControllerDatasetDividersOptions;
+    labels?: TreemapControllerDatasetLabelsOptions;
+    label?: string;
+    data: TreemapDataPoint[];
+    groups?: Array<keyof DType>;
+    sumKeys?: Array<keyof DType>;
+    tree: number[] | DType[] | AnyObject;
+    treeLeafKey?: keyof DType;
+    key?: keyof DType;
+    hidden?: boolean;
+    displayMode?: "containerBoxes" | "headerBoxes";
+    groupColors?: TreeMapGroupColor[];
+}
+export interface TreemapDataPoint {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /**
+     * Value
+     */
+    v: number;
+    /**
+     * Sum
+     */
+    s: number;
+    /**
+     * Depth, only available if grouping
+     */
+    l?: number;
+    /**
+     * Group name, only available if grouping
+     */
+    g?: string;
+    /**
+     * Group Sum, only available if grouping
+     */
+    gs?: number;
+    /**
+     * additonal keys sums, only available if grouping
+     */
+    vs?: AnyObject;
+    isLeaf?: boolean;
+}
+declare module "chart.js" {
+    interface ChartTypeRegistry {
+        treemap: {
+            chartOptions: CoreChartOptions<"treemap">;
+            datasetOptions: TreemapControllerDatasetOptions<Record<string, unknown>>;
+            defaultDataPoint: TreemapDataPoint;
+            metaExtensions: AnyObject;
+            parsedDataType: unknown;
+            scales: never;
+        };
+    }
+}
+export interface TreemapOptions {
+    backgroundColor: Color;
+    borderColor: Color;
+    borderWidth: number | {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+}
+export interface TreemapConfig {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type TreemapController = DatasetController;
+export interface TreemapElement<T extends TreemapConfig = TreemapConfig, O extends TreemapOptions = TreemapOptions> extends Element<T, O>, VisualElement {
+}
+export {};

package/dist/types/types/chart/combo_chart.d.ts

@@ -0,0 +1,22 @@
+import { ChartConfiguration } from "chart.js";
+import { UID } from "../misc";
+import { Range } from "../range";
+import { CustomizedDataSet } from "./chart";
+import { CommonChartDefinition } from "./common_chart";
+export interface ComboChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly dataSetStyles: ComboChartDataSetStyle;
+    readonly type: "combo";
+    readonly hideDataMarkers?: boolean;
+    readonly zoomable?: boolean;
+}
+export type ComboChartDataSetStyle = Record<UID, CustomizedDataSet & {
+    type?: "bar" | "line";
+}>;
+export type ComboChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+    masterChartConfig?: ChartConfiguration;
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+};

package/dist/types/types/chart/common_chart.d.ts

@@ -0,0 +1,16 @@
+import { Color } from "../misc";
+import { Range } from "../range";
+import { AxesDesign, ChartDataSource, DataSetStyle, TitleDesign } from "./chart";
+export type VerticalAxisPosition = "left" | "right";
+export type LegendPosition = "top" | "bottom" | "left" | "right" | "none";
+export interface CommonChartDefinition<T extends string | Range = Range> {
+    readonly dataSetStyles: DataSetStyle;
+    readonly dataSource: ChartDataSource<T>;
+    readonly title: TitleDesign;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly aggregated?: boolean;
+    readonly axesDesign?: AxesDesign;
+    readonly showValues?: boolean;
+    readonly humanize?: boolean;
+}

package/dist/types/types/chart/funnel_chart.d.ts

@@ -0,0 +1,24 @@
+import { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { AxesDesign, ChartDataSource, DataSetStyle, TitleDesign } from "./chart";
+import { LegendPosition } from "./common_chart";
+export interface FunnelChartDefinition<T extends string | Range = Range> {
+    readonly type: "funnel";
+    readonly dataSetStyles: DataSetStyle;
+    readonly dataSource: ChartDataSource<T>;
+    readonly title: TitleDesign;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly horizontal?: boolean;
+    readonly axesDesign?: AxesDesign;
+    readonly aggregated?: boolean;
+    readonly showValues?: boolean;
+    readonly funnelColors?: FunnelChartColors;
+    readonly cumulative?: boolean;
+    readonly humanize?: boolean;
+}
+export type FunnelChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+};
+export type FunnelChartColors = (Color | undefined)[];

package/dist/types/types/chart/gauge_chart.d.ts

@@ -0,0 +1,89 @@
+import type { ChartOptions } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { TitleDesign } from "./chart";
+export interface GaugeChartDefinition<T extends string | Range = string> {
+    readonly type: "gauge";
+    readonly title: TitleDesign;
+    readonly dataRange?: T;
+    readonly sectionRule: SectionRule;
+    readonly background?: Color;
+    readonly humanize?: boolean;
+    readonly dataSource?: undefined;
+}
+export interface SectionRule {
+    readonly colors: ColorSet;
+    readonly rangeMin: string;
+    readonly rangeMax: string;
+    readonly lowerInflectionPoint: SectionThreshold;
+    readonly upperInflectionPoint: SectionThreshold;
+}
+interface ColorSet {
+    readonly lowerColor: Color;
+    readonly middleColor: Color;
+    readonly upperColor: Color;
+}
+export interface SectionThreshold {
+    readonly type: "number" | "percentage";
+    readonly value: string;
+    readonly operator: "<" | "<=";
+}
+export interface GaugeValue {
+    value: number;
+    label: string;
+}
+export interface GaugeInflectionValue extends GaugeValue {
+    operator: "<" | "<=";
+}
+export interface GaugeChartRuntime {
+    background: Color;
+    title: TitleDesign;
+    minValue: GaugeValue;
+    maxValue: GaugeValue;
+    gaugeValue?: GaugeValue;
+    inflectionValues: GaugeInflectionValue[];
+    colors: Color[];
+}
+export interface GaugeAnimatedRuntime extends GaugeChartRuntime {
+    animationValue?: number;
+}
+export interface GaugeChartOptions extends ChartOptions {
+    needle?: NeedleOptions;
+    valueLabel?: ValueLabelOptions;
+    inflectionValues: InflectionValuesOptions[];
+    minValue: string;
+    maxValue: string;
+}
+export interface NeedleOptions {
+    display?: boolean;
+    borderColor?: Color;
+    backgroundColor?: Color;
+    /**
+     * Needle width as the percentage of the chart area width
+     */
+    width?: number;
+}
+export interface InflectionValuesOptions {
+    value: number;
+    color: Color;
+    label: string;
+}
+export interface ValueLabelOptions {
+    display?: boolean;
+    formatter?: (value: any) => string;
+    font?: {
+        size?: number;
+        family?: string;
+        color?: Color;
+    };
+    backgroundColor?: Color;
+    borderColor?: Color;
+    borderRadius?: number;
+    padding?: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+}
+export {};

package/dist/types/types/chart/geo_chart.d.ts

@@ -0,0 +1,26 @@
+import { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { ChartColorScale, ChartRuntimeGenerationArgs } from "./chart";
+import { CommonChartDefinition } from "./common_chart";
+export interface GeoChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "geo";
+    readonly colorScale?: ChartColorScale;
+    readonly missingValueColor?: Color;
+    readonly region?: string;
+    readonly showColorBar?: boolean;
+}
+export type GeoChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+};
+export type GeoChartProjection = "azimuthalEqualArea" | "azimuthalEquidistant" | "gnomonic" | "orthographic" | "stereographic" | "equalEarth" | "albers" | "albersUsa" | "conicConformal" | "conicEqualArea" | "conicEquidistant" | "equirectangular" | "mercator" | "transverseMercator" | "naturalEarth1";
+export interface GeoChartRegion {
+    id: string;
+    label: string;
+    defaultProjection: GeoChartProjection;
+}
+export interface GeoChartRuntimeGenerationArgs extends ChartRuntimeGenerationArgs {
+    availableRegions: GeoChartRegion[];
+    getGeoJsonFeatures: (region: string) => GeoJSON.Feature[] | undefined;
+    geoFeatureNameToId: (region: string, featureName: string) => string | undefined;
+}

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

@@ -0,0 +1,13 @@
+export type * from "./bar_chart";
+export * from "./chart";
+export type * from "./chartjs_tree_map_type";
+export type * from "./common_chart";
+export type * from "./funnel_chart";
+export type * from "./gauge_chart";
+export type * from "./line_chart";
+export type * from "./pie_chart";
+export type * from "./pyramid_chart";
+export type * from "./scatter_chart";
+export type * from "./scorecard_chart";
+export * from "./sunburst_chart";
+export type * from "./waterfall_chart";

package/dist/types/types/chart/line_chart.d.ts

@@ -0,0 +1,21 @@
+import type { ChartConfiguration } from "chart.js";
+import { Range } from "../range";
+import { CommonChartDefinition } from "./common_chart";
+export interface LineChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "line";
+    readonly labelsAsText: boolean;
+    readonly stacked: boolean;
+    readonly aggregated?: boolean;
+    readonly cumulative: boolean;
+    readonly fillArea?: boolean;
+    readonly hideDataMarkers?: boolean;
+    readonly zoomable?: boolean;
+}
+export type LineChartRuntime = {
+    chartJsConfig: ChartConfiguration<"line">;
+    masterChartConfig?: ChartConfiguration<"line">;
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+};

package/dist/types/types/chart/pie_chart.d.ts

@@ -0,0 +1,15 @@
+import type { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { CommonChartDefinition } from "./common_chart";
+export interface PieChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "pie";
+    readonly slicesColors?: Color[];
+    readonly aggregated?: boolean;
+    readonly isDoughnut?: boolean;
+    readonly showValues?: boolean;
+    readonly pieHolePercentage?: number;
+}
+export type PieChartRuntime = {
+    chartJsConfig: ChartConfiguration<"pie" | "doughnut">;
+};

package/dist/types/types/chart/pyramid_chart.d.ts

@@ -0,0 +1,13 @@
+import { ChartConfiguration } from "chart.js";
+import { Range } from "../range";
+import { BarChartDefinition } from "./bar_chart";
+export interface PyramidChartDefinition<T extends string | Range = Range> extends Omit<BarChartDefinition<T>, "type" | "zoomable"> {
+    readonly type: "pyramid";
+}
+export type PyramidChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+};

package/dist/types/types/chart/radar_chart.d.ts

@@ -0,0 +1,18 @@
+import { ChartConfiguration } from "chart.js";
+import { Range } from "../range";
+import { CommonChartDefinition } from "./common_chart";
+export interface RadarChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "radar";
+    readonly aggregated?: boolean;
+    readonly stacked: boolean;
+    readonly fillArea?: boolean;
+    readonly hideDataMarkers?: boolean;
+    readonly humanize?: boolean;
+}
+export type RadarChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+};

package/dist/types/types/chart/scatter_chart.d.ts

@@ -0,0 +1,6 @@
+import { Range } from "../range";
+import { LineChartDefinition, LineChartRuntime } from "./line_chart";
+export interface ScatterChartDefinition<T extends string | Range = Range> extends Omit<LineChartDefinition<T>, "type" | "stacked" | "cumulative" | "zoomable" | "hideDataMarkers"> {
+    readonly type: "scatter";
+}
+export type ScatterChartRuntime = LineChartRuntime;

package/dist/types/types/chart/scorecard_chart.d.ts

@@ -0,0 +1,39 @@
+import { Color, Style } from "../misc";
+import { Range } from "../range";
+import { TitleDesign } from "./chart";
+export interface ScorecardChartDefinition<T extends string | Range = string> {
+    readonly type: "scorecard";
+    readonly title: TitleDesign;
+    readonly keyValue?: T;
+    readonly keyDescr?: TitleDesign;
+    readonly baseline?: T;
+    readonly baselineMode: BaselineMode;
+    readonly baselineDescr?: TitleDesign;
+    readonly background?: Color;
+    readonly baselineColorUp: Color;
+    readonly baselineColorDown: Color;
+    readonly humanize?: boolean;
+    readonly dataSource?: undefined;
+}
+export type BaselineMode = "text" | "difference" | "percentage" | "progress";
+export type BaselineArrowDirection = "neutral" | "up" | "down";
+export interface ProgressBar {
+    readonly value: number;
+    readonly color: Color;
+}
+export interface ScorecardChartRuntime {
+    readonly title: TitleDesign;
+    readonly keyValue: string;
+    readonly keyDescr: string;
+    readonly baselineDisplay: string;
+    readonly baselineColor?: string;
+    readonly baselineArrow: BaselineArrowDirection;
+    readonly baselineDescr?: string;
+    readonly background: Color;
+    readonly fontColor: Color;
+    readonly keyValueStyle?: Style;
+    readonly keyValueDescrStyle?: Style;
+    readonly baselineStyle?: Style;
+    readonly baselineDescrStyle?: Style;
+    readonly progressBar?: ProgressBar;
+}

package/dist/types/types/chart/sunburst_chart.d.ts

@@ -0,0 +1,42 @@
+import { ChartConfiguration, ChartDataset } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { ChartDataSource, ChartStyle, DataSetStyle, TitleDesign } from "./chart";
+import { LegendPosition } from "./common_chart";
+export interface SunburstChartDefinition<T extends string | Range = Range> {
+    readonly type: "sunburst";
+    readonly dataSetStyles: DataSetStyle;
+    readonly dataSource: ChartDataSource<T>;
+    readonly title: TitleDesign;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly showValues?: boolean;
+    readonly showLabels?: boolean;
+    readonly valuesDesign?: ChartStyle;
+    readonly groupColors?: (Color | undefined | null)[];
+    readonly pieHolePercentage?: number;
+    readonly humanize?: boolean;
+}
+export type SunburstChartRuntime = {
+    chartJsConfig: ChartConfiguration<"doughnut">;
+};
+export type SunburstChartRawData = {
+    label: string;
+    value: number;
+    groups: string[];
+};
+export interface SunburstTreeNode extends SunburstChartRawData {
+    children: SunburstTreeNode[];
+    depth: number;
+}
+export declare const SunburstChartDefaults: {
+    showValues: boolean;
+    showLabels: boolean;
+    valuesDesign: ChartStyle;
+};
+export interface SunburstChartJSDataset extends ChartDataset<"doughnut"> {
+    groupColors: {
+        label: string;
+        color: Color;
+    }[];
+}

package/dist/types/types/chart/tree_map_chart.d.ts

@@ -0,0 +1,52 @@
+import { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { ChartDataSource, DataSetStyle, TitleDesign } from "./chart";
+import { TreemapDataPoint } from "./chartjs_tree_map_type";
+import { LegendPosition } from "./common_chart";
+export interface TreeMapChartDefinition<T extends string | Range = Range> {
+    readonly type: "treemap";
+    readonly dataSetStyles: DataSetStyle;
+    readonly dataSource: ChartDataSource<T>;
+    readonly title: TitleDesign;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly showHeaders?: boolean;
+    readonly headerDesign?: TitleDesign;
+    readonly showValues?: boolean;
+    readonly showLabels?: boolean;
+    readonly valuesDesign?: TitleDesign;
+    readonly coloringOptions?: TreeMapColoringOptions;
+    readonly humanize?: boolean;
+}
+export type TreeMapCategoryColorOptions = {
+    type: "categoryColor";
+    colors: (Color | undefined | null)[];
+    useValueBasedGradient: boolean;
+};
+export type TreeMapColorScaleOptions = {
+    type: "colorScale";
+    minColor: Color;
+    midColor?: Color;
+    maxColor: Color;
+};
+export interface TreeMapGroupColor {
+    label: string;
+    color: Color;
+}
+export type TreeMapDataset = Record<string, string | number | undefined>[];
+export type TreeMapColoringOptions = TreeMapCategoryColorOptions | TreeMapColorScaleOptions;
+export type TreeMapChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+};
+export type TreeMapItem = {
+    raw: TreemapDataPoint;
+};
+export declare const TreeMapChartDefaults: {
+    showHeaders: boolean;
+    headerDesign: TitleDesign;
+    showValues: boolean;
+    showLabels: boolean;
+    valuesDesign: TitleDesign;
+    coloringOptions: TreeMapCategoryColorOptions;
+};

package/dist/types/types/chart/waterfall_chart.d.ts

@@ -0,0 +1,19 @@
+import { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { CommonChartDefinition, VerticalAxisPosition } from "./common_chart";
+export interface WaterfallChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "waterfall";
+    readonly verticalAxisPosition: VerticalAxisPosition;
+    readonly aggregated?: boolean;
+    readonly showSubTotals: boolean;
+    readonly showConnectorLines: boolean;
+    readonly firstValueAsSubtotal?: boolean;
+    readonly positiveValuesColor?: Color;
+    readonly negativeValuesColor?: Color;
+    readonly subTotalValuesColor?: Color;
+    readonly zoomable?: boolean;
+}
+export type WaterfallChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+};

package/dist/types/types/chart_subtype_properties.d.ts

@@ -0,0 +1,26 @@
+import { ChartDefinition, ChartType } from "./chart";
+export declare const chartCategories: {
+    line: string;
+    column: string;
+    bar: string;
+    area: string;
+    pie: string;
+    hierarchical: string;
+    misc: string;
+};
+type ChartUICategory = keyof typeof chartCategories;
+export interface ChartSubtypeProperties {
+    /** Type shown in the chart side panel */
+    chartSubtype: string;
+    /** Translated name of the displayType */
+    displayName: string;
+    /** Type of the chart in the model */
+    chartType: ChartType;
+    /** Match the chart type with a chart display type. Optional if chartType === displayType  */
+    matcher?: (definition: ChartDefinition) => boolean;
+    /** Additional definition options to create a chart of type displayType */
+    subtypeDefinition?: Partial<ChartDefinition>;
+    category: ChartUICategory;
+    preview: string;
+}
+export {};

package/dist/types/types/clipboard/clipboard_interface.d.ts

@@ -0,0 +1,12 @@
+import { OSClipboardContent } from "../clipboard";
+export type ClipboardReadResult = {
+    status: "ok";
+    content: OSClipboardContent;
+} | {
+    status: "permissionDenied" | "notImplemented";
+};
+export interface ClipboardInterface {
+    write(clipboardContent: OSClipboardContent): Promise<void>;
+    writeText(text: string): Promise<void>;
+    read(): Promise<ClipboardReadResult>;
+}

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

@@ -0,0 +1,57 @@
+import { AllowedImageMimeTypes, Image } from "./image";
+import { ClipboardCell, HeaderIndex, UID, Zone } from "./misc";
+export declare enum ClipboardMIMEType {
+    PlainText = "text/plain",
+    Html = "text/html",
+    Image = "image"
+}
+export type OSClipboardContent = {
+    [key in (typeof AllowedImageMimeTypes)[number]]?: Blob;
+} & {
+    [ClipboardMIMEType.PlainText]?: string;
+    [ClipboardMIMEType.Html]?: string;
+};
+export interface SpreadsheetClipboardData extends MinimalClipboardData {
+    version?: string;
+    clipboardId?: string;
+}
+export type ParsedOSClipboardContent = {
+    text?: string;
+    data?: SpreadsheetClipboardData;
+    imageBlob?: Blob;
+};
+export type ParsedOsClipboardContentWithImageData = ParsedOSClipboardContent & {
+    imageData?: Image;
+};
+export interface ClipboardOptions {
+    isCutOperation: boolean;
+    pasteOption?: ClipboardPasteOptions;
+    selectTarget?: boolean;
+}
+export type ClipboardPasteOptions = "onlyFormat" | "asValue";
+export type ClipboardCopyOptions = "copyPaste" | "shiftCells";
+export type ClipboardOperation = "CUT" | "COPY";
+export type ClipboardCellData = {
+    sheetId: UID;
+    zones: Zone[];
+    rowsIndexes: HeaderIndex[];
+    columnsIndexes: HeaderIndex[];
+    clippedZones: Zone[];
+};
+export type ClipboardFigureData = {
+    sheetId: UID;
+    figureId: UID;
+};
+export type ClipboardData = ClipboardCellData | ClipboardFigureData;
+export type ClipboardPasteTarget = {
+    sheetId: UID;
+    zones: Zone[];
+    figureId?: UID;
+};
+export type MinimalClipboardData = {
+    sheetId?: UID;
+    cells?: ClipboardCell[][];
+    zones?: Zone[];
+    figureId?: UID;
+    [key: string]: unknown;
+};

package/dist/types/types/collaborative/revisions.d.ts

@@ -0,0 +1,8 @@
+import { CoreCommand } from "../commands";
+import { UID } from "../misc";
+import { ClientId } from "./session";
+export interface RevisionData {
+    readonly id: UID;
+    readonly clientId: ClientId;
+    readonly commands: readonly CoreCommand[];
+}