@odoo/o-spreadsheet 17.0.84 → 17.0.96

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

@@ -0,0 +1,64 @@
+export interface StreamCallbacks<Event> {
+    handleEvent: (event: Event) => void;
+    /** this callback will only be called when another consumer captures the stream,
+     * not when the current consumer decides to release itself */
+    release?: () => void;
+}
+type Owner = unknown;
+/**
+ * Stateless sequence of events that can be processed by consumers.
+ *
+ * There are three kind of consumers:
+ * - the main consumer
+ * - the default consumer
+ * - observer consumers
+ *
+ * Main consumer
+ * -------------
+ * Anyone can capture the event stream and become the main consumer.
+ * If there is already a main consumer, it is kicked off and it will no longer
+ * receive events.
+ * The main consumer can release the stream at any moment to stop listening
+ * events.
+ *
+ * Default consumer
+ * ----------------
+ * When the main consumer releases the stream and until the stream is captured
+ * again, all events are transmitted to the default consumer.
+ *
+ * Observer consumers
+ * ------------------
+ * Observers permanently receive events.
+ *
+ */
+export declare class EventStream<Event> {
+    private observers;
+    /**
+     * the one we default to when someone releases the stream by themeselves
+     */
+    private defaultSubscription?;
+    private mainSubscription?;
+    registerAsDefault(owner: Owner, callbacks: StreamCallbacks<Event>): void;
+    /**
+     * Register callbacks to observe the stream
+     */
+    observe(owner: Owner, callbacks: StreamCallbacks<Event>): void;
+    /**
+     * Capture the stream for yourself
+     */
+    capture(owner: Owner, callbacks: StreamCallbacks<Event>): void;
+    release(owner: Owner): void;
+    /**
+     * Release whichever subscription in charge and get back to the default subscription
+     */
+    getBackToDefault(): void;
+    /**
+     * Check if you are currently the main stream consumer
+     */
+    isListening(owner: Owner): boolean;
+    /**
+     * Push an event to the stream and broadcast it to consumers
+     */
+    send(event: Event): void;
+}
+export {};

package/dist/types/selection_stream/selection_stream_processor.d.ts

