@odoo/o-spreadsheet 19.2.0-alpha.4 → 19.3.2

package/dist/types/types/conditional_formatting.d.ts

@@ -0,0 +1,114 @@
+import { DateCriterionValue } from "./generic_criterion";
+import { Style, UID } from "./misc";
+import { Range } from "./range";
+/**
+ * https://docs.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/025ea6e4-ad42-43ea-a016-16f4e4688ac8
+ */
+export interface ConditionalFormat {
+    id: UID;
+    rule: ConditionalFormatRule;
+    stopIfTrue?: boolean;
+    ranges: string[];
+}
+export interface ConditionalFormatInternal extends Omit<ConditionalFormat, "ranges" | "rule"> {
+    ranges: Range[];
+    rule: ConditionalFormatRuleInternal;
+}
+export type ConditionalFormatRule = SingleColorRules | ColorScaleRule | IconSetRule | DataBarRule;
+export type ConditionalFormatRuleInternal = SingleColorRules | ColorScaleRule | IconSetRule | DataBarRuleInternal;
+export type SingleColorRules = CellIsRule;
+export interface SingleColorRule {
+    style: Style;
+}
+export interface TextRule extends SingleColorRule {
+    text: string;
+}
+export interface CellIsRule extends SingleColorRule {
+    type: "CellIsRule";
+    operator: ConditionalFormattingOperatorValues;
+    values: string[];
+    dateValue?: DateCriterionValue;
+    isPercent?: boolean;
+    isBottom?: boolean;
+}
+export interface ExpressionRule extends SingleColorRule {
+    type: "ExpressionRule";
+}
+export type ThresholdType = "value" | "number" | "percentage" | "percentile" | "formula";
+export type ColorScaleThreshold = {
+    color: number;
+    type: ThresholdType;
+    value?: string;
+};
+export type ColorScaleMidPointThreshold = {
+    color: number;
+    type: Exclude<ThresholdType, "value">;
+    value: string;
+};
+export type IconThreshold = {
+    type: Exclude<ThresholdType, "value">;
+    operator: "gt" | "ge";
+    value: string;
+};
+export interface ColorScaleRule {
+    type: "ColorScaleRule";
+    minimum: ColorScaleThreshold;
+    maximum: ColorScaleThreshold;
+    midpoint?: ColorScaleMidPointThreshold;
+}
+export interface DataBarRule {
+    type: "DataBarRule";
+    color: number;
+    rangeValues?: string;
+}
+export interface DataBarRuleInternal extends Omit<DataBarRule, "rangeValues"> {
+    rangeValues?: Range;
+}
+export interface IconSet {
+    upper: string;
+    middle: string;
+    lower: string;
+}
+export interface IconSetRule {
+    type: "IconSetRule";
+    icons: IconSet;
+    upperInflectionPoint: IconThreshold;
+    lowerInflectionPoint: IconThreshold;
+}
+export interface ContainsTextRule extends TextRule {
+    type: "ContainsTextRule";
+}
+export interface NotContainsTextRule extends TextRule {
+    type: "NotContainsTextRule";
+}
+export interface BeginsWithRule extends TextRule {
+    type: "BeginsWithRule";
+}
+export interface EndsWithRule extends TextRule {
+    type: "EndsWithRule";
+}
+export interface containsBlanksRule extends TextRule {
+    type: "containsBlanksRule";
+}
+export interface notContainsBlanksRule extends TextRule {
+    type: "notContainsBlanksRule";
+}
+export interface containsErrorsRule extends SingleColorRule {
+    type: "containsErrorsRule";
+}
+export interface notContainsErrorsRule extends SingleColorRule {
+    type: "notContainsErrorsRule";
+}
+export interface TimePeriodRule extends SingleColorRule {
+    type: "TimePeriodRule";
+    timePeriod: string;
+}
+export interface AboveAverageRule extends SingleColorRule {
+    type: "AboveAverageRule";
+    aboveAverage: boolean;
+    equalAverage: boolean;
+}
+declare const cfOperators: readonly ["containsText", "notContainsText", "isGreaterThan", "isGreaterOrEqualTo", "isLessThan", "isLessOrEqualTo", "isBetween", "isNotBetween", "beginsWithText", "endsWithText", "isNotEmpty", "isEmpty", "isNotEqual", "isEqual", "customFormula", "dateIs", "dateIsBefore", "dateIsAfter", "dateIsOnOrBefore", "dateIsOnOrAfter", "top10", "uniqueValues", "duplicateValues"];
+export type ConditionalFormattingOperatorValues = (typeof cfOperators)[number];
+export declare const availableConditionalFormatOperators: Set<ConditionalFormattingOperatorValues>;
+export {};

