@adaptabletools/adaptable 13.1.1 → 14.0.0-canary.1

package/src/Api/Internal/CustomSortInternalApi.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomSortInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class CustomSortInternalApi extends ApiBase_1.ApiBase {
+    getCustomSortComparer(column) {
+        var _a;
+        return (_a = this.getGeneralOptions().customSortComparers) === null || _a === void 0 ? void 0 : _a.find((csc) => this.adaptable.api.scopeApi.isColumnInScope(column, csc.scope));
+    }
+}
+exports.CustomSortInternalApi = CustomSortInternalApi;

package/src/Api/Internal/DashboardInternalApi.d.ts

@@ -0,0 +1,8 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { DashboardState } from '../../PredefinedConfig/DashboardState';
+export declare class DashboardInternalApi extends ApiBase {
+    /**
+     * Fires Dashboard Changed Event
+     */
+    fireDashboardChangedEvent(trigger: string, oldDashboardState: DashboardState, newDashboardState: DashboardState): void;
+}

package/src/Api/Internal/DashboardInternalApi.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+class DashboardInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Fires Dashboard Changed Event
+     */
+    fireDashboardChangedEvent(trigger, oldDashboardState, newDashboardState) {
+        // it's called synchronously by DASHBOARD_SET_ACTIVE_TAB & DASHBOARD_SET_IS_COLLAPSED,
+        // both firing the same events, thus this function being called twice;
+        // so we debounced to only get the latest call
+        const dashboardChangedInfo = {
+            adaptableApi: this.adaptable.api,
+            actionName: trigger,
+            oldDashboardState,
+            newDashboardState,
+        };
+        if (!(0, isEqual_1.default)(oldDashboardState, newDashboardState)) {
+            this.adaptable.api.eventApi.emitSync('DashboardChanged', dashboardChangedInfo);
+        }
+    }
+}
+exports.DashboardInternalApi = DashboardInternalApi;

package/src/Api/Internal/DataSetInternalApi.d.ts

@@ -0,0 +1,9 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { DataSet } from '../../AdaptableOptions/GeneralOptions';
+export declare class DataSetInternalApi extends ApiBase {
+    /**
+     * Fires the DataSet Selected Event
+     * @param dataSet Data Set which has been selected
+     */
+    fireDataSetSelectedEvent(dataSet: DataSet): void;
+}

package/src/Api/Internal/DataSetInternalApi.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSetInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class DataSetInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Fires the DataSet Selected Event
+     * @param dataSet Data Set which has been selected
+     */
+    fireDataSetSelectedEvent(dataSet) {
+        if (this.adaptable.isLive) {
+            const dataSetSelectedInfo = {
+                adaptableApi: this.adaptable.api,
+                dataSet,
+            };
+            this.adaptable.api.eventApi.emit('DataSetSelected', dataSetSelectedInfo);
+        }
+    }
+}
+exports.DataSetInternalApi = DataSetInternalApi;

package/src/Api/Internal/ExportInternalApi.d.ts

@@ -0,0 +1,11 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { Report } from '../../PredefinedConfig/ExportState';
+export declare class ExportInternalApi extends ApiBase {
+    /**
+     * Whether given data change affects given report
+     * @param cellDataChangedInfo data change to check
+     * @param report report to check
+     */
+    isDataChangeInReport(cellDataChangedInfo: CellDataChangedInfo, report: Report): boolean;
+}