@@ -0,0 +1,167 @@
+import { AnchorZone, Direction, DispatchResult, Getters, SelectionStep } from "../types";
+import { SelectionEvent, SelectionEventOptions } from "../types/event_stream";
+import { HeaderIndex } from "./../types/misc";
+import { StreamCallbacks } from "./event_stream";
+type StatefulStream<Event, State> = {
+    capture(owner: unknown, state: State, callbacks: StreamCallbacks<Event>): void;
+    registerAsDefault: (owner: unknown, state: State, callbacks: StreamCallbacks<Event>) => void;
+    resetDefaultAnchor: (owner: unknown, state: State) => void;
+    resetAnchor: (owner: unknown, state: State) => void;
+    observe: (owner: unknown, callbacks: StreamCallbacks<Event>) => void;
+    release: (owner: unknown) => void;
+    getBackToDefault(): void;
+};
+/**
+ * Allows to select cells in the grid and update the selection
+ */
+interface SelectionProcessor {
+    selectZone(anchor: AnchorZone, options?: SelectionEventOptions): DispatchResult;
+    selectCell(col: number, row: number): DispatchResult;
+    moveAnchorCell(direction: Direction, step: SelectionStep): DispatchResult;
+    setAnchorCorner(col: number, row: number): DispatchResult;
+    addCellToSelection(col: number, row: number): DispatchResult;
+    resizeAnchorZone(direction: Direction, step: SelectionStep): DispatchResult;
+    selectColumn(index: number, mode: SelectionEvent["mode"]): DispatchResult;
+    selectRow(index: number, mode: SelectionEvent["mode"]): DispatchResult;
+    selectAll(): DispatchResult;
+    loopSelection(): DispatchResult;
+    selectTableAroundSelection(): DispatchResult;
+    isListening(owner: unknown): boolean;
+}
+export type SelectionStreamProcessor = SelectionProcessor & StatefulStream<SelectionEvent, AnchorZone>;
+/**
+ * Processes all selection updates (usually from user inputs) and emits an event
+ * with the new selected anchor
+ */
+export declare class SelectionStreamProcessorImpl implements SelectionStreamProcessor {
+    private getters;
+    private stream;
+    /**
+     * "Active" anchor used as a reference to compute new anchors
+     * An new initial value is given each time the stream is
+     * captured. The value is updated with each new anchor.
+     */
+    private anchor;
+    private defaultAnchor;
+    constructor(getters: Getters);
+    capture(owner: unknown, anchor: AnchorZone, callbacks: StreamCallbacks<SelectionEvent>): void;
+    /**
+     * Register as default subscriber and capture the event stream.
+     */
+    registerAsDefault(owner: unknown, anchor: AnchorZone, callbacks: StreamCallbacks<SelectionEvent>): void;
+    resetDefaultAnchor(owner: unknown, anchor: AnchorZone): void;
+    resetAnchor(owner: unknown, anchor: AnchorZone): void;
+    observe(owner: unknown, callbacks: StreamCallbacks<SelectionEvent>): void;
+    release(owner: unknown): void;
+    getBackToDefault(): void;
+    private modifyAnchor;
+    /**
+     * Select a new anchor
+     */
+    selectZone(anchor: AnchorZone, options?: SelectionEventOptions): DispatchResult;
+    /**
+     * Select a single cell as the new anchor.
+     */
+    selectCell(col: HeaderIndex, row: HeaderIndex): DispatchResult;
+    /**
+     * Set the selection to one of the cells adjacent to the current anchor cell.
+     */
+    moveAnchorCell(direction: Direction, step?: SelectionStep): DispatchResult;
+    /**
+     * Update the current anchor such that it includes the given
+     * cell position.
+     */
+    setAnchorCorner(col: HeaderIndex, row: HeaderIndex): DispatchResult;
+    /**
+     * Add a new cell to the current selection
+     */
+    addCellToSelection(col: HeaderIndex, row: HeaderIndex): DispatchResult;
+    /**
+     * Increase or decrease the size of the current anchor zone.
+     * The anchor cell remains where it is. It's the opposite side
+     * of the anchor zone which moves.
+     */
+    resizeAnchorZone(direction: Direction, step?: SelectionStep): DispatchResult;
+    selectColumn(index: HeaderIndex, mode: SelectionEvent["mode"]): DispatchResult;
+    selectRow(index: HeaderIndex, mode: SelectionEvent["mode"]): DispatchResult;
+    /**
+     * Loop the current selection while keeping the same anchor. The selection will loop through:
+     *  1) the smallest zone that contain the anchor and that have only empty cells bordering it
+     *  2) the whole sheet
+     *  3) the anchor cell
+     */
+    loopSelection(): DispatchResult;
+    /**
+     * Select a "table" around the current selection.
+     * We define a table by the smallest zone that contain the anchor and that have only empty
+     * cells bordering it
+     */
+    selectTableAroundSelection(): DispatchResult;
+    /**
+     * Select the entire sheet
+     */
+    selectAll(): DispatchResult;
+    isListening(owner: unknown): boolean;
+    /**
+     * Process a new anchor selection event. If the new anchor is inside
+     * the sheet boundaries, the event is pushed to the event stream to
+     * be processed.
+     */
+    private processEvent;
+    private checkEventAnchorZone;
+    private checkAnchorZone;
+    private checkAnchorZoneOrThrow;
+    /**
+     *  ---- PRIVATE ----
+     */
+    /** Computes the next cell position in the direction of deltaX and deltaY
+     * by crossing through merges and skipping hidden cells.
+     * Note that the resulting position might be out of the sheet, it needs to be validated.
+     */
+    private getNextAvailablePosition;
+    private getNextAvailableCol;
+    private getNextAvailableRow;
+    private getNextAvailableHeader;
+    /**
+     * Finds a visible cell in the currently selected zone starting with the anchor.
+     * If the anchor is hidden, browses from left to right and top to bottom to
+     * find a visible cell.
+     */
+    private getReferenceAnchor;
+    private deltaToTarget;
+    private getStartingPosition;
+    /**
+     * Given a starting position, compute the end of the cluster containing the position in the given
+     * direction or the start of the next cluster. We define cluster here as side-by-side cells that
+     * all have a content.
+     *
+     * We will return the end of the cluster if the given cell is inside a cluster, and the start of the
+     * next cluster if the given cell is outside a cluster or at the border of a cluster in the given direction.
+     */
+    private getEndOfCluster;
+    /**
+     * Checks if a cell is empty (i.e. does not have a content). If the cell is part of a merge,
+     * the check applies to the main cell of the merge.
+     */
+    private isCellEmpty;
+    /**
+     * Checks if a cell evaluated value is empty. If the cell is part of a merge,
+     * the check applies to the main cell of the merge.
+     */
+    private isEvaluatedCellEmpty;
+    /** Computes the next cell position in the given direction by crossing through merges and skipping hidden cells.
+     *
+     * This has the same behaviour as getNextAvailablePosition() for certain arguments, but use this method instead
+     * inside directionToDelta(), which is called in getNextAvailablePosition(), to avoid possible infinite
+     * recursion.
+     */
+    private getNextCellPosition;
+    private getPosition;
+    /**
+     * Expand the given zone to a table.
+     * We define a table by the smallest zone that contain the anchor and that have only empty
+     * cells bordering it
+     */
+    private expandZoneToTable;
+}
+export {};