package/dist/types/types/core_getters.d.ts

@@ -0,0 +1,74 @@
+import { BordersPlugin } from "../plugins/core/borders";
+import { CarouselPlugin } from "../plugins/core/carousel";
+import { CellPlugin } from "../plugins/core/cell";
+import { ChartPlugin } from "../plugins/core/chart";
+import { ConditionalFormatPlugin } from "../plugins/core/conditional_format";
+import { DataValidationPlugin } from "../plugins/core/data_validation";
+import { FigurePlugin } from "../plugins/core/figures";
+import { HeaderGroupingPlugin } from "../plugins/core/header_grouping";
+import { HeaderSizePlugin } from "../plugins/core/header_size";
+import { HeaderVisibilityPlugin } from "../plugins/core/header_visibility";
+import { ImagePlugin } from "../plugins/core/image";
+import { MergePlugin } from "../plugins/core/merge";
+import { NamedRangesPlugin } from "../plugins/core/named_range";
+import { PivotCorePlugin } from "../plugins/core/pivot";
+import { RangeAdapterPlugin } from "../plugins/core/range";
+import { SettingsPlugin } from "../plugins/core/settings";
+import { SheetPlugin } from "../plugins/core/sheet";
+import { TablePlugin } from "../plugins/core/tables";
+/**
+ * Union of all getter names of a plugin.
+ *
+ * e.g. With the following plugin
+ * ```ts
+ * class MyPlugin {
+ *   static getters = [
+ *     "getCell",
+ *     "getCellValue",
+ *   ] as const;
+ *   getCell() { ... }
+ *   getCellValue() { ... }
+ * }
+ * ```
+ * `type Names = GetterNames<typeof MyPlugin>` is equivalent to
+ * `type Names = "getCell" | "getCellValue"`
+ *
+ * Some technical comments:
+ *
+ * - Since the getter names are in a static array, the type of the plugin must
+ *   be given, not the class itself.
+ *
+ * - we need to index the getters array with every index:
+ *   `Plugin["getters"][0] | Plugin["getters"][1] | Plugin["getters"][2] | ...`
+ *   which is equivalent to `Plugin["getters"][0 | 1 | 2 | ...]`.
+ *   This can be generalized because the union of all indices `0 | 1 | 2 | 3 | ...`
+ *   is actually the type `number`.
+ */
+type GetterNames<Plugin extends {
+    getters: readonly string[];
+}> = Plugin["getters"][number];
+/**
+ * Extract getter methods from a plugin, based on its `getters` static array.
+ * @example
+ * class MyPlugin {
+ *   static getters = [
+ *     "getCell",
+ *     "getCellValue",
+ *   ] as const;
+ *   getCell() { ... }
+ *   getCellValue() { ... }
+ * }
+ * type MyPluginGetters = PluginGetters<typeof MyPlugin>;
+ * // MyPluginGetters is equivalent to:
+ * // {
+ * //   getCell: () => ...,
+ * //   getCellValue: () => ...,
+ * // }
+ */
+export type PluginGetters<Plugin extends {
+    new (...args: unknown[]): any;
+    getters: readonly string[];
+}> = Pick<InstanceType<Plugin>, GetterNames<Plugin>>;
+type RangeAdapterGetters = Pick<RangeAdapterPlugin, GetterNames<typeof RangeAdapterPlugin>>;
+export type CoreGetters = PluginGetters<typeof SheetPlugin> & PluginGetters<typeof HeaderSizePlugin> & PluginGetters<typeof HeaderVisibilityPlugin> & PluginGetters<typeof CellPlugin> & PluginGetters<typeof MergePlugin> & PluginGetters<typeof BordersPlugin> & PluginGetters<typeof ChartPlugin> & PluginGetters<typeof ImagePlugin> & PluginGetters<typeof CarouselPlugin> & PluginGetters<typeof FigurePlugin> & RangeAdapterGetters & PluginGetters<typeof ConditionalFormatPlugin> & PluginGetters<typeof TablePlugin> & PluginGetters<typeof SettingsPlugin> & PluginGetters<typeof HeaderGroupingPlugin> & PluginGetters<typeof DataValidationPlugin> & PluginGetters<typeof NamedRangesPlugin> & PluginGetters<typeof PivotCorePlugin>;
+export {};