package/src/Api/Internal/ExportInternalApi.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class ExportInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Whether given data change affects given report
+     * @param cellDataChangedInfo data change to check
+     * @param report report to check
+     */
+    isDataChangeInReport(cellDataChangedInfo, report) {
+        // for All Data Report any data change is true so get out asap
+        if (report.Name == 'All Data') {
+            return true;
+        }
+        // if its a Custom Report then the User has to run it so we just ignore completely
+        if (this.getExportApi().isServerReport(report)) {
+            return false;
+        }
+        // Start with the DataChanged Column and go through all possibilities
+        switch (report.ReportColumnScope) {
+            case 'AllColumns':
+                // has to be relevant so continue to rows
+                break;
+            case 'ScopeColumns':
+                // use the Scope object which will tell us if the Column is relevant
+                if (!this.adaptable.api.scopeApi.isColumnInScopeColumns(cellDataChangedInfo.column, report.Scope)) {
+                    return false;
+                }
+                break;
+            case 'SelectedColumns':
+                let selectedCellInfo = this.adaptable.api.gridApi.getSelectedCellInfo();
+                if (selectedCellInfo) {
+                    if (selectedCellInfo.columns.find((c) => c.columnId == cellDataChangedInfo.column.columnId) == null) {
+                        return false;
+                    }
+                }
+                break;
+            case 'VisibleColumns':
+                //  hope that visibile column property is updated whenever the layout changes... (need to check!)
+                if (!cellDataChangedInfo.column.visible) {
+                    return false;
+                }
+                break;
+        }
+        // now do rows
+        switch (report.ReportRowScope) {
+            case 'AllRows':
+                return true;
+            case 'ExpressionRows':
+                return true; // TODO this is the only difficult one - do we check AdapTableQL?  if we can then that is good as we can then do a delta after all...
+            case 'SelectedCellRows':
+                let selectedCellInfo = this.adaptable.api.gridApi.getSelectedCellInfo();
+                if (selectedCellInfo && selectedCellInfo.gridCells) {
+                    if (selectedCellInfo.gridCells.find((gc) => gc.primaryKeyValue == cellDataChangedInfo.primaryKeyValue)) {
+                        return true;
+                    }
+                }
+                return false;
+            case 'SelectedRows':
+                let selectedRowInfo = this.adaptable.api.gridApi.getSelectedRowInfo();
+                if (selectedRowInfo && selectedRowInfo.gridRows) {
+                    if (selectedRowInfo.gridRows.find((gr) => gr.primaryKeyValue == cellDataChangedInfo.primaryKeyValue)) {
+                        return true;
+                    }
+                }
+                return false;
+            case 'VisibleRows':
+                return this.adaptable.isRowNodeVisible(cellDataChangedInfo.rowNode);
+        }
+    }
+}
+exports.ExportInternalApi = ExportInternalApi;

package/src/Api/Internal/FilterInternalApi.d.ts

@@ -0,0 +1,58 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { AdaptablePredicateDef } from '../../PredefinedConfig/Common/AdaptablePredicate';
+import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
+import { ColumnFilter } from '../../PredefinedConfig/Common/ColumnFilter';
+import { RowNode } from '@ag-grid-community/core';
+import { LayoutColumnFilterAction } from '../../Redux/ActionsReducers/LayoutRedux';
+import * as Redux from 'redux';
+export declare class FilterInternalApi extends ApiBase {
+    /**
+     * Returns Predicate Definition for given Column and Quick Filter shortcut
+     * @param shortcut Quick Filter shortcut to lookup
+     * @param column Adaptable Column being Filtered
+     */
+    findPredicateDefByShortcut(shortcut: string, column: AdaptableColumn): AdaptablePredicateDef;
+    /**
+     * Creates an Equality Filter based on given Grid Cells
+     * @param gridCells cells to create Filter for
+     */
+    createValuesColumnFilterForCells(gridCells: GridCell[]): ColumnFilter | null;
+    /**
+     *  Creates an Equality Filter based on given Grid Cell
+     * @param gridCell cell to create Filter for
+     */
+    createEqualityColumnFilterForCell(gridCell: GridCell): ColumnFilter | null;
+    /**
+     * Retrieves description of given Column Filter
+     * @param columnFilter Column Filter to use
+     */
+    columnFilterToString(columnFilter: ColumnFilter): string;
+    /**
+     * Retrieves descriptions of given Column Filters
+     * @param columnFilters Column Filters to use
+     */
+    columnFiltersToString(columnFilters: ColumnFilter[]): string;
+    /**
+     * Calls AdapTableQL to evaluate Filter for given Row
+     * @param columnFilter Column Filter to use
+     * @param node Row Node to evaluate
+     */
+    evaluateColumnFilter(columnFilter: ColumnFilter, node: RowNode): boolean;
+    /**
+     * Checks if the filter action should trigger grid filtering.
+     *
+     * @param action Filtering Action
+     */
+    shouldNewColumnFilterTriggerGridFiltering(action: LayoutColumnFilterAction | Redux.Action): boolean;
+    /**
+     * Fires Filter Applied Event - typically used to enable filtering on the server
+     */
+    fireFilterAppliedEvent(): void;
+    /**
+     * Compares to sets of Column Filters to see if they are identical
+     * @param filters1
+     * @param filters2
+     */
+    areColumnFiltersDifferent(oldFilters: ColumnFilter[], newFilters: ColumnFilter[]): boolean;
+}

