@ic3/reporting-api 8.0.0-alpha.6 → 8.0.0-rc.3

package/dist/PublicTidyColumn.d.ts

@@ -1,17 +1,60 @@
-import { AxisCoordinate, EntityItem, IMdxAxisSeriesInfo, ITidyTableSelection, MdxInfo, SortingType, TidyCellError, TidyColumnCoordinateUniqueName, TidyColumnsType } from "./PublicTidyTableTypes";
+import { AxisCoordinate, ConvertToTypeParseSettings, EntityItem, IMdxAxisSeriesInfo, ITidyColumnsSource, ITidyTableSelection, MdxInfo, MdxMemberCoordinates, TidyCellError, TidyColumnsSubType, TidyColumnsType } from "./PublicTidyTableTypes";
 import { TidyActionEvent } from "./IcEvent";
-import { ITidyTable } from "./PublicTidyTable";
 import { ReactElement } from "react";
 import { ThemeTextFormatter } from "./PublicTheme";
+import { Property } from "csstype";
+import { AppNotification } from "./INotification";
+export interface ITidyColumnTypedValue {
+    value: any;
+    type: TidyColumnsType;
+}
+export declare type ITidyColumnAddValue = ITidyColumnAddValueInsert | ITidyColumnAddValueCopyRow;
+export interface ITidyColumnAddValueInsert {
+    options: "INSERT";
+    value: ITidyColumnTypedValue;
+    fValue?: string;
+}
+export interface ITidyColumnAddValueCopyRow {
+    options: "COPY_ROW";
+    rowIndex: number;
+}
 /**
  * Properties with a special meaning
  */
 export declare enum ITidyColumnNamedProperties {
+    /**
+     * The formatted value of a cell. For example, 5003 in euros is formatted as €5,003
+     */
     mdxCellFormattedValue = "formattedValue",
+    /**
+     * MDX related colorings
+     */
     mdxCellBackColor = "mdxCellBackColor",
+    /**
+     * MDX related colorings
+     */
     mdxCellForeColor = "mdxCellForeColor",
+    /**
+     * The format string for the cell value. For example, euros are formatted using €#,###.
+     * and percentages using #0.00%.
+     */
     mdxCellFormatString = "mdxCellFormatString",
+    /**
+     * The main color of the cell
+     */
     mdxCellColor = "color",
+    /**
+     * Column defined to fire an app. notification.
+     *
+     * The name of the notification (e.g., print-report).
+     */
+    appNotificationType = "appNotificationType",
+    /**
+     * Column defined to fire an app. notification.
+     *
+     * The parameters of the notification (e.g., page size, filename, ...) as a JSON or a string.
+     */
+    appNotificationPayload = "appNotificationPayload",
     /**
      * Column defined to fire events, the name of the event
      */
@@ -35,9 +78,13 @@ export declare enum ITidyColumnNamedProperties {
     /**
      * Column defined as an MDX axis, the key of the column
      */
-    key = "key",
+    mdxCellKey = "key",
+    /**
+     * Show this when hovering over the cell (or the visualisation representing the cell)
+     */
     tooltip = "tooltip"
 }
+export declare const CharacterTidyColumnProperties: Set<string>;
 /**
  * A copy from XLSX CellObject (we don't want the link to the library !)
  */
@@ -71,58 +118,110 @@ export interface ITidyColumnXlsxCell {
     /** The style/theme of the cell (if applicable) */
     s?: any;
 }
-export declare type AllowedColumnType<T> = TidyColumnsType.UNKNOWN | (T extends string ? TidyColumnsType.COLOR | TidyColumnsType.CHARACTER : T extends number ? TidyColumnsType.NUMERIC | TidyColumnsType.LATITUDE | TidyColumnsType.LONGITUDE : T extends boolean ? TidyColumnsType.LOGICAL : T extends number[] ? TidyColumnsType.VECTOR : T extends Date ? TidyColumnsType.DATETIME : T extends null ? TidyColumnsType.NULL : TidyColumnsType.MIXED);
-/**
- * Base interface for nullable column.
- */
-export interface ITidyBaseColumn<T> {
+declare type NonNullable<T> = Exclude<T, null | undefined>;
+export declare type AllowedColumnType<T> = TidyColumnsType.UNKNOWN | TidyColumnsType.MIXED | (NonNullable<T> extends Property.Color ? TidyColumnsType.COLOR : TidyColumnsType.UNKNOWN) | (NonNullable<T> extends string ? TidyColumnsType.CHARACTER : TidyColumnsType.UNKNOWN) | (NonNullable<T> extends number ? TidyColumnsType.NUMERIC | TidyColumnsType.LATITUDE | TidyColumnsType.LONGITUDE : TidyColumnsType.UNKNOWN) | (NonNullable<T> extends boolean ? TidyColumnsType.LOGICAL : TidyColumnsType.UNKNOWN) | (NonNullable<T> extends any[] ? TidyColumnsType.LIST : TidyColumnsType.UNKNOWN) | (NonNullable<T> extends Date ? TidyColumnsType.DATETIME : TidyColumnsType.UNKNOWN) | (NonNullable<T> extends unknown ? TidyColumnsType : TidyColumnsType.UNKNOWN) | (T extends null ? TidyColumnsType.NULL : TidyColumnsType.UNKNOWN);
+export interface ITidyBaseColumnReadonly<T> {
+    /**
+     * Returns the length of the value array.
+     */
+    length(): number;
+    /**
+     * Returns true if and only if the column has zero rows.
+     */
+    isEmpty(): boolean;
+    getSource(): ITidyColumnsSource;
+    /**
+     * Get the MDX role of the column
+     */
+    getRole(): string | undefined;
+    /**
+     * Return the type of the column
+     */
+    getType(): AllowedColumnType<T>;
     /**
-     * The name of the column.
+     * E.g., datetime column: YEAR, ...
      */
-    name: string;
+    getSubType(): TidyColumnsSubType | undefined;
     /**
-     * Create a column.
-     * @param name name of the column.
-     * @param values values in the column.
-     * @param type optional type of the column.
+     * Check if column is of type
+     * @param type check this type
      */
+    is<T extends TidyColumnsType>(type: T): this is ITidyColumnIsType<T>;
+    /**
+     * Returns true if and only if the column is of the type(s) specified
+     * @param typesToCheck one or more types to check this column against
+     */
+    isOfType(...typesToCheck: TidyColumnsType[]): boolean;
     /**
      * Returns the name of the column.
      */
     getName(): string;
     /**
-     * Set the name of the column.
-     * @param name set this as the caption of the column.
+     * Get the display name of the column. Both the name and the caption form the display name of the column.
      */
-    setName(name: string): void;
+    getDisplayName(): string;
     /**
      * Returns the caption of the column. The caption is used for displaying localised
      * or custom captions for the axis, header, etc.
      */
     getCaption(): string;
     /**
-     * Set the caption of the column. The caption is used for displaying localised
-     * or custom captions for the axis, header, etc.
-     * @param caption set this as the caption of the column.
+     * Returns the formatter of the column.
      */
-    setCaption(caption: string): void;
+    getNumberFormat(): ThemeTextFormatter | undefined;
+    /**
+     * Returns true if the column is a hierarchical structure
+     */
+    isHierarchy(): boolean;
+    /**
+     * For hierarchical structures the tree depth (starts at zero).
+     */
+    getLevelDepthR(idx: number): number;
+    /**
+     * Returns the column values.
+     */
+    getValues(): ReadonlyArray<T>;
     /**
      * Get the value of the column at position idx.
      * @param idx the position to return the value of.
      */
     getValue(idx: number): T;
     /**
-     * Set the value of a column at a certain index.
-     * @param idx row index.
-     * @param newValue new value for the column.
+     * Function used for value comparison in sorting and ranking. Return a positive number if a > b, a negative
+     * number if a < b and 0 otherwise.
+     * @param a value 1
+     * @param b value 2
+     */
+    compare(a: T, b: T): number;
+    /**
+     * Apply a function to the groups of unique values in this column
+     *
+     * @return a map with the string value and the row indices in the group.
      */
-    setValue(idx: number, newValue: T): void;
+    groupBy(): Map<string, number[]>;
     /**
-     * Get cell as expected by xlsx library (do not include the interface as it's lazy loaded !)
+     * Same as reIndex but creating a new column leaving this column untouched.
      *
-     * @param idx the position to return the value of.
+     * @see ITidyBaseColumn.reIndex
      */
-    getExcelCell(idx: number): ITidyColumnXlsxCell | undefined;
+    reIndexN(index: number[]): ITidyBaseColumn<T>;
+}
+/**
+ * Base interface for nullable column.
+ */
+export interface ITidyBaseColumn<T> extends ITidyBaseColumnReadonly<T> {
+    getErrors(): (TidyCellError | undefined)[];
+    /**
+     * If an error occurred in the calculation of cells for a column, then the error can be
+     * retrieved using this function.
+     * @param idx the row index of the cell to retrieve the error of.
+     */
+    getError(idx: number): TidyCellError | undefined;
+    /**
+     * Returns first value where callback does not return undefined.
+     * @param callback given the row index, outputs a value or undefined.
+     */
+    findFirst<P>(callback: (idx: number) => P | undefined): P | undefined;
     /**
      * Get the formatted value of the column at position idx.
      *
@@ -132,216 +231,269 @@ export interface ITidyBaseColumn<T> {
      * @param idx the position to return the value of.
      */
     getFormattedValue(idx: number): string | undefined;
-    getFormattedValueOrValue(idx: number): string | undefined;
-    setNumberFormat(format: ThemeTextFormatter, fv: (value: T | undefined) => string): void;
-    setFormattedValues(formatString: string, formattedValues: string[]): void;
     /**
-     * Returns the formatter of the column.
+     * Return the formatted value. Fallback on the value itself.
      */
-    getNumberFormat(): ThemeTextFormatter | undefined;
+    getFormattedValueOrValue(idx: number): string | undefined;
     getNumberFormatInfo(): string | undefined;
     /**
-     * Returns the column values.
-     */
-    getValues(): Array<T>;
-    /**
-     * Set the values of this column. Ensure that the length remains the same, if not, an error is thrown.
-     * @param values new values of the column.
-     */
-    setValues<P>(values: P[]): void;
-    /**
-     * Returns the column internal values object.
-     * @deprecated Use {getValues} or {unique} instead.
-     * @see {getValues} {unique}
+     * Get cell as expected by xlsx library (do not include the interface as it's lazy loaded !)
+     * Does not return the format string.
+     *
+     * @param idx the position to return the value of.
      */
-    getInternalValues(): Array<T>;
+    getExcelCell(idx: number): ITidyColumnXlsxCell | undefined;
     /**
-     * Return a new column with transformed values.
-     * @param fun function with one parameter. Describes the transformation.
-     * @param columnName the name of the new column.
-     * @param newType new type for the column. Leave blank for auto inference of the type.
+     * Returns the type for Material-UI Table/Grid
      */
-    mapToColumn<P>(fun: (value: T, index: number) => P, columnName: string, newType?: AllowedColumnType<P>): ITidyBaseColumn<P>;
+    getXGridType(): "string" | "number" | "date" | "dateTime" | "boolean" | undefined;
     /**
-     * Apply a transformation to all values in the column. Note, this functions alters the values in the column.
-     * @param fun function with one parameter. Describes the transformation. In the function, index represents the
-     * index of the internal data structure.
-     * @param newType new type for the column. Leave blank for auto inference of the type.
+     * Return the cell decoration of the column
      */
-    apply<P>(fun: (value: T, index: number) => P, newType?: AllowedColumnType<P>): void;
+    getCellDecoration(): PublicTidyColumnCellDecoration | undefined;
     /**
-     * Fill the column with a single value.
+     * Returns true if the column has a property of requested name.
      */
-    fill<P>(value: P): void;
+    hasProperty(name: ITidyColumnNamedProperties | string): boolean;
     /**
-     * Get the unique values in this column.
+     * Returns true if the column has color property or is a color column
      */
-    unique(): T[];
+    hasColorProperty(): boolean;
     /**
-     * Get the axis values in this column.
-     *
-     * If it's an MDX Axis, the potentially sorted MDX axis (e.g. pivot table sort)
+     * Returns the color column (if defined).
      *
-     * If it's not, return undefined
+     * If the column has type 'color', then it returns itself. Else it returns the
+     * column of the first property with type 'color'.
      */
-    mdxAxis(): T[] | undefined;
+    getColorColumn(): ITidyColorColumn | undefined;
     /**
-     * Returns true if and only if the column has zero rows.
+     * Returns the color of a cell (if defined).
+     *
+     * If the column has type 'color', then it returns the cell value. Else it returns the
+     * value at rowIdx of the first property with type 'color' (if it is defined).
      */
-    isEmpty(): boolean;
+    getColor(rowIdx: number): Property.Color | undefined;
     /**
-     * Returns the length of the value array.
+     * Returns the property at the specified property coordinate.
+     * @param name name of the property.
      */
-    length(): number;
+    getProperty(name: ITidyColumnNamedProperties | string): ITidyUnknownColumn;
     /**
-     * Sort the values of the column. Edge cases such as NaN and null are sorted to the end of the column.
-     * Sort ascending by default.
+     * Returns the property at the specified property coordinate.
+     * @param name name of the property.
      */
-    sort(order?: SortingType): void;
+    getOptionalProperty(name: ITidyColumnNamedProperties | string): ITidyUnknownColumn | undefined;
     /**
-     * Get the ranking of the values. Smallest value gets rank 0,
-     * second smallest rank 1, etc. until rank n-1. Sort ascending by default.
-     * @param order sorting order. Default = ascending.
+     * Get the value of the property for the given property coordinate and the given row (undefined if the property does not exist)
+     * @param name name of the property.
+     * @param rowIdx row index for the value to return.
      */
-    getRank(order?: SortingType): number[];
+    getPropertyAt(name: ITidyColumnNamedProperties | string, rowIdx: number): any;
     /**
-     * Export the column as a flat object.
+     * Return the properties of a column for a given cell index.
+     *
+     * @param idx row index of cell.
      */
-    toChartData(): {
-        [key: string]: T;
-    }[];
+    getPropertiesAt(idx: number): Record<string, any>;
     /**
-     * Returns the mdx info at a row index.
-     * TODO (tom) this must not return undefined to ensure that we always have a unique name. Currently
-     * we use getSelectionRowIdentifier and getCoordinateUniqueName.
+     * Return available properties for this column as a list of columns.
      */
-    getMdxInfo(idx: number): MdxInfo | undefined;
+    getPropertiesAsColumns(): ITidyUnknownColumn[];
     isWithEntityItem(): boolean;
-    getEntityItem(idx: number): EntityItem | undefined;
-    getMdxCoordinates(rowIdx: number): [number, number, number] | [];
     /**
-     * Returns true if the column is a hierarchical structure
+     * Create and return the entity item at position idx for generating events.
      */
-    isHierarchy(): boolean;
+    getEntityItem(idx: number): EntityItem | undefined;
     /**
-     * Get the index of the parent. Returns idx if there is no hierarchy.
+     * Get the index of the parent. Returns -1 if the parent is the root.
      * @param idx the index to find the parent of.
      */
     getParentIdx(idx: number): number;
-    /**
-     * Returns true if the entry at position idx does not have children
-     * @param idx the position to check
-     */
-    isLeaf(idx: number): boolean;
-    /**
-     * Get the indices of the level 0 children of this node. Returns [] if the
-     * column is not a hierarchy.
-     * @param idx
-     */
-    getLeaves(idx: number): number[];
     /**
      * Return the descendants of the node in the hierarchy at the index.
      * Returned set excludes the node itself.
      * @param index
      */
     getDescendants(index: number): number[];
-    /**
-     * Returns the children of the node in the hierarchy. Excludes the node itself.
-     * @param index
-     */
-    getChildren(index: number): number[];
     /**
      * Return the siblings of the node in the hierarchy at the index.
      * Including the node itself.
      * @param index
      */
     getSiblings(index: number): number[];
-    mapAllRows<P>(fun: (index: number) => P): P[];
     /**
-     * Map the rows that are visible given a hierarchical axis and an array of boolean values
-     * @param expanded an array indicating for each index if it is expanded or not. If it is collapsed, then all
-     * children are not visible.
-     * @param fun function to apply
+     * Get the default member of the dimension that the column represents. Returns undefined
+     * if the column is not a MDX dimension.
      */
-    mapVisibleRows<P>(expanded: (rowIdx: number) => boolean, fun: (index: number) => P): P[];
-    mapTreeVisibleRows<P extends ReactElement>(expanded: (rowIdx: number) => boolean, fun: (index: number) => P, filter?: (info: MdxInfo) => boolean): P[];
+    getHierarchyDefaultMember(): EntityItem | undefined;
     /**
-     * For hierarchical structures de tree depth, starts at zero.
+     * Get the mdx coordinate (axeIdx,hierIdx,tupleIdx) of the cell at rowIdx. Defines a member in a MDX Query result axes
      */
-    getLevelDepth(idx: number): number | undefined;
-    hasMdxChildren(rowIdx: number): boolean;
+    getMdxCoordinates(rowIdx: number): MdxMemberCoordinates | undefined;
     /**
-     * Returns a string representation of the coordinate
+     * Get the array of MDX info in the column.
+     * Returns an empty array if there is no MDX info.
      */
-    getCoordinateUniqueName(rowIdx: number): TidyColumnCoordinateUniqueName;
+    getMdxInfos(): (MdxInfo | undefined)[];
     /**
-     * Returns true if the column has a property of requested type.
+     * Returns the MDX info at a row index.
      */
-    hasProperty(type: TidyColumnsType): boolean;
+    getMdxInfo(idx: number): MdxInfo | undefined;
     /**
-     * Returns the property at the specified property coordinate.
-     * @param name name of the property.
+     * Get extra information of the MDX axis used for this column, if available.
      */
-    getProperty(name: ITidyColumnNamedProperties | string): ITidyUnknownColumn;
+    getAxisInfo(): IMdxAxisSeriesInfo | undefined;
     /**
-     * Returns the property at the specified property coordinate.
-     * @param name name of the property.
+     * Get the MDX axis coordinate, if available.
+     * @see {AxisCoordinate}
      */
-    getOptionalProperty(name: ITidyColumnNamedProperties | string): ITidyUnknownColumn | undefined;
+    getAxisCoordinate(): AxisCoordinate | undefined;
     /**
-     * Get the value of the property for the given property coordinate and the given row (undefined if the property does not exist)
-     * @param name name of the property.
-     * @param rowIdx row index for the value to return.
+     * Get the axis values in this column.
+     *
+     * If it's an MDX Axis, the potentially sorted MDX axis (e.g. pivot table sort)
+     *
+     * If it's not, return undefined
      */
-    getPropertyAt(name: ITidyColumnNamedProperties | string, rowIdx: number): any;
+    mdxAxis(): ReadonlyArray<T> | undefined;
     /**
-     * Returns true if the column has color property  or is a color column
+     * Get the unique values in this column.
+     */
+    unique(ignoreNull: boolean): T[];
+    /**
+     * Set the name of the column.
+     * @param name set this as the caption of the column.
      *
+     * Note, do not use this for columns that are in tables as it can cause duplicate columns in a table.
+     * Use setCaption to change the name visible to the user.
      */
-    hasColorProperty(): boolean;
+    setName(name: string): void;
     /**
-     * Returns the color of a cell (if defined).
+     * Set the number formatter of the column, calculating and adding the 'formattedValue' property.
+     */
+    setNumberFormat(format: ThemeTextFormatter | undefined): void;
+    /**
+     * Set the caption of the column. The caption is used for displaying localised
+     * or custom captions for the axis, header, etc.
+     * @param caption set this as the caption of the column.
+     */
+    setCaption(caption: string): void;
+    /**
+     * Convert the column to another type. This modifies the values to be of that type.
      *
-     * If the column has type 'color', then it returns the cell value. Else it returns the
-     * value at rowIdx of the first property with type 'color' (if it is defined).
+     * If type is datetime, then the settings contain the date locale (default='en_US') and
+     * the dateformat (default = 'yyyy-MM-dd').
      */
-    getColor(rowIdx: number): string | undefined;
+    convertToType(type: TidyColumnsType, settings?: ConvertToTypeParseSettings): void;
     /**
-     * Return available properties for this column as a list of columns.
+     * Same as convertToType but creating a new column.
      */
-    getProperties(): ITidyUnknownColumn[];
+    convertToTypeN(type: TidyColumnsType, settings?: ConvertToTypeParseSettings): ITidyBaseColumn<T>;
     /**
-     * Return the properties for the column as a table.
+     * Create a new column with the content of this column changing both its name and its caption.
      */
-    getPropertyTable(): ITidyTable;
+    duplicate(name: string, caption: string): ITidyBaseColumn<T>;
     /**
-     * Set a table as the properties for this column. Ensure that the row count of the table is equal to the length
-     * of the column.
-     * @param tableWithProperties table with columns that will become properties of the column.
+     * Change the values of the column.
+     * @param values the new values for the column.
+     * @param newType the new type of the column. Leave undefined for automatic inference.
      */
-    setPropertyTable(tableWithProperties: ITidyTable): void;
+    setValues<P>(values: P[], newType?: AllowedColumnType<P>): void;
     /**
-     * Return the properties of a column for a given cell index.
-     * @param idx row index of cell.
+     * Apply a transformation to all values in the column. Note, this functions alters the values in the column.
+     * @param fun function with one parameter. Describes the transformation. In the function, index represents the
+     * index of the internal data structure.
+     * @param newType new type for the column. Leave blank for auto inference of the type.
      */
-    getPropertiesAt(idx: number): Record<string, any>;
+    apply<P>(fun: (value: T, index: number) => P, newType?: AllowedColumnType<P>): void;
+    /**
+     * Inserts are sorted according to the insertion indices.
+     *
+     * e.g., add totals.
+     */
+    insertValues(inserts: Map<number, ITidyColumnAddValue>): void;
+    /**
+     * Repeat the values in the column.
+     *
+     * Examples:
+     * column.getValues() --> ['a','b','c']
+     * column.repeat(6,1) --> ['a','b','c','a','b','c']
+     * column.repeat(6,2) --> ['a','a','b','b','c','c']
+     * column.repeat(12,2) --> ['a','a','b','b','c','c','a','a','b','b','c','c']
+     *
+     * @param newLength new length of the array.
+     * @param repetition how many times to repeat each value.
+     */
+    repeat(newLength: number, repetition?: number): void;
+    /**
+     * Same as repeat but creating a new column leaving this column untouched.
+     *
+     * @see repeat
+     */
+    repeatN(newLength: number, repetition?: number): ITidyBaseColumn<T>;
+    /**
+     * Push a value to the end of the column's values.
+     */
+    pushValue(pushValue: ITidyColumnTypedValue): void;
+    /**
+     * Apply a new index to the column and its properties (e.g., limiting rows, reordering rows, copying rows).
+     *
+     * Examples:
+     * <pre>
+     *      initial values       -> [ 'a', 'b', 'c']
+     *        reIndex: [2,1,0]   -> [ 'c', 'b', 'a']
+     *        reIndex: [2,2,1]   -> [ 'c', 'c', 'b']
+     *        reIndex: [0,1,2,2] -> [ 'a', 'b', 'c','c']
+     *        reIndex: [0]       -> [ 'a' ]
+     *        reIndex: [0,5]     -> [ 'a', null ]
+     * </pre>
+     *
+     * @param index new row indices
+     *
+     * @see ITidyColumn.reIndexN
+     */
+    reIndex(index: number[]): void;
+    /**
+     * Set the formatted values. Use this if you have the formatted values pre-calculated
+     * or a function to calculate the formatted values.
+     */
+    setFormattedValues(formattedValues: (string | null)[] | ((value: T | undefined) => string)): void;
+    /**
+     * Return a new column with transformed values.
+     * @param fun function with one parameter. Describes the transformation.
+     * @param columnName the name of the new column.
+     * @param newType new type for the column. Leave blank for auto inference of the type.
+     */
+    mapToColumn<P>(fun: (value: T, index: number) => P, columnName: string, newType: AllowedColumnType<P>): ITidyBaseColumn<P>;
     /**
-     * For each row matching the lookup value call func()
      *
-     * @param lookupValue
-     * @param func  if false, stop the foreach
+     * if it's an mdx axis, for each row of the undelying mdx Axis
+     * if no, for each row
+     *
+     * @see mdxAxis
+     */
+    mapAxisOrRows<K>(callbackfn: (rowIdx: number, column: ITidyBaseColumn<T>) => K): K[];
+    /**
+     * @param callbackfn  if the return value is undefined do not map the row
+     */
+    mapAllRows<P>(callbackfn: (index: number, column: ITidyBaseColumn<T>) => P | undefined, forceMapAllRows?: boolean): P[];
+    /**
+     * Map the rows that are visible given a hierarchical axis and an array of boolean values
+     * @param expanded an array indicating for each index if it is expanded or not. If it is collapsed, then all
+     * children are not visible.
+     * @param fun function to apply
      */
-    forEachMatching(lookupValue: any, func: (rowIdx: number) => void | boolean): void;
+    mapVisibleRows<P>(expanded: (rowIdx: number) => boolean, fun: (index: number) => P): P[];
+    mapTreeVisibleRows<P extends ReactElement>(expanded: (rowIdx: number) => boolean, fun: (index: number) => P, filter?: (info: MdxInfo) => boolean): P[];
     /**
      * Set a property on the column. If the property already exists, it is overwritten.
      * @param property the column to set as a property. Ensure that the lengths are the same.
      */
     setProperty(property: ITidyColumn): void;
     /**
-     * Returns first value where callback does not return undefined.
-     * @param callback given the row index, outputs a value or undefined.
+     * Delete a property on the column
      */
-    findFirst<P>(callback: (idx: number) => P | undefined): P | undefined;
+    deleteProperty(propertyName: ITidyColumn | string): void;
     /**
      * @param column the initial selection as a column
      * @param items the initial selection (name, ...)
@@ -358,36 +510,12 @@ export interface ITidyBaseColumn<T> {
      */
     findRowIdxForSelection(sel: ITidyTableSelection, colIdx?: number, startIdx?: number): number | undefined;
     /**
-     * If an error occurred in the calculation of cells for a column, then the error can be
-     * retrieved using this function.
-     * @param idx the row index of the cell to retrieve the error of.
-     */
-    getError(idx: number): TidyCellError | undefined;
-    setErrors(errors: (TidyCellError | undefined)[]): void;
-    /**
-     * Returns the row index of the first occurrence where the values of this column equals value. Returns undefined
-     * if it did not find the value.
+     * Returns the row index of the first occurrence where the values of this column equals value.
+     * Returns undefined if it did not find the value.
+     *
      * @param value value to search for.
      */
     getRowIndexOf(value: T): number | undefined;
-    /**
-     * Apply a function to the groups of unique values in this column
-     */
-    groupBy(): Map<T, number[]>;
-    /**
-     * Get the default member of the dimension that the column represents. Returns undefined
-     * if the column is not a MDX dimension.
-     */
-    getHierarchyDefaultMember(): string | undefined;
-    /**
-     * Get extra information of the MDX axis used for this column, if available.
-     */
-    getAxisInfo(): IMdxAxisSeriesInfo | undefined;
-    /**
-     * Get the MDX axis coordinate, if available.
-     * @see {AxisCoordinate}
-     */
-    getAxisCoordinate(): AxisCoordinate | undefined;
     /**
      * For a hierarchical columns returns a a list of transformed colummns  columns as needed by a pivot
      * table like structure
@@ -405,99 +533,38 @@ export interface ITidyBaseColumn<T> {
      */
     getNodePath(rowIdx: number): number[];
     /**
-     * Returns if present an action as defined by the properties of the columns
+     * Returns if present a notification as defined by the properties of the columns
      */
-    getEventAction(rowIdx: number): [string, TidyActionEvent] | undefined;
+    getAppNotification(rowIdx: number): AppNotification | undefined;
     /**
-     * Insert a column into this column.
-     * @param column column to add.
-     * @param index insert the column at this index. If undefined, insert at the start of the
-     * this column.
+     * Returns if present an action as defined by the properties of the columns
      */
-    insertColumn(column: ITidyColumn, index?: number): void;
+    getEventAction(rowIdx: number): [string, TidyActionEvent] | undefined;
     mapUniqueNames<T>(uniqueNames: string[], mapper: (idx: number) => T | null | undefined): T[];
-    /**
-     * Apply a new index to the column and its properties.
-     *
-     * Examples:
-     * column.getValues() --> ['a','b','c']
-     * column.reIndex([2,1,0]) --> ['c','b','a']
-     * column.reIndex([2,2,1]) --> ['c','c','b']
-     * column.reIndex([0]) --> ['a']
-     * column.reIndex([0,5]) --> ['a',undefined]
-     *
-     * @param index list of integers.
-     */
-    reIndex(index: number[], keepingAxisOrder?: boolean): void;
-    slice(index: number[]): ITidyBaseColumn<T>;
-    /**
-     * Repeat the values in the column.
-     *
-     * Examples:
-     * column.getValues() --> ['a','b','c']
-     * column.repeat(6,1) --> ['a','b','c','a','b','c']
-     * column.repeat(6,2) --> ['a','a','b','b','c','c']
-     * column.repeat(12,2) --> ['a','a','b','b','c','c','a','a','b','b','c','c']
-     *
-     * @param newLength new length of the array.
-     * @param repetition how many times to repeat each value.
-     */
-    repeat(newLength: number, repetition?: number): void;
-    /**
-     * Function used for value comparison in sorting and ranking. Return a positive number if a > b, a negative
-     * number if a < b and 0 otherwise. Add the sorting type if nulls and NaNs should be pushed to the back of the
-     * column.
-     * @param a value 1
-     * @param b value 2
-     */
-    compare(a: T, b: T): number;
-    isNumeric(): this is ITidyNumericColumn;
-    isVector(): this is ITidyVectorColumn;
-    isDatetime(): this is ITidyDateColumn;
-    isCharacter(): this is ITidyCharacterColumn;
-    isLogical(): this is ITidyLogicalColumn;
-    isColor(): this is ITidyColorColumn;
-    /**
-     * Convert the column to another type. This modifies the values to be of that type.
-     */
-    convertToType(type: TidyColumnsType): void;
-    /**
-     * Change the type of the column. Note, only types that model the values in the column are allowed. For conversion,
-     * use {@link convertToType}
-     * @param type
-     */
-    setType(type: AllowedColumnType<T>): void;
-    getType(): AllowedColumnType<T>;
     /**
      * Cell decoration
      */
-    setCellDecoration(decoration: Partial<PublicTidyColumnCellDecoration>): void;
-    getCellDecoration(): Partial<PublicTidyColumnCellDecoration>;
-    /**
-     * Set a value in the cache of the column.
-     */
-    setCachedValue(key: string, value: any): void;
-    /**
-     * Get a value from the columns cache.
-     */
-    getCachedValue(key: string): any;
-    /**
-     * Clear the columns cache.
-     */
-    clearCache(): void;
+    setCellDecoration(decoration: PublicTidyColumnCellDecoration): void;
 }
-export interface PublicTidyColumnCellDecoration {
-    rendered: (rowIdx: number) => React.ReactElement;
+export declare type PublicTidyColumnCellDecoration = Partial<{
+    handlesCellsOnError: boolean;
+    appliesToCell: (rowIdx: number) => boolean;
+    rendered: (rowIdx: number, sizing?: {
+        width: number;
+        height: number;
+    }) => React.ReactElement;
     cssStyles: (rowIdx: number) => Record<string, any> | undefined;
-}
+}>;
 export declare type ITidyColumn = ITidyBaseColumn<any>;
-export declare type ITidyUnknownColumn = ITidyBaseColumn<unknown>;
+export declare type ITidyUnknownColumn = ITidyBaseColumn<unknown | null>;
+export declare type ITidyNullColumn = ITidyBaseColumn<null>;
 export declare type ITidyNumericColumn = ITidyBaseColumn<number | null>;
 export declare type ITidyCharacterColumn = ITidyBaseColumn<string | null>;
-export declare type ITidyColorColumn = ITidyBaseColumn<string | null>;
+export declare type ITidyColorColumn = ITidyBaseColumn<Property.Color | null>;
 export declare type ITidyDateColumn = ITidyBaseColumn<Date | null>;
 export declare type ITidyLogicalColumn = ITidyBaseColumn<boolean | null>;
-export declare type ITidyVectorColumn = ITidyBaseColumn<any[] | null>;
+export declare type ITidyListColumn = ITidyBaseColumn<any[] | null>;
+export declare type ITidyColumnIsType<T extends TidyColumnsType> = T extends TidyColumnsType.ANY ? ITidyColumn : T extends TidyColumnsType.COLOR ? ITidyColorColumn : T extends TidyColumnsType.LONGITUDE ? ITidyBaseColumn<number | null> : T extends TidyColumnsType.LATITUDE ? ITidyBaseColumn<number | null> : T extends TidyColumnsType.ISO2_LOCATION_CODE ? ITidyCharacterColumn : T extends TidyColumnsType.DATETIME ? ITidyDateColumn : T extends TidyColumnsType.NUMERIC ? ITidyNumericColumn : T extends TidyColumnsType.CHARACTER ? ITidyCharacterColumn : T extends TidyColumnsType.LOGICAL ? ITidyLogicalColumn : T extends TidyColumnsType.LIST ? ITidyListColumn : T extends TidyColumnsType.MIXED ? ITidyColumn : T extends TidyColumnsType.NULL ? ITidyNullColumn : ITidyUnknownColumn;
 /**
  * Introduced for tidy table HTML expression (e.g., tooltip) completion.
  *
@@ -510,3 +577,4 @@ export interface TidyTableExprColumnMeta {
 }
 export declare const TidyTableTextExprColumnMetas: TidyTableExprColumnMeta[];
 export declare const TidyTableNumberExprColumnMetas: TidyTableExprColumnMeta[];
+export {};