package/dist/types/state_observer.d.ts

@@ -0,0 +1,15 @@
+import { CoreCommand, HistoryChange } from "./types";
+export declare class StateObserver {
+    private changes;
+    private commands;
+    /**
+     * Record the changes which could happen in the given callback, save them in a
+     * new revision with the given id and userId.
+     */
+    recordChanges(callback: () => void): {
+        changes: HistoryChange[];
+        commands: CoreCommand[];
+    };
+    addCommand(command: CoreCommand): void;
+    addChange(...args: [...HistoryChange["path"], any]): void;
+}

package/dist/types/translation.d.ts

@@ -0,0 +1,21 @@
+type SprintfValues = (string | String | number)[] | [{
+    [key: string]: string | number;
+}];
+export type TranslationFunction = (string: string, ...values: SprintfValues) => string;
+/***
+ * Allow to inject a translation function from outside o-spreadsheet. This should be called before instantiating
+ * a model.
+ * @param tfn the function that will do the translation
+ * @param loaded a function that returns true when the translation is loaded
+ */
+export declare function setTranslationMethod(tfn: TranslationFunction, loaded?: () => boolean): void;
+/**
+ * If no translation function has been set, this will mark the translation are loaded.
+ *
+ * By default, the translations should not be set as loaded, otherwise top-level translated constants will never be
+ * translated. But if by the time the model is instantiated no custom translation function has been set, we can set
+ * the default translation function as loaded so o-spreadsheet can be run in standalone with no translations.
+ */
+export declare function setDefaultTranslationMethod(): void;
+export declare const _t: TranslationFunction;
+export {};

package/dist/types/types/autofill.d.ts