package/dist/types/types/currency.d.ts

@@ -0,0 +1,7 @@
+export interface Currency {
+    name: string;
+    code: string;
+    symbol: string;
+    decimalPlaces: number;
+    position: "before" | "after";
+}

package/dist/types/types/data_validation.d.ts

@@ -0,0 +1,138 @@
+import { DateCriterionValue } from "./generic_criterion";
+import { Color, UID } from "./misc";
+import { Range } from "./range";
+export interface DataValidationRule {
+    id: UID;
+    criterion: DataValidationCriterion;
+    ranges: Range[];
+    isBlocking?: boolean;
+}
+export type TextContainsCriterion = {
+    type: "containsText";
+    values: string[];
+};
+export type TextNotContainsCriterion = {
+    type: "notContainsText";
+    values: string[];
+};
+export type TextIsCriterion = {
+    type: "isEqualText";
+    values: string[];
+};
+export type TextIsEmailCriterion = {
+    type: "isEmail";
+    values: string[];
+};
+export type TextIsLinkCriterion = {
+    type: "isLink";
+    values: string[];
+};
+export type DateIsCriterion = {
+    type: "dateIs";
+    dateValue: DateCriterionValue;
+    values: string[];
+};
+export type DateIsBeforeCriterion = {
+    type: "dateIsBefore";
+    dateValue: DateCriterionValue;
+    values: string[];
+};
+export type DateIsOnOrBeforeCriterion = {
+    type: "dateIsOnOrBefore";
+    dateValue: DateCriterionValue;
+    values: string[];
+};
+export type DateIsAfterCriterion = {
+    type: "dateIsAfter";
+    dateValue: DateCriterionValue;
+    values: string[];
+};
+export type DateIsOnOrAfterCriterion = {
+    type: "dateIsOnOrAfter";
+    dateValue: DateCriterionValue;
+    values: string[];
+};
+export type DateIsBetweenCriterion = {
+    type: "dateIsBetween";
+    values: string[];
+};
+export type DateIsNotBetweenCriterion = {
+    type: "dateIsNotBetween";
+    values: string[];
+};
+export type DateIsValidCriterion = {
+    type: "dateIsValid";
+    values: string[];
+};
+export type IsEqualCriterion = {
+    type: "isEqual";
+    values: string[];
+};
+export type IsNotEqualCriterion = {
+    type: "isNotEqual";
+    values: string[];
+};
+export type IsGreaterThanCriterion = {
+    type: "isGreaterThan";
+    values: string[];
+};
+export type IsGreaterOrEqualToCriterion = {
+    type: "isGreaterOrEqualTo";
+    values: string[];
+};
+export type IsLessThanCriterion = {
+    type: "isLessThan";
+    values: string[];
+};
+export type IsLessOrEqualToCriterion = {
+    type: "isLessOrEqualTo";
+    values: string[];
+};
+export type IsBetweenCriterion = {
+    type: "isBetween";
+    values: string[];
+};
+export type IsNotBetweenCriterion = {
+    type: "isNotBetween";
+    values: string[];
+};
+export type IsCheckboxCriterion = {
+    type: "isBoolean";
+    values: string[];
+};
+export type IsValueInListCriterion = {
+    type: "isValueInList";
+    values: string[];
+    colors?: Record<string, Color | undefined>;
+    displayStyle: "arrow" | "plainText" | "chip";
+};
+export type IsValueInRangeCriterion = {
+    type: "isValueInRange";
+    values: string[];
+    colors?: Record<string, Color | undefined>;
+    displayStyle: "arrow" | "plainText" | "chip";
+};
+export type Top10Criterion = {
+    type: "top10";
+    values: string[];
+    isPercent?: boolean;
+    isBottom?: boolean;
+};
+export type UniqueValuesCriterion = {
+    type: "uniqueValues";
+    values: string[];
+};
+export type DuplicateValuesCriterion = {
+    type: "duplicateValues";
+    values: string[];
+};
+export type CustomFormulaCriterion = {
+    type: "customFormula";
+    values: string[];
+};
+export type DataValidationCriterion = TextContainsCriterion | TextNotContainsCriterion | TextIsCriterion | TextIsEmailCriterion | TextIsLinkCriterion | IsBetweenCriterion | DateIsCriterion | DateIsBeforeCriterion | DateIsOnOrBeforeCriterion | DateIsAfterCriterion | DateIsOnOrAfterCriterion | DateIsBetweenCriterion | DateIsNotBetweenCriterion | DateIsValidCriterion | IsEqualCriterion | IsNotEqualCriterion | IsGreaterThanCriterion | IsGreaterOrEqualToCriterion | IsLessThanCriterion | IsLessOrEqualToCriterion | IsNotBetweenCriterion | IsCheckboxCriterion | IsValueInListCriterion | IsValueInRangeCriterion | CustomFormulaCriterion;
+export type DataValidationCriterionType = DataValidationCriterion["type"];
+export type DataValidationDateCriterion = Extract<DataValidationCriterion, {
+    dateValue: DateCriterionValue;
+}>;
+export declare const availableDataValidationOperators: Set<DataValidationCriterionType>;

