@odoo/o-spreadsheet 19.2.11 → 19.4.0-alpha.4

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>;
+    };
+}

package/dist/types/types/image.d.ts

@@ -0,0 +1,23 @@
+import { FigureSize } from "./figure";
+import { Color } from "./misc";
+import { XLSXFigureSize } from "./xlsx";
+export type ImageSVG = {
+    name: string;
+    width: number;
+    height: number;
+    paths: {
+        path: string;
+        fillColor: Color;
+    }[];
+};
+export interface Image {
+    path: string;
+    size: FigureSize;
+    mimetype?: string;
+}
+export interface ExcelImage {
+    imageSrc: string;
+    size: XLSXFigureSize;
+    mimetype?: string;
+}
+export declare const AllowedImageMimeTypes: readonly ["image/avif", "image/bmp", "image/gif", "image/vnd.microsoft.icon", "image/jpeg", "image/png", "image/tiff", "image/webp"];

package/dist/types/types/locale.d.ts

@@ -0,0 +1,17 @@
+import { Alias } from "./misc";
+export type LocaleCode = string & Alias;
+export interface Locale {
+    name: string;
+    code: LocaleCode;
+    thousandsSeparator?: string;
+    decimalSeparator: string;
+    weekStart: number;
+    dateFormat: string;
+    timeFormat: string;
+    formulaArgSeparator: string;
+    /** Describes how to split the digits with the thousand separator. See `getIndexesOfDigitsWithThousandSeparator` for details. */
+    digitGrouping?: string;
+}
+export declare const DEFAULT_LOCALES: Locale[];
+export declare const DEFAULT_LOCALE: Locale;
+export declare const DEFAULT_LOCALE_DIGIT_GROUPING = "[3,0]";

package/dist/types/types/misc.d.ts