package/src/Api/Internal/FilterInternalApi.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
+const LayoutRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/LayoutRedux"));
+const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
+class FilterInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Returns Predicate Definition for given Column and Quick Filter shortcut
+     * @param shortcut Quick Filter shortcut to lookup
+     * @param column Adaptable Column being Filtered
+     */
+    findPredicateDefByShortcut(shortcut, column) {
+        return this.getFilterApi()
+            .getFilterPredicateDefsForColumn(column)
+            .find((i) => { var _a; return (_a = i.shortcuts) === null || _a === void 0 ? void 0 : _a.includes(shortcut); });
+    }
+    /**
+     * Creates an Equality Filter based on given Grid Cells
+     * @param gridCells cells to create Filter for
+     */
+    createValuesColumnFilterForCells(gridCells) {
+        if (!gridCells) {
+            return null;
+        }
+        const filter = {
+            ColumnId: gridCells[0].column.columnId,
+            Predicate: {
+                PredicateId: 'Values',
+                Inputs: [...new Set(gridCells.map((gc) => gc.displayValue))],
+            },
+        };
+        const [savedFilter] = this.getFilterApi().setColumnFilters([filter]) || [null];
+        return savedFilter;
+    }
+    /**
+     *  Creates an Equality Filter based on given Grid Cell
+     * @param gridCell cell to create Filter for
+     */
+    createEqualityColumnFilterForCell(gridCell) {
+        if (!gridCell) {
+            return null;
+        }
+        const column = gridCell.column;
+        const filter = {
+            ColumnId: column.columnId,
+            Predicate: {
+                PredicateId: this.adaptable.api.predicateApi.internalApi.getEqualityPredicateForDataType(column.dataType),
+                Inputs: [...new Set([gridCell.rawValue])],
+            },
+        };
+        const [savedFilter] = this.getFilterApi().setColumnFilters([filter]) || [null];
+        return savedFilter;
+    }
+    /**
+     * Retrieves description of given Column Filter
+     * @param columnFilter Column Filter to use
+     */
+    columnFilterToString(columnFilter) {
+        const friendlyName = this.adaptable.api.columnApi.getFriendlyNameForColumnId(columnFilter.ColumnId);
+        return ('[' +
+            friendlyName +
+            '] ' +
+            this.adaptable.api.predicateApi.predicateToString(columnFilter.Predicate));
+    }
+    /**
+     * Retrieves descriptions of given Column Filters
+     * @param columnFilters Column Filters to use
+     */
+    columnFiltersToString(columnFilters) {
+        return columnFilters.map((cf) => this.columnFilterToString(cf)).join(', ');
+    }
+    /**
+     * Calls AdapTableQL to evaluate Filter for given Row
+     * @param columnFilter Column Filter to use
+     * @param node Row Node to evaluate
+     */
+    evaluateColumnFilter(columnFilter, node) {
+        var _a;
+        if (!columnFilter.Predicate) {
+            return true;
+        }
+        const someInputsAreEmpty = (_a = columnFilter.Predicate.Inputs) === null || _a === void 0 ? void 0 : _a.some((input) => {
+            if (typeof input === 'string') {
+                return StringExtensions_1.default.IsNullOrEmpty(input);
+            }
+            if (typeof input === 'number') {
+                return isNaN(input);
+            }
+            return !input;
+        });
+        if (someInputsAreEmpty) {
+            return true;
+        }
+        const column = this.adaptable.api.columnApi.getColumnWithColumnId(columnFilter.ColumnId);
+        if (!column) {
+            return true;
+        }
+        const gridCell = this.adaptable.api.gridApi.getGridCellFromRowNode(node, columnFilter.ColumnId);
+        if (!gridCell) {
+            return true;
+        }
+        let value = gridCell.normalisedValue;
+        return this.adaptable.api.predicateApi.handlePredicate(columnFilter.Predicate, {
+            value: value,
+            oldValue: null,
+            displayValue: gridCell.displayValue,
+            node,
+            column,
+        }, true);
+    }
+    /**
+     * Checks if the filter action should trigger grid filtering.
+     *
+     * @param action Filtering Action
+     */
+    shouldNewColumnFilterTriggerGridFiltering(action) {
+        // trigger filter change only:
+        // - new -> new filter is active
+        // - clear -> previous filters was active
+        // - clearAll -> a filter was active
+        // - edit -> same => input change
+        // - edit -> different & new is active
+        // - edit -> different & old was active
+        // - set -> new filter is active
+        // filter -> suspend changes
+        var _a, _b;
+        const isNewAndActive = action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_ADD &&
+            this.adaptable.api.filterApi.isFilterActive(action.columnFilter);
+        const isClearAndPreviousWasActive = action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_CLEAR &&
+            this.adaptable.api.filterApi.isFilterActive(action.columnFilter);
+        const isClearAllAtLeastOneActiveFilter = action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_CLEAR_ALL &&
+            this.adaptable.api.filterApi
+                .getColumnFilters()
+                .some((columnFilter) => this.adaptable.api.filterApi.isFilterActive(columnFilter));
+        let isEditTrigger = false;
+        if (action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_EDIT) {
+            const newFilter = action.columnFilter;
+            const previous = this.adaptable.api.filterApi.getColumnFilterForColumn(newFilter.ColumnId);
+            // same filter edit, so always trigger
+            if (((_a = previous === null || previous === void 0 ? void 0 : previous.Predicate) === null || _a === void 0 ? void 0 : _a.PredicateId) === ((_b = newFilter === null || newFilter === void 0 ? void 0 : newFilter.Predicate) === null || _b === void 0 ? void 0 : _b.PredicateId)) {
+                isEditTrigger = true;
+                // new filter is active
+            }
+            else if (this.adaptable.api.filterApi.isFilterActive(newFilter)) {
+                isEditTrigger = true;
+            }
+            else if (this.adaptable.api.filterApi.isFilterActive(previous)) {
+                // previous filter was active
+                isEditTrigger = true;
+            }
+        }
+        const isSetAndActive = action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_SET &&
+            this.adaptable.api.filterApi.isFilterActive(action.columnFilter);
+        const isSuspendChanged = [
+            LayoutRedux.LAYOUT_COLUMN_FILTER_SUSPEND,
+            LayoutRedux.LAYOUT_COLUMN_FILTER_SUSPEND_ALL,
+            LayoutRedux.LAYOUT_COLUMN_FILTER_UNSUSPEND,
+            LayoutRedux.LAYOUT_COLUMN_FILTER_UNSUSPEND_ALL,
+        ].includes(action.type);
+        return (isNewAndActive ||
+            isClearAndPreviousWasActive ||
+            isClearAllAtLeastOneActiveFilter ||
+            isEditTrigger ||
+            isSetAndActive ||
+            isSuspendChanged);
+    }
+    /**
+     * Fires Filter Applied Event - typically used to enable filtering on the server
+     */
+    fireFilterAppliedEvent() {
+        if (this.adaptable.isLive) {
+            const filterAppliedInfo = {
+                columnFilters: this.getFilterApi().getColumnFilters(),
+                adaptableApi: this.getAdaptableApi(),
+            };
+            this.adaptable.api.eventApi.emit('FilterApplied', filterAppliedInfo);
+        }
+    }
+    /**
+     * Compares to sets of Column Filters to see if they are identical
+     * @param filters1
+     * @param filters2
+     */
+    areColumnFiltersDifferent(oldFilters, newFilters) {
+        if (ArrayExtensions_1.default.IsNullOrEmpty(oldFilters) && ArrayExtensions_1.default.IsNullOrEmpty(newFilters)) {
+            return false;
+        }
+        return ArrayExtensions_1.default.areArraysNotEqual(oldFilters, newFilters);
+    }
+}
+exports.FilterInternalApi = FilterInternalApi;