@@ -0,0 +1,62 @@
+/**
+ * An AutofillModifier describe the possible operations to apply to the
+ * content of a cell when we autofill this cell.
+ *
+ * It could be:
+ *  - Increment: increment the content by a given step
+ *  - Copy: simply copy the content
+ *  - Formula: update the formula, with the same behavior than paste
+ */
+import { Getters } from ".";
+import { Cell } from "./cells";
+import { Border, DIRECTION, UID, UpdateCellData } from "./misc";
+export interface IncrementModifier {
+    type: "INCREMENT_MODIFIER";
+    increment: number;
+    current: number;
+}
+export interface AlphanumericIncrementModifier {
+    type: "ALPHANUMERIC_INCREMENT_MODIFIER";
+    increment: number;
+    current: number;
+    prefix: string;
+    numberPostfixLength: number;
+}
+export interface CopyModifier {
+    type: "COPY_MODIFIER";
+}
+export interface FormulaModifier {
+    type: "FORMULA_MODIFIER";
+    increment: number;
+    current: number;
+}
+export type AutofillModifier = IncrementModifier | AlphanumericIncrementModifier | CopyModifier | FormulaModifier;
+export interface Tooltip {
+    props: any;
+    component?: any;
+}
+export interface AutofillCellData extends UpdateCellData {
+    border?: Border;
+}
+export interface AutofillData {
+    cell?: Cell;
+    col: number;
+    row: number;
+    sheetId: UID;
+    border?: Border;
+}
+export interface AutofillResult {
+    cellData: AutofillCellData;
+    tooltip?: Tooltip;
+    origin: {
+        col: number;
+        row: number;
+    };
+}
+export interface GeneratorCell {
+    data: AutofillData;
+    rule: AutofillModifier;
+}
+export interface AutofillModifierImplementation {
+    apply: (rule: AutofillModifier, data: AutofillData, getters: Getters, direction: DIRECTION) => Omit<AutofillResult, "origin">;
+}

package/dist/types/types/cell_popovers.d.ts

@@ -0,0 +1,44 @@
+import { ComponentConstructor } from "@odoo/owl";
+import { Getters } from "./index";
+import { CellPosition, PropsOf } from "./misc";
+import { Rect } from "./rendering";
+export type CellPopoverType = "ErrorToolTip" | "LinkDisplay" | "FilterMenu" | "LinkEditor";
+export type PopoverPropsPosition = "TopRight" | "BottomLeft";
+type MaxSizedComponentConstructor = ComponentConstructor & {
+    maxSize?: {
+        maxWidth?: number;
+        maxHeight?: number;
+    };
+};
+/**
+ * If the cell at the given position have an associated component (linkDisplay, errorTooltip, ...),
+ * returns the parameters to display the component
+ */
+type CellPopoverBuilder = (position: CellPosition, getters: Getters) => CellPopoverComponent<MaxSizedComponentConstructor>;
+export interface PopoverBuilders {
+    onOpen?: CellPopoverBuilder;
+    onHover?: CellPopoverBuilder;
+}
+export interface ClosedCellPopover {
+    isOpen: false;
+}
+/**
+ * Description of a cell component.
+ * i.e. which component class, which props and where to
+ * display it relative to the cell
+ */
+type OpenCellPopover<C extends ComponentConstructor> = {
+    isOpen: true;
+    Component: C;
+    props: PropsOf<C>;
+    cellCorner: PopoverPropsPosition;
+};
+export type CellPopoverComponent<C extends MaxSizedComponentConstructor = MaxSizedComponentConstructor> = ClosedCellPopover | OpenCellPopover<C>;
+export type PositionedCellPopover<C extends MaxSizedComponentConstructor = MaxSizedComponentConstructor> = {
+    isOpen: true;
+    Component: C;
+    props: PropsOf<C>;
+    anchorRect: Rect;
+    cellCorner: PopoverPropsPosition;
+};
+export {};

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