@@ -0,0 +1,344 @@
+import { CellValue, EvaluatedCell } from "./cells";
+import { CompiledFormula } from "../formulas/compiler";
+import { CommandResult } from "./commands";
+import { Format } from "./format";
+import { Range } from "./range";
+/**
+ * The following type is meant to be used in union with other aliases to prevent
+ * Intellisense from resolving it.
+ * See https://github.com/microsoft/TypeScript/issues/31940#issuecomment-841712377
+ */
+export type Alias = {} & {};
+export type HeaderIndex = number & Alias;
+export type Pixel = number & Alias;
+export type UID = string & Alias;
+export type SetDecimalStep = 1 | -1;
+export type FilterId = UID & Alias;
+export type TableId = UID & Alias;
+/**
+ * CSS style color string
+ * e.g. "#ABC", "#AAAFFF", "rgb(30, 80, 16)"
+ */
+export type Color = string & Alias;
+export interface RGBA {
+    a: number;
+    r: number;
+    g: number;
+    b: number;
+}
+export interface HSLA {
+    a: number;
+    h: number;
+    s: number;
+    l: number;
+}
+export interface Link {
+    readonly label: string;
+    readonly url: string;
+    readonly isExternal: boolean;
+    /**
+     * Specifies if the URL is editable by the end user.
+     * Special links might not allow it.
+     */
+    readonly isUrlEditable: boolean;
+}
+export interface Zone {
+    left: HeaderIndex;
+    right: HeaderIndex;
+    top: HeaderIndex;
+    bottom: HeaderIndex;
+}
+export interface AnchorZone {
+    zone: Zone;
+    cell: Position;
+}
+export interface Selection {
+    anchor: AnchorZone;
+    zones: Zone[];
+}
+export interface UnboundedZone {
+    top: HeaderIndex;
+    bottom: HeaderIndex | undefined;
+    left: HeaderIndex;
+    right: HeaderIndex | undefined;
+    /**
+     * The hasHeader flag is used to determine if the zone has a header (eg. A2:A or C3:3).
+     *
+     * The main issue is that the zone A1:A and A:A have different behavior. The "correct" way to handle this would be to
+     * allow the top/left to be undefined, but this make typing and using unbounded zones VERY annoying. So we use this
+     * boolean instead.
+     */
+    hasHeader?: boolean;
+}
+export interface ZoneDimension {
+    numberOfRows: HeaderIndex;
+    numberOfCols: HeaderIndex;
+}
+export type Align = "left" | "right" | "center" | undefined;
+export type VerticalAlign = "top" | "middle" | "bottom" | undefined;
+export type Wrapping = "overflow" | "wrap" | "clip" | undefined;
+export interface Style {
+    bold?: boolean;
+    italic?: boolean;
+    strikethrough?: boolean;
+    underline?: boolean;
+    align?: Align;
+    wrapping?: Wrapping;
+    verticalAlign?: VerticalAlign;
+    fillColor?: Color;
+    textColor?: Color;
+    fontSize?: number;
+    rotation?: number;
+    hideGridLines?: boolean;
+}
+export interface DataBarFill {
+    color: Color;
+    percentage: number;
+}
+export interface UpdateCellData {
+    content?: string;
+    formula?: string;
+    style?: Style | null;
+    format?: Format;
+}
+export interface Sheet {
+    id: UID;
+    name: string;
+    numberOfCols: number;
+    rows: Row[];
+    areGridLinesVisible: boolean;
+    isVisible: boolean;
+    panes: PaneDivision;
+    color?: Color;
+    isLocked?: boolean;
+}
+export interface CellPosition {
+    col: HeaderIndex;
+    row: HeaderIndex;
+    sheetId: UID;
+}
+export declare const borderStyles: readonly ["thin", "medium", "thick", "dashed", "dotted"];
+export type BorderStyle = (typeof borderStyles)[number];
+export type BorderDescr = {
+    style: BorderStyle;
+    color: Color;
+};
+/**
+ * A complete border(s) data is a set of position-color-style information
+ */
+export type BorderData = {
+    position: BorderPosition;
+    color?: Color;
+    style?: BorderStyle;
+};
+export interface Border {
+    top?: BorderDescr;
+    left?: BorderDescr;
+    bottom?: BorderDescr;
+    right?: BorderDescr;
+}
+export type ReferenceDenormalizer = (range: Range) => FunctionResultObject;
+export type EnsureRange = (range: Range) => Matrix<FunctionResultObject>;
+export type GetSymbolValue = (symbolName: string, isRange: boolean) => Arg;
+export type FormulaToExecute = (deps: Range[], refFn: ReferenceDenormalizer, range: EnsureRange, getSymbolValue: GetSymbolValue, ctx: object) => Matrix<FunctionResultObject> | FunctionResultObject;
+export interface LiteralValues {
+    numbers: {
+        value: number;
+    }[];
+    strings: {
+        value: string;
+    }[];
+}
+export type Matrix<T = unknown> = T[][];
+export type FunctionResultObject = {
+    value: CellValue;
+    format?: Format;
+    errorOriginPosition?: CellPosition;
+    message?: string;
+    origin?: CellPosition;
+    /**
+     * When a formula returns a reference to another cell (rather than just a value),
+     * this stores the referenced cell's position.
+     *
+     * Example: `LOOKUP(42, B1:B9, C1:C9)` might resolve to cell C5, setting
+     * `position` to C5. Formulas that specifically expect a cell reference as input
+     * can then receive C5 as a reference rather than just its value
+     * (e.g. `=CELL("format", LOOKUP(42, B1:B9, C1:C9))`).
+     */
+    position?: CellPosition;
+};
+export type FunctionResultNumber = {
+    value: number;
+    format?: string;
+};
+export type Arg = Maybe<FunctionResultObject> | Matrix<FunctionResultObject>;
+export declare function isMatrix(x: any): x is Matrix<any>;
+export interface ClipboardCell {
+    evaluatedCell: EvaluatedCell;
+    position: CellPosition;
+    content: string;
+    style?: Style | undefined;
+    format?: Format | undefined;
+    compiledFormula?: CompiledFormula;
+    border?: Border;
+}
+export interface HeaderDimensions {
+    start: Pixel;
+    size: Pixel;
+    end: Pixel;
+}
+export interface Row {
+    cells: Record<number, number | undefined>;
+}
+export interface Position {
+    col: HeaderIndex;
+    row: HeaderIndex;
+}
+export interface PixelPosition {
+    x: Pixel;
+    y: Pixel;
+}
+export interface Merge extends Zone {
+    id: number;
+}
+export interface Highlight {
+    range: Range;
+    color: Color;
+    interactive?: boolean;
+    thinLine?: boolean;
+    noFill?: boolean;
+    /** transparency of the fill color (0-1) */
+    fillAlpha?: number;
+    noBorder?: boolean;
+    dashed?: boolean;
+}
+export interface PaneDivision {
+    /** Represents the number of frozen columns */
+    xSplit: number;
+    /** Represents the number of frozen rows */
+    ySplit: number;
+}
+export type BorderPosition = "all" | "hv" | "h" | "v" | "external" | "left" | "top" | "right" | "bottom" | "clear";
+export declare const enum DIRECTION {
+    UP = "up",
+    DOWN = "down",
+    LEFT = "left",
+    RIGHT = "right"
+}
+export type ChangeType = "REMOVE" | "RESIZE" | "MOVE" | "CHANGE" | "NONE";
+export type ApplyRangeChangeResult<T> = {
+    changeType: ChangeType;
+    range: T;
+};
+export type ApplyFormulaRangeChangeResult = {
+    changeType: ChangeType;
+    formula: string;
+};
+export type ApplyRangeChange = (range: Range) => ApplyRangeChangeResult<Range>;
+export type ApplyRenameNamedRange = (currentRangeName: string) => string;
+export type AdaptSheetName = {
+    old: string;
+    current: string;
+};
+export type RangeAdapter = {
+    sheetId: UID;
+    sheetName: AdaptSheetName;
+    applyChange: ApplyRangeChange;
+};
+export type RangeAdapterFunctions = {
+    applyChange: ApplyRangeChange;
+    adaptRangeString: (defaultSheetId: UID, sheetXC: string) => ApplyRangeChangeResult<string>;
+    adaptFormulaString: (defaultSheetId: UID, formula: string) => string;
+    adaptCompiledFormula: (compiledFormula: CompiledFormula) => CompiledFormula;
+};
+export type Dimension = "COL" | "ROW";
+export type ConsecutiveIndexes = HeaderIndex[];
+export interface RangeProvider {
+    adaptRanges: (adapterFunctions: RangeAdapterFunctions) => void;
+}
+export type Validation<T> = (toValidate: T) => CommandResult | CommandResult[];
+export type Increment = 1 | -1 | 0;
+export interface Ref<T> {
+    el: T | null;
+}
+/**
+ * Container for a lazy computed value
+ */
+export interface Lazy<T> {
+    /**
+     * Return the computed value.
+     * The value is computed only once and memoized.
+     */
+    (): T;
+    /**
+     * Map a lazy value to another lazy value.
+     *
+     * ```ts
+     * // neither function is called here
+     * const lazyValue = lazy(() => veryExpensive(...)).map((result) => alsoVeryExpensive(result));
+     *
+     * // both values are computed now
+     * const value = lazyValue()
+     * ```
+     */
+    map: <U>(callback: (value: T) => U) => Lazy<U>;
+}
+export type Maybe<T> = T | undefined;
+export interface Cloneable<T> {
+    clone: (args?: Partial<T>) => T;
+}
+export type CSSProperties<P extends string = string> = Record<P, string | undefined>;
+export interface SortOptions {
+    /** If true sort the headers of the range along with the rest */
+    sortHeaders?: boolean;
+    /** If true treat empty cells as "0" instead of undefined */
+    emptyCellAsZero?: boolean;
+}
+export interface MenuMouseEvent extends MouseEvent {
+    closedMenuId?: UID;
+}
+export type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
+type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
+type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+type ImmutableObject<T> = {
+    readonly [K in keyof T]: Immutable<T[K]>;
+};
+export type DeepPartial<T> = T extends Function ? T : T extends Array<infer U> ? _DeepPartialArray<U> : T extends object ? _DeepPartialObject<T> : T | undefined;
+type _DeepPartialArray<T> = Array<DeepPartial<T>>;
+type _DeepPartialObject<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+export interface HeaderGroup {
+    start: HeaderIndex;
+    end: HeaderIndex;
+    isFolded?: boolean;
+}
+export type Direction = "up" | "down" | "left" | "right";
+export type SelectionStep = number | "end";
+export interface Offset {
+    col: number;
+    row: number;
+}
+export type DebouncedFunction<T> = T & {
+    stopDebounce: () => void;
+    isDebouncePending: () => boolean;
+};
+export interface GridClickModifiers {
+    addZone: boolean;
+    expandZone: boolean;
+}
+export type ComposerFocusType = "inactive" | "cellFocus" | "contentFocus";
+export type EditionMode = "editing" | "selecting" | "inactive";
+export type SortDirection = "asc" | "desc";
+export interface ValueAndLabel<T = string> {
+    value: T;
+    label: string;
+    separator?: boolean;
+}
+export interface NamedRange {
+    name: string;
+    range: Range;
+}
+export {};