package/src/Api/Internal/FlashingCellInternalApi.d.ts

@@ -0,0 +1,12 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { FlashingCellDefinition } from '../../PredefinedConfig/FlashingCellState';
+import { AdaptableFlashingCell } from '../../PredefinedConfig/Common/AdaptableFlashingCell';
+export declare class FlashingCellInternalApi extends ApiBase {
+    /**
+     * Merges a Flashing Cell Definition with default values
+     * @param flashingCellDefinition Flashing Cell Definition to Merge
+     */
+    mergeFlashingCellDefinitionWithDefaults(flashingCellDefinition: FlashingCellDefinition): FlashingCellDefinition;
+    getAdaptableFlashingCellFor(primaryKey: string, columnId?: string): AdaptableFlashingCell | null;
+    clearFlashingCellState(): void;
+}

package/src/Api/Internal/FlashingCellInternalApi.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlashingCellInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const Helper_1 = require("../../Utilities/Helpers/Helper");
+const SystemRedux_1 = require("../../Redux/ActionsReducers/SystemRedux");
+const AlertRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/AlertRedux"));
+class FlashingCellInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Merges a Flashing Cell Definition with default values
+     * @param flashingCellDefinition Flashing Cell Definition to Merge
+     */
+    mergeFlashingCellDefinitionWithDefaults(flashingCellDefinition) {
+        let flashingDefaults = this.adaptable.adaptableOptions.flashingCellOptions;
+        if (!flashingDefaults) {
+            return flashingCellDefinition;
+        }
+        // deep clone it, otherwise we will mutate&share(!!) the global flashingCellOptions object
+        flashingDefaults = (0, Helper_1.cloneObject)(flashingDefaults);
+        if (!flashingCellDefinition.DownChangeStyle && flashingDefaults.defaultDownChangeStyle) {
+            flashingCellDefinition.DownChangeStyle = flashingDefaults.defaultDownChangeStyle;
+        }
+        if (!flashingCellDefinition.UpChangeStyle && flashingDefaults.defaultUpChangeStyle) {
+            flashingCellDefinition.UpChangeStyle = flashingDefaults.defaultUpChangeStyle;
+        }
+        if (!flashingCellDefinition.NeutralChangeStyle && flashingDefaults.defaultNeutralChangeStyle) {
+            flashingCellDefinition.NeutralChangeStyle = flashingDefaults.defaultNeutralChangeStyle;
+        }
+        if (!flashingCellDefinition.FlashDuration && flashingDefaults.defaultFlashDuration) {
+            flashingCellDefinition.FlashDuration = flashingDefaults.defaultFlashDuration;
+        }
+        if (!flashingCellDefinition.FlashTarget && flashingDefaults.defaultFlashTarget) {
+            flashingCellDefinition.FlashTarget = flashingDefaults.defaultFlashTarget;
+        }
+        return flashingCellDefinition;
+    }
+    getAdaptableFlashingCellFor(primaryKey, columnId) {
+        var _a;
+        const { AdaptableFlashingCells: AdaptableFlashingAlerts, AdaptableFlashingCellsMap: AdaptableFlashingAlertsMap, } = this.getAdaptableState().System;
+        const forPrimaryKey = (_a = AdaptableFlashingAlerts[primaryKey]) !== null && _a !== void 0 ? _a : {};
+        const toFlashingAlert = (uuid) => { var _a; return uuid ? (_a = AdaptableFlashingAlertsMap[uuid]) !== null && _a !== void 0 ? _a : null : null; };
+        const adaptableFlashingCell = columnId
+            ? toFlashingAlert(forPrimaryKey[columnId])
+            : toFlashingAlert(forPrimaryKey[SystemRedux_1.FLASHING_CELL_ROW_KEY]);
+        if ((adaptableFlashingCell === null || adaptableFlashingCell === void 0 ? void 0 : adaptableFlashingCell.flashingCellDefinition) &&
+            !this.getAdaptableApi().layoutApi.internalApi.isObjectAvailableInLayout(adaptableFlashingCell.flashingCellDefinition, 'FlashingCell', this.getAdaptableApi().layoutApi.getCurrentLayout())) {
+            return;
+        }
+        return adaptableFlashingCell;
+    }
+    clearFlashingCellState() {
+        this.dispatchAction(AlertRedux.AlertClearFlashingCells());
+    }
+}
+exports.FlashingCellInternalApi = FlashingCellInternalApi;