@@ -0,0 +1,64 @@
+import { EvaluationError } from "./errors";
+import { Format, FormattedValue } from "./format";
+import { Link, RangeCompiledFormula, Style, UID } from "./misc";
+interface CellAttributes {
+    readonly id: UID;
+    /**
+     * Raw cell content
+     */
+    readonly content: string;
+    readonly style?: Style;
+    readonly format?: Format;
+}
+export interface LiteralCell extends CellAttributes {
+    readonly isFormula: false;
+}
+export interface FormulaCell extends CellAttributes {
+    readonly isFormula: true;
+    readonly compiledFormula: RangeCompiledFormula;
+}
+export type Cell = LiteralCell | FormulaCell;
+interface EvaluatedCellProperties {
+    readonly format?: Format;
+    /**
+     * Cell value formatted based on the format
+     */
+    readonly formattedValue: FormattedValue;
+    readonly defaultAlign: "right" | "center" | "left";
+    /**
+     * Can the cell appear in an automatic sum zone.
+     */
+    readonly isAutoSummable: boolean;
+    readonly link?: Link;
+}
+export type CellValue = string | number | boolean | null;
+export type EvaluatedCell = NumberCell | TextCell | BooleanCell | EmptyCell | ErrorCell;
+export interface NumberCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.number;
+    readonly value: number;
+}
+export interface TextCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.text;
+    readonly value: string;
+}
+export interface BooleanCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.boolean;
+    readonly value: boolean;
+}
+export interface EmptyCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.empty;
+    readonly value: "";
+}
+export interface ErrorCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.error;
+    readonly value: string;
+    readonly error: EvaluationError;
+}
+export declare enum CellValueType {
+    boolean = "boolean",
+    number = "number",
+    text = "text",
+    empty = "empty",
+    error = "error"
+}
+export {};

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

@@ -0,0 +1,19 @@
+import type { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { LegendPosition, VerticalAxisPosition } from "./common_chart";
+export interface BarChartDefinition {
+    readonly type: "bar";
+    readonly dataSets: string[];
+    readonly dataSetsHaveTitle: boolean;
+    readonly labelRange?: string;
+    readonly title: string;
+    readonly background?: Color;
+    readonly verticalAxisPosition: VerticalAxisPosition;
+    readonly legendPosition: LegendPosition;
+    readonly stacked: boolean;
+    readonly aggregated?: boolean;
+}
+export type BarChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+    background: Color;
+};

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

@@ -0,0 +1,48 @@
+import { Range } from "../../types";
+import { XlsxHexColor } from "../xlsx";
+import { BarChartDefinition, BarChartRuntime } from "./bar_chart";
+import { LegendPosition, VerticalAxisPosition } from "./common_chart";
+import { GaugeChartDefinition, GaugeChartRuntime } from "./gauge_chart";
+import { LineChartDefinition, LineChartRuntime } from "./line_chart";
+import { PieChartDefinition, PieChartRuntime } from "./pie_chart";
+import { ScorecardChartDefinition, ScorecardChartRuntime } from "./scorecard_chart";
+export type ChartType = "line" | "bar" | "pie" | "scorecard" | "gauge";
+export type ChartDefinition = LineChartDefinition | PieChartDefinition | BarChartDefinition | ScorecardChartDefinition | GaugeChartDefinition;
+export type ChartJSRuntime = LineChartRuntime | PieChartRuntime | BarChartRuntime | GaugeChartRuntime;
+export type ChartRuntime = ChartJSRuntime | ScorecardChartRuntime;
+export interface LabelValues {
+    readonly values: string[];
+    readonly formattedValues: string[];
+}
+export interface DatasetValues {
+    readonly label?: string;
+    readonly data: any[];
+}
+export type AxisType = "category" | "linear" | "time";
+export interface DataSet {
+    readonly labelCell?: Range;
+    readonly dataRange: Range;
+}
+export interface ExcelChartDataset {
+    readonly label?: string;
+    readonly range: string;
+}
+export type ExcelChartType = "line" | "bar" | "pie";
+export interface ExcelChartDefinition {
+    readonly title?: string;
+    readonly type: ExcelChartType;
+    readonly dataSets: ExcelChartDataset[];
+    readonly labelRange?: string;
+    readonly backgroundColor: XlsxHexColor;
+    readonly fontColor: XlsxHexColor;
+    readonly verticalAxisPosition: VerticalAxisPosition;
+    readonly legendPosition: LegendPosition;
+    readonly stacked?: boolean;
+    readonly cumulative?: boolean;
+}
+export interface ChartCreationContext {
+    readonly range?: string[];
+    readonly title?: string;
+    readonly background?: string;
+    readonly auxiliaryRange?: string;
+}

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

@@ -0,0 +1,2 @@
+export type VerticalAxisPosition = "left" | "right";
+export type LegendPosition = "top" | "bottom" | "left" | "right" | "none";

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