package/dist/types/types/env.d.ts

@@ -0,0 +1,10 @@
+export interface EditTextOptions {
+    error?: string;
+    placeholder?: string;
+}
+export type NotificationType = "danger" | "info" | "success" | "warning";
+export interface InformationNotification {
+    text: string;
+    type: NotificationType;
+    sticky: boolean;
+}

package/dist/types/types/errors.d.ts

@@ -0,0 +1,45 @@
+import { CellPosition } from "./misc";
+export declare const CellErrorType: {
+    readonly NotAvailable: "#N/A";
+    readonly InvalidReference: "#REF";
+    readonly BadExpression: "#BAD_EXPR";
+    readonly CircularDependency: "#CYCLE";
+    readonly UnknownFunction: "#NAME?";
+    readonly DivisionByZero: "#DIV/0!";
+    readonly InvalidNumber: "#NUM!";
+    readonly SpilledBlocked: "#SPILL!";
+    readonly GenericError: "#ERROR";
+    readonly NullError: "#NULL!";
+};
+export type ErrorValue = (typeof CellErrorType)[keyof typeof CellErrorType];
+export declare const errorTypes: Set<string>;
+export declare class EvaluationError {
+    readonly message: string;
+    readonly value: string;
+    constructor(message?: string, value?: string);
+}
+export declare class BadExpressionError extends EvaluationError {
+    constructor(message?: string);
+}
+export declare class CircularDependencyError extends EvaluationError {
+    constructor(message?: string);
+}
+export declare class InvalidReferenceError extends EvaluationError {
+    constructor(message?: string);
+}
+export declare class NotAvailableError extends EvaluationError {
+    constructor(message?: string);
+}
+export declare class UnknownFunctionError extends EvaluationError {
+    constructor(message?: string);
+}
+export declare class SplillBlockedError extends EvaluationError {
+    readonly errorOriginPosition?: CellPosition | undefined;
+    constructor(message?: string, errorOriginPosition?: CellPosition | undefined);
+}
+export declare class DivisionByZeroError extends EvaluationError {
+    constructor(message?: string);
+}
+export declare class NumberTooLargeError extends EvaluationError {
+    constructor(message?: string);
+}

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

@@ -0,0 +1 @@
+export type * from "./selection_events";

package/dist/types/types/event_stream/selection_events.d.ts

@@ -0,0 +1,11 @@
+import { AnchorZone } from "../misc";
+export type SelectionEventOptions = {
+    scrollIntoView?: boolean;
+    unbounded?: boolean;
+};
+export interface SelectionEvent {
+    anchor: AnchorZone;
+    previousAnchor: AnchorZone;
+    mode: "newAnchor" | "overrideSelection" | "updateAnchor" | "commitSelection";
+    options: SelectionEventOptions;
+}

package/dist/types/types/figure.d.ts

@@ -0,0 +1,39 @@
+import { TitleDesign } from "./chart";
+import { HeaderIndex, Pixel, PixelPosition, UID } from "./misc";
+import { DOMCoordinates } from "./rendering";
+export interface FigureInfo {
+    id: UID;
+    width: Pixel;
+    height: Pixel;
+    tag: string;
+}
+export interface Figure extends FigureInfo, AnchorOffset {
+}
+export interface FigureUI extends DOMCoordinates, Figure {
+}
+export interface AnchorOffset {
+    col: HeaderIndex;
+    row: HeaderIndex;
+    offset: PixelPosition;
+}
+export interface FigureSize {
+    width: Pixel;
+    height: Pixel;
+}
+export interface ExcelFigureSize {
+    cx: number;
+    cy: number;
+}
+export type ResizeDirection = -1 | 0 | 1;
+export interface Carousel {
+    readonly items: CarouselItem[];
+    readonly title?: TitleDesign;
+}
+export type CarouselItem = {
+    type: "chart";
+    chartId: UID;
+    title?: string;
+} | {
+    type: "carouselDataView";
+    title?: string;
+};

package/dist/types/types/files.d.ts

@@ -0,0 +1,28 @@
+import { FigureSize } from "./figure";
+import { Image } from "./image";
+type FilePath = string;
+/**
+ * FileStore manage the transfer of file with the server.
+ */
+export interface FileStore {
+    /**
+     * Upload a file to a server and returns its path.
+     */
+    upload(file: File): Promise<FilePath>;
+    /**
+     * get File from the server
+     */
+    getFile(filePath: FilePath): Promise<File | Blob>;
+}
+/**
+ * ImageProvider can request the user to input an image file before sending it to a server.
+ */
+export interface ImageProviderInterface {
+    /**
+     * RequestImage ask the user to input an image file. Then send it to a server trough an FileStore. Finally it return the path and the size of the image in the server.
+     */
+    requestImage(): Promise<Image>;
+    uploadFile(file: File | Blob): Promise<Image>;
+    getImageOriginalSize(path: string): Promise<FigureSize>;
+}
+export {};

package/dist/types/types/find_and_replace.d.ts

@@ -0,0 +1,8 @@
+import { Range } from "./range";
+export interface SearchOptions {
+    matchCase: boolean;
+    exactMatch: boolean;
+    searchFormulas: boolean;
+    searchScope: "allSheets" | "activeSheet" | "specificRange";
+    specificRange?: Range;
+}

package/dist/types/types/format.d.ts

@@ -0,0 +1,8 @@
+import { Locale } from "./locale";
+import { Alias } from "./misc";
+export type Format = string & Alias;
+export type FormattedValue = string & Alias;
+export interface LocaleFormat {
+    locale: Locale;
+    format?: Format;
+}

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