package/dist/types/types/model.d.ts

@@ -0,0 +1,47 @@
+import { GeoChartRegion } from "./chart/geo_chart";
+import { Client, ClientPosition } from "./collaborative/session";
+import { TransportService } from "./collaborative/transport_service";
+import { Currency } from "./currency";
+import { InformationNotification } from "./env";
+import { FileStore } from "./files";
+import { Locale } from "./locale";
+import { Color } from "./misc";
+export type Mode = "normal" | "readonly" | "dashboard" | "export_verification";
+export interface ModelConfig {
+    readonly mode: Mode;
+    /**
+     * Any external custom dependencies your custom plugins or functions might need.
+     * They are available in plugins config and functions
+     * evaluation context.
+     */
+    readonly custom: Readonly<{
+        [key: string]: any;
+    }>;
+    readonly defaultCurrency?: Partial<Currency>;
+    /**
+     * External dependencies required to enable some features
+     * such as uploading images.
+     */
+    readonly external: Readonly<ModelExternalConfig>;
+    readonly moveClient: (position: ClientPosition) => void;
+    readonly transportService: TransportService;
+    readonly client: Client;
+    readonly snapshotRequested: boolean;
+    readonly notifyUI: (payload: InformationNotification) => void;
+    readonly raiseBlockingErrorUI: (text: string) => void;
+    readonly customColors: Color[];
+    readonly colorScheme?: "light" | "dark";
+}
+export interface ModelExternalConfig {
+    readonly fileStore?: FileStore;
+    readonly loadCurrencies?: () => Promise<Currency[]>;
+    readonly loadLocales?: () => Promise<Locale[]>;
+    readonly geoJsonService?: {
+        getAvailableRegions: () => GeoChartRegion[];
+        getTopoJson: (region: string) => Promise<any>;
+        /**  Convert the name of a geographical feature (eg. France) to the id of the corresponding feature in the TopoJSON */
+        geoFeatureNameToId: (region: string, territory: string) => string | undefined;
+        /** Returns the regions that can be selected as an alternative when the chart was initially configured with the given region */
+        getAlternativeRegions?: (region: string) => GeoChartRegion[];
+    };
+}