@@ -0,0 +1,73 @@
+import type { ChartConfiguration, ChartData, ChartDataset, ChartOptions } from "chart.js";
+import { Color } from "../misc";
+export interface GaugeChartDefinition {
+    readonly type: "gauge";
+    readonly title: string;
+    readonly dataRange?: string;
+    readonly sectionRule: SectionRule;
+    readonly background?: Color;
+}
+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;
+}
+interface SectionThreshold {
+    readonly type: "number" | "percentage";
+    readonly value: string;
+}
+export interface GaugeChartConfiguration extends Omit<ChartConfiguration, "data" | "options"> {
+    data?: GaugeChartData;
+    options: GaugeChartOptions;
+}
+export interface GaugeChartRuntime {
+    chartJsConfig: GaugeChartConfiguration;
+    background: Color;
+}
+interface GaugeChartData extends Omit<ChartData, "datasets"> {
+    datasets: GaugeChartDataSets[];
+}
+interface GaugeChartDataSets extends ChartDataset<"doughnut"> {
+    readonly minValue?: number;
+    readonly value?: number | undefined;
+    readonly backgroundColor?: string[];
+}
+export interface GaugeChartOptions extends ChartOptions {
+    needle?: NeedleOptions;
+    valueLabel?: ValueLabelOptions;
+}
+export interface NeedleOptions {
+    display?: boolean;
+    borderColor?: Color;
+    backgroundColor?: Color;
+    /**
+     * Needle width as the percentage of the chart area width
+     */
+    width?: number;
+}
+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/index.d.ts

@@ -0,0 +1,7 @@
+export type * from "./bar_chart";
+export type * from "./chart";
+export type * from "./common_chart";
+export type * from "./gauge_chart";
+export type * from "./line_chart";
+export type * from "./pie_chart";
+export type * from "./scorecard_chart";

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

@@ -0,0 +1,21 @@
+import type { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { LegendPosition, VerticalAxisPosition } from "./common_chart";
+export interface LineChartDefinition {
+    readonly type: "line";
+    readonly dataSets: string[];
+    readonly dataSetsHaveTitle: boolean;
+    readonly labelRange?: string;
+    readonly title: string;
+    readonly background?: Color;
+    readonly verticalAxisPosition: VerticalAxisPosition;
+    readonly legendPosition: LegendPosition;
+    readonly labelsAsText: boolean;
+    readonly stacked: boolean;
+    readonly aggregated?: boolean;
+    readonly cumulative: boolean;
+}
+export type LineChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+    background: Color;
+};

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

@@ -0,0 +1,17 @@
+import type { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { LegendPosition } from "./common_chart";
+export interface PieChartDefinition {
+    readonly type: "pie";
+    readonly dataSets: string[];
+    readonly dataSetsHaveTitle: boolean;
+    readonly labelRange?: string;
+    readonly title: string;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly aggregated?: boolean;
+}
+export type PieChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+    background: Color;
+};

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

@@ -0,0 +1,26 @@
+import { Color, Style } from "../misc";
+export interface ScorecardChartDefinition {
+    readonly type: "scorecard";
+    readonly title: string;
+    readonly keyValue?: string;
+    readonly baseline?: string;
+    readonly baselineMode: BaselineMode;
+    readonly baselineDescr?: string;
+    readonly background?: Color;
+    readonly baselineColorUp: Color;
+    readonly baselineColorDown: Color;
+}
+export type BaselineMode = "text" | "difference" | "percentage";
+export type BaselineArrowDirection = "neutral" | "up" | "down";
+export interface ScorecardChartRuntime {
+    readonly title: string;
+    readonly keyValue: string;
+    readonly baselineDisplay: string;
+    readonly baselineColor?: string;
+    readonly baselineArrow: BaselineArrowDirection;
+    readonly baselineDescr?: string;
+    readonly background: Color;
+    readonly fontColor: Color;
+    readonly keyValueStyle?: Style;
+    readonly baselineStyle?: Style;
+}