package/src/Api/Internal/FormatColumnInternalApi.d.ts

@@ -0,0 +1,109 @@
+import { AdaptableColumn, AdaptableFormat, AdaptablePredicateDef, AdaptableScope, FormatColumn, StringFormatterOptions } from '../../types';
+import { ApiBase } from '../Implementation/ApiBase';
+import { RowNode } from '@ag-grid-community/core';
+export declare class FormatColumnInternalApi extends ApiBase {
+    /**
+     * Retrieves all Format Columns in Adaptable State with the `Style` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithStyle(): FormatColumn[];
+    /**
+     * Retrieves all Format Columns in Adaptable State with the `Style` or the `CellAlignment` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithStyleAndCellAlignment(): FormatColumn[];
+    /**
+     * Retrieves all Format Columns in Adaptable State with `DisplayFormat` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithDisplayFormat(): FormatColumn[];
+    /**
+     * Retrieves all Format Columns in Adaptable State with `CellAlignment` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithCellAlignment(): FormatColumn[];
+    /**
+     * Get all FormatColumns which are defined for this column and have a custom AdaptableStyle
+     * @param column
+     * @param config
+     * @returns list of FormatColumn
+     */
+    getFormatColumnsWithStyleForColumn(column: AdaptableColumn, config?: {
+        includeSuspended?: boolean;
+    }): FormatColumn[];
+    /**
+     * Gets Format Column if any for given Column which includes Style element with ClassName
+     * @param column The Column for which to retrieve the Format Column
+     * @returns format columns
+     */
+    getFormatColumnWithStyleClassNameForColumn(column: AdaptableColumn, config?: {
+        includeSuspended?: boolean;
+    }): FormatColumn[];
+    getFormatColumnWithColumnInScope(formatColumns: FormatColumn[], column: AdaptableColumn): FormatColumn[];
+    private getFormatColumnInColumnScope;
+    /**
+     * Get all FormatColumns which are defined for this column and have a custom DisplayFormat
+     * @param column
+     * @param config
+     * @returns list of FormatColumn
+     */
+    getFormatColumnsWithDisplayFormatForColumn(column: AdaptableColumn, config?: {
+        includeSuspended?: boolean;
+    }): FormatColumn[];
+    /**
+     * Format value according to format options.
+     *
+     * @param customDisplayFormatterContext context that includes value to format
+     * @param options formatter options
+     */
+    getNumberFormattedValue(value: any, node: RowNode, abColumn: AdaptableColumn, options: AdaptableFormat['Options']): any;
+    /**
+     * Format value according to format options.
+     *
+     * @param value  context that includes value to format
+     * @param options formatter options
+     */
+    getStringFormattedValue(value: any, node: RowNode, abColumn: AdaptableColumn, options: StringFormatterOptions): string;
+    /**
+     * Format value according to format options.
+     *
+     * @param customDisplayFormatterContext  context that includes value to format
+     * @param options formatter options
+     */
+    getDateFormattedValue(value: any, node: RowNode, abColumn: AdaptableColumn, options: AdaptableFormat['Options']): string;
+    private applyCustomFormatters;
+    /**
+     * Returns all Predicates appropriate for the given Scope
+     * @param scope Scope to check
+     */
+    getFormatColumnDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    /**
+     * Checks if format column is relevant for a given cell (intersection of given AdaptableColumn and RowNode)
+     *
+     * @param formatColumn
+     * @param column
+     * @param params
+     */
+    isFormatColumnRelevantForColumn(formatColumn: FormatColumn, column: AdaptableColumn, params: {
+        node: RowNode;
+        value: any;
+    }): boolean;
+    private evaluatePredicate;
+    private evaluateExpression;
+    /**
+     * Extract from the given FormatColumns only the ones which are relevant for a given cell (intersection of given AdaptableColumn and RowNode)
+     *
+     * @param formatColumns
+     * @param column
+     * @param params
+     */
+    getFormatColumnsRelevantForColumn(formatColumns: FormatColumn[], column: AdaptableColumn, params: {
+        node: RowNode;
+        value: any;
+    }): FormatColumn[];
+    /**
+     * Retrieves all Format Columns which have an Expression
+     * @returns Format Columns with Expression
+     */
+    getFormatColumnsWithExpression(): FormatColumn[];
+}