package/dist/types/types/pivot.d.ts

@@ -0,0 +1,187 @@
+import { CellValue } from "./cells";
+import { Format } from "./format";
+import { Locale } from "./locale";
+import { Dimension, FunctionResultObject, SortDirection, UID, Zone } from "./misc";
+export type Aggregator = "array_agg" | "count" | "count_distinct" | "bool_and" | "bool_or" | "max" | "min" | "avg" | "sum";
+export type Granularity = "day" | "month" | "year" | "second_number" | "minute_number" | "hour_number" | "day_of_week" | "day_of_month" | "iso_week_number" | "month_number" | "quarter_number";
+export interface PivotCoreDimension {
+    fieldName: string;
+    order?: SortDirection;
+    granularity?: Granularity | string;
+    isCustomField?: boolean;
+    parentField?: string;
+    customGroups?: PivotCustomGroup[];
+}
+export interface PivotCoreMeasure {
+    /**
+     * Identifier of the measure, `technicalName:aggregator{:autoIncrementedNumber}`.
+     * It's used to identify the measure in the pivot formula.
+     */
+    id: string;
+    userDefinedName?: string;
+    fieldName: string;
+    aggregator: Aggregator | string;
+    isHidden?: boolean;
+    format?: Format;
+    computedBy?: {
+        sheetId: UID;
+        formula: string;
+    };
+    display?: PivotMeasureDisplay;
+}
+export interface CommonPivotCoreDefinition {
+    columns: PivotCoreDimension[];
+    rows: PivotCoreDimension[];
+    measures: PivotCoreMeasure[];
+    name: string;
+    deferUpdates?: boolean;
+    sortedColumn?: PivotSortedColumn;
+    collapsedDomains?: PivotCollapsedDomains;
+    customFields?: Record<string, PivotCustomGroupedField>;
+    style?: PivotStyle;
+}
+export interface PivotSortedColumn {
+    order: SortDirection;
+    domain: PivotDomain;
+    measure: string;
+}
+export interface PivotCollapsedDomains {
+    COL: PivotDomain[];
+    ROW: PivotDomain[];
+}
+export interface PivotCustomGroupedField {
+    parentField: string;
+    name: string;
+    groups: PivotCustomGroup[];
+}
+export interface PivotCustomGroup {
+    name: string;
+    values: CellValue[];
+    isOtherGroup?: boolean;
+}
+export interface SpreadsheetPivotCoreDefinition extends CommonPivotCoreDefinition {
+    type: "SPREADSHEET";
+    dataSet?: {
+        sheetId: UID;
+        zone: Zone;
+    };
+}
+interface FakePivotDefinition extends CommonPivotCoreDefinition {
+    type: "FAKE";
+}
+export type PivotCoreDefinition = SpreadsheetPivotCoreDefinition | FakePivotDefinition;
+export type TechnicalName = string;
+export interface PivotField {
+    name: TechnicalName;
+    type: string;
+    string: string;
+    aggregator?: string;
+    help?: string;
+    isCustomField?: boolean;
+    parentField?: string;
+    customGroups?: PivotCustomGroup[];
+}
+export type PivotFields = Record<TechnicalName, PivotField | undefined>;
+export interface PivotMeasure extends PivotCoreMeasure {
+    displayName: string;
+    type: string;
+    isValid: boolean;
+}
+export interface PivotDimension extends PivotCoreDimension {
+    nameWithGranularity: string;
+    displayName: string;
+    type: string;
+    isValid: boolean;
+}
+export interface PivotTableColumn {
+    fields: string[];
+    values: CellValue[];
+    width: number;
+    offset: number;
+}
+export interface PivotTableRow {
+    fields: string[];
+    values: CellValue[];
+    indent: number;
+}
+export interface PivotTableData {
+    cols: PivotTableColumn[][];
+    rows: PivotTableRow[];
+    measures: string[];
+    fieldsType?: Record<string, string | undefined>;
+}
+export interface PivotHeaderCell {
+    type: "HEADER";
+    domain: PivotDomain;
+    dimension: Dimension;
+}
+export interface PivotGroupNameCell {
+    type: "ROW_GROUP_NAME";
+    rowField: string;
+}
+export interface PivotMeasureHeaderCell {
+    type: "MEASURE_HEADER";
+    domain: PivotDomain;
+    measure: string;
+}
+export interface PivotValueCell {
+    type: "VALUE";
+    domain: PivotDomain;
+    measure: string;
+}
+export interface PivotEmptyCell {
+    type: "EMPTY";
+}
+export type PivotTableCell = PivotHeaderCell | PivotGroupNameCell | PivotMeasureHeaderCell | PivotValueCell | PivotEmptyCell;
+export interface PivotTimeAdapterNotNull<T> {
+    normalizeFunctionValue: (value: Exclude<CellValue, null>) => T;
+    toValueAndFormat: (normalizedValue: T, locale?: Locale) => FunctionResultObject;
+    toFunctionValue: (normalizedValue: T) => string;
+    toComparableValue?: (normalizedValue: T) => number;
+}
+export interface PivotTimeAdapter<T> {
+    normalizeFunctionValue: (value: CellValue) => T | null;
+    toValueAndFormat: (normalizedValue: T, locale?: Locale) => FunctionResultObject;
+    toFunctionValue: (normalizedValue: T) => string;
+    toComparableValue?: (normalizedValue: T | null) => number | undefined;
+}
+export interface PivotNode {
+    field: string;
+    type: string;
+    value: CellValue;
+}
+export type PivotDomain = PivotNode[];
+/** Pivot domain splitted for the domain related to the pivot's rows and columns  */
+export interface PivotColRowDomain {
+    colDomain: PivotDomain;
+    rowDomain: PivotDomain;
+}
+export declare const PREVIOUS_VALUE = "(previous)";
+export declare const NEXT_VALUE = "(next)";
+export interface PivotMeasureDisplay {
+    type: PivotMeasureDisplayType;
+    fieldNameWithGranularity?: string;
+    value?: string | boolean | number | typeof PREVIOUS_VALUE | typeof NEXT_VALUE;
+}
+export type PivotMeasureDisplayType = "no_calculations" | "%_of_grand_total" | "%_of_col_total" | "%_of_row_total" | "%_of_parent_row_total" | "%_of_parent_col_total" | "index" | "%_of_parent_total" | "running_total" | "%_running_total" | "rank_asc" | "rank_desc" | "%_of" | "difference_from" | "%_difference_from";
+export interface DimensionTreeNode {
+    value: CellValue;
+    field: string;
+    type: string;
+    children: DimensionTree;
+    width: number;
+}
+export type DimensionTree = DimensionTreeNode[];
+export interface PivotStyle {
+    numberOfRows?: number;
+    numberOfColumns?: number;
+    displayTotals?: boolean;
+    displayColumnHeaders?: boolean;
+    displayMeasuresRow?: boolean;
+    tableStyleId?: string;
+    bandedRows?: boolean;
+    bandedColumns?: boolean;
+    hasFilters?: boolean;
+    tabularForm?: boolean;
+}
+export {};