@@ -0,0 +1,58 @@
+import { CellValue } from "./cells";
+import { Getters } from "./getters";
+import { Locale } from "./locale";
+import { Arg, CellPosition, FunctionResultObject, Matrix, UID } from "./misc";
+import { Range } from "./range";
+export type ArgType = "ANY" | "BOOLEAN" | "NUMBER" | "STRING" | "DATE" | "RANGE" | "RANGE<BOOLEAN>" | "RANGE<NUMBER>" | "RANGE<DATE>" | "RANGE<STRING>" | "RANGE<ANY>";
+export interface ArgDefinition {
+    acceptMatrix?: boolean;
+    acceptMatrixOnly?: boolean;
+    acceptErrors?: boolean;
+    repeating?: boolean;
+    optional?: boolean;
+    description: string;
+    name: string;
+    type: ArgType[];
+    default?: boolean;
+    defaultValue?: any;
+    proposalValues?: ArgProposal[];
+}
+export type ArgProposal = {
+    value: CellValue;
+    label?: string;
+};
+export type ComputeFunction<R> = (this: EvalContext, ...args: Arg[]) => R;
+export interface AddFunctionDescription {
+    compute: ComputeFunction<FunctionResultObject | Matrix<FunctionResultObject> | CellValue | Matrix<CellValue>>;
+    description: string;
+    category?: string;
+    args: ArgDefinition[];
+    isExported?: boolean;
+    hidden?: boolean;
+}
+export type FunctionDescription = AddFunctionDescription & {
+    name: string;
+    minArgRequired: number;
+    maxArgPossible: number;
+    nbrArgRepeating: number;
+    nbrOptionalNonRepeatingArgs: number;
+};
+export type EvalContext = {
+    __originSheetId: UID;
+    __originCellPosition?: CellPosition;
+    locale: Locale;
+    getters: Getters;
+    getFormulaResult: (position: CellPosition) => FunctionResultObject;
+    [key: string]: any;
+    updateDependencies?: (position: CellPosition) => void;
+    addDependencies?: (position: CellPosition, ranges: Range[]) => void;
+    debug?: boolean;
+    lookupCaches?: LookupCaches;
+};
+/**
+ * used to cache lookup values for linear search
+ **/
+export type LookupCaches = {
+    forwardSearch: Map<unknown, Map<CellValue, number>>;
+    reverseSearch: Map<unknown, Map<CellValue, number>>;
+};

package/dist/types/types/generic_criterion.d.ts

@@ -0,0 +1,16 @@
+import { CellValue } from "./cells";
+export interface GenericCriterion {
+    type: GenericCriterionType;
+    values: string[];
+    isPercent?: boolean;
+    isBottom?: boolean;
+}
+export type GenericDateCriterion = GenericCriterion & {
+    dateValue: DateCriterionValue;
+};
+export type GenericCriterionType = "containsText" | "notContainsText" | "isEqualText" | "isEmail" | "isLink" | "dateIs" | "dateIsBefore" | "dateIsOnOrBefore" | "dateIsAfter" | "dateIsOnOrAfter" | "dateIsBetween" | "dateIsNotBetween" | "dateIsValid" | "isEqual" | "isNotEqual" | "isGreaterThan" | "isGreaterOrEqualTo" | "isLessThan" | "isLessOrEqualTo" | "isBetween" | "isNotBetween" | "isBoolean" | "isValueInList" | "isValueInRange" | "customFormula" | "beginsWithText" | "endsWithText" | "isNotEmpty" | "isEmpty" | "top10" | "uniqueValues" | "duplicateValues";
+export type DateCriterionValue = "today" | "tomorrow" | "yesterday" | "lastWeek" | "lastMonth" | "lastYear" | "exactDate";
+export type EvaluatedCriterion<T extends GenericCriterion = GenericCriterion> = Omit<T, "values"> & {
+    values: CellValue[];
+};
+export type EvaluatedDateCriterion = EvaluatedCriterion<GenericDateCriterion>;

package/dist/types/types/getters.d.ts

@@ -0,0 +1,44 @@
+import { TableStylePlugin } from "../plugins/core/table_style";
+import { EvaluationPlugin } from "../plugins/ui_core_views/cell_evaluation";
+import { CellIconPlugin } from "../plugins/ui_core_views/cell_icon_plugin";
+import { CustomColorsPlugin } from "../plugins/ui_core_views/custom_colors";
+import { DynamicTablesPlugin } from "../plugins/ui_core_views/dynamic_tables";
+import { EvaluationChartPlugin } from "../plugins/ui_core_views/evaluation_chart";
+import { EvaluationConditionalFormatPlugin } from "../plugins/ui_core_views/evaluation_conditional_format";
+import { EvaluationDataValidationPlugin } from "../plugins/ui_core_views/evaluation_data_validation";
+import { FormulaTrackerPlugin } from "../plugins/ui_core_views/formula_tracker";
+import { HeaderSizeUIPlugin } from "../plugins/ui_core_views/header_sizes_ui";
+import { PivotUIPlugin } from "../plugins/ui_core_views/pivot_ui";
+import { AutofillPlugin } from "../plugins/ui_feature/autofill";
+import { AutomaticSumPlugin } from "../plugins/ui_feature/automatic_sum";
+import { CellComputedStylePlugin } from "../plugins/ui_feature/cell_computed_style";
+import { CheckboxTogglePlugin } from "../plugins/ui_feature/checkbox_toggle";
+import { CollaborativePlugin } from "../plugins/ui_feature/collaborative";
+import { DynamicTranslate } from "../plugins/ui_feature/dynamic_translate";
+import { GeoFeaturePlugin } from "../plugins/ui_feature/geo_features";
+import { HeaderVisibilityUIPlugin } from "../plugins/ui_feature/header_visibility_ui";
+import { HistoryPlugin } from "../plugins/ui_feature/local_history";
+import { LockSheetPlugin } from "../plugins/ui_feature/lock_sheet";
+import { PivotPresencePlugin } from "../plugins/ui_feature/pivot_presence_plugin";
+import { SortPlugin } from "../plugins/ui_feature/sort";
+import { SplitToColumnsPlugin } from "../plugins/ui_feature/split_to_columns";
+import { SubtotalEvaluationPlugin } from "../plugins/ui_feature/subtotal_evaluation";
+import { TableComputedStylePlugin } from "../plugins/ui_feature/table_computed_style";
+import { UIOptionsPlugin } from "../plugins/ui_feature/ui_options";
+import { SheetUIPlugin } from "../plugins/ui_feature/ui_sheet";
+import { CarouselUIPlugin } from "../plugins/ui_stateful/carousel_ui";
+import { ClipboardPlugin } from "../plugins/ui_stateful/clipboard";
+import { FilterEvaluationPlugin } from "../plugins/ui_stateful/filter_evaluation";
+import { HeaderPositionsUIPlugin } from "../plugins/ui_stateful/header_positions";
+import { GridSelectionPlugin } from "../plugins/ui_stateful/selection";
+import { SheetViewPlugin } from "../plugins/ui_stateful/sheetview";
+import { CoreGetters, PluginGetters } from "./core_getters";
+/**
+ * The getters that can be used in the rendering-related stores and helpers. The SheetView and Selection getters should
+ * not be used in those, they should use the values in the GridRenderingContext instead.
+ */
+export type RenderingGetters = {
+    isReadonly: () => boolean;
+    isDashboard: () => boolean;
+} & CoreGetters & PluginGetters<typeof AutofillPlugin> & PluginGetters<typeof AutomaticSumPlugin> & PluginGetters<typeof HistoryPlugin> & PluginGetters<typeof ClipboardPlugin> & PluginGetters<typeof EvaluationPlugin> & PluginGetters<typeof EvaluationChartPlugin> & PluginGetters<typeof EvaluationConditionalFormatPlugin> & PluginGetters<typeof HeaderVisibilityUIPlugin> & PluginGetters<typeof CustomColorsPlugin> & PluginGetters<typeof AutomaticSumPlugin> & PluginGetters<typeof CollaborativePlugin> & PluginGetters<typeof SortPlugin> & PluginGetters<typeof UIOptionsPlugin> & PluginGetters<typeof SheetUIPlugin> & PluginGetters<typeof FilterEvaluationPlugin> & PluginGetters<typeof SplitToColumnsPlugin> & PluginGetters<typeof SubtotalEvaluationPlugin> & PluginGetters<typeof HeaderSizeUIPlugin> & PluginGetters<typeof EvaluationDataValidationPlugin> & PluginGetters<typeof HeaderPositionsUIPlugin> & PluginGetters<typeof TableStylePlugin> & PluginGetters<typeof CellComputedStylePlugin> & PluginGetters<typeof DynamicTablesPlugin> & PluginGetters<typeof PivotUIPlugin> & PluginGetters<typeof TableComputedStylePlugin> & PluginGetters<typeof GeoFeaturePlugin> & PluginGetters<typeof PivotPresencePlugin> & PluginGetters<typeof TableComputedStylePlugin> & PluginGetters<typeof CheckboxTogglePlugin> & PluginGetters<typeof CellIconPlugin> & PluginGetters<typeof DynamicTranslate> & PluginGetters<typeof FormulaTrackerPlugin> & PluginGetters<typeof LockSheetPlugin> & PluginGetters<typeof CarouselUIPlugin>;
+export type Getters = RenderingGetters & PluginGetters<typeof SheetViewPlugin> & PluginGetters<typeof GridSelectionPlugin>;