package/dist/types/types/pivot_runtime.d.ts

@@ -0,0 +1,32 @@
+import { PivotRuntimeDefinition } from "../helpers/pivot/pivot_runtime_definition";
+import { SpreadsheetPivotTable } from "../helpers/pivot/table_spreadsheet_pivot";
+import { FunctionResultObject, Maybe } from "./misc";
+import { PivotCoreDefinition, PivotDimension, PivotDomain, PivotFields, PivotMeasure } from "./pivot";
+export interface InitPivotParams {
+    reload?: boolean;
+}
+export interface Pivot<T = PivotRuntimeDefinition> {
+    type: PivotCoreDefinition["type"];
+    definition: T;
+    init(params?: InitPivotParams): void;
+    isValid(): boolean;
+    onDefinitionChange(nextDefinition: PivotCoreDefinition): void;
+    getCollapsedTableStructure(): SpreadsheetPivotTable;
+    getExpandedTableStructure(): SpreadsheetPivotTable;
+    getFields(): PivotFields;
+    getPivotHeaderValueAndFormat(domain: PivotDomain): FunctionResultObject;
+    getPivotCellValueAndFormat(measure: string, domain: PivotDomain): FunctionResultObject;
+    getPivotMeasureValue(measure: string, domain: PivotDomain): FunctionResultObject;
+    getMeasure: (id: string) => PivotMeasure;
+    parseArgsToPivotDomain(args: Maybe<FunctionResultObject>[]): PivotDomain;
+    areDomainArgsFieldsValid(args: Maybe<FunctionResultObject>[]): boolean;
+    assertIsValid({ throwOnError }: {
+        throwOnError: boolean;
+    }): FunctionResultObject | undefined;
+    getPossibleFieldValues(dimension: PivotDimension): {
+        value: string | boolean | number;
+        label: string;
+    }[];
+    needsReevaluation: boolean;
+    markAsDirtyForEvaluation?(): void;
+}