package/dist/types/types/history.d.ts

@@ -0,0 +1,43 @@
+import { Branch } from "../history/branch";
+import { Operation } from "../history/operation";
+import { UID } from "./misc";
+export interface CreateRevisionOptions {
+    revisionId?: UID;
+    clientId?: UID;
+    pending?: boolean;
+}
+export interface HistoryChange {
+    key: string;
+    target: any;
+    before: any;
+}
+export interface WorkbookHistory<Plugin> {
+    update<T extends keyof Plugin>(key: T, val: Plugin[T]): void;
+    update<T extends keyof Plugin, U extends keyof NonNullable<Plugin[T]>>(key1: T, key2: U, val: NonNullable<Plugin[T]>[U]): void;
+    update<T extends keyof Plugin, U extends keyof NonNullable<Plugin[T]>, K extends keyof NonNullable<NonNullable<Plugin[T]>[U]>>(key1: T, key2: U, key3: K, val: NonNullable<NonNullable<Plugin[T]>[U]>[K]): void;
+    update<T extends keyof Plugin, U extends keyof NonNullable<Plugin[T]>, K extends keyof NonNullable<NonNullable<Plugin[T]>[U]>, V extends keyof NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>>(key1: T, key2: U, key3: K, key4: V, val: NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]): void;
+    update<T extends keyof Plugin, U extends keyof NonNullable<Plugin[T]>, K extends keyof NonNullable<NonNullable<Plugin[T]>[U]>, V extends keyof NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>, W extends keyof NonNullable<NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]>>(key1: T, key2: U, key3: K, key4: V, key5: W, val: NonNullable<NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]>[W]): void;
+    update<T extends keyof Plugin, U extends keyof NonNullable<Plugin[T]>, K extends keyof NonNullable<NonNullable<Plugin[T]>[U]>, V extends keyof NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>, W extends keyof NonNullable<NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]>, Y extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]>[W]>>(key1: T, key2: U, key3: K, key4: V, key5: W, key6: Y, val: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]>[W]>[Y]): void;
+}
+export type Transformation<T = unknown> = (dataToTransform: T) => T;
+export interface TransformationFactory<T = unknown> {
+    /**
+     * Build a transformation function to transform any operation as if the execution of
+     * a previous `operation` was omitted.
+     */
+    without: (operation: T) => Transformation<T>;
+    /**
+     * Build a transformation function to transform any operation as if a new `operation` was
+     * executed before.
+     */
+    with: (operation: T) => Transformation<T>;
+}
+export interface OperationSequenceNode<T> {
+    operation: Operation<T>;
+    branch: Branch<T>;
+    isCancelled: boolean;
+    next?: {
+        operation: Operation<T>;
+        branch: Branch<T>;
+    };
+}