@adaptabletools/adaptable 13.1.1 → 14.0.0-canary.1

package/src/Api/Internal/StyledColumnInternalApi.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StyledColumnInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
+class StyledColumnInternalApi extends ApiBase_1.ApiBase {
+    getMinValueForNumericColumn(column) {
+        if (column.dataType !== 'Number') {
+            return undefined;
+        }
+        return this.adaptable.getMinMaxCachedValueForColumn(column, 'min');
+    }
+    getMaxValueForNumericColumn(column) {
+        if (column.dataType !== 'Number') {
+            return undefined;
+        }
+        return this.adaptable.getMinMaxCachedValueForColumn(column, 'max');
+    }
+    /**
+     * Gets the Minimum Value to display for a Styled Column
+     * @param styledColumn Styled Column to check
+     * @param rowNode current Row Node
+     * @param cellValue current Cell Value
+     */
+    getNumericStyleMinValue(styledColumn, column, rowNode, cellValue) {
+        var _a, _b;
+        const columnComparison = styledColumn.GradientStyle
+            ? styledColumn.GradientStyle.ColumnComparison
+            : (_a = styledColumn.PercentBarStyle) === null || _a === void 0 ? void 0 : _a.ColumnComparison;
+        if (columnComparison) {
+            if (!isNaN(Number(columnComparison.MinValue))) {
+                return Number(columnComparison.MinValue);
+            }
+            else {
+                let columnId = columnComparison.MinValue;
+                if (!this.adaptable.api.columnApi.isColumnInGrid(columnId)) {
+                    return 0;
+                }
+                else {
+                    return this.adaptable.api.gridApi.getRawValueFromRowNode(rowNode, columnId);
+                }
+            }
+        }
+        // for Gradient Column we want just the range that contains cell value
+        if (styledColumn.GradientStyle) {
+            const range = this.findRangeForColumn(styledColumn.GradientStyle.CellRanges, column, styledColumn.GradientStyle.RangeValueType, cellValue);
+            return this.getCellColorRangeMinValue(range, column, styledColumn.GradientStyle.RangeValueType);
+        }
+        // for percentbar we want to get the whole Ranges
+        if (styledColumn.PercentBarStyle) {
+            const ranges = (_b = styledColumn.PercentBarStyle) === null || _b === void 0 ? void 0 : _b.CellRanges;
+            if (ranges) {
+                return this.getCellColorRangeMinValue(ranges[0], column, styledColumn.PercentBarStyle.RangeValueType);
+            }
+        }
+    }
+    /**
+     * Returns last range that matches the cell value.
+     *
+     * @param cellRanges
+     * @param column
+     * @param rangeValueType
+     * @param cellValue
+     */
+    findRangeForColumn(cellRanges, column, rangeValueType, cellValue) {
+        if (!cellRanges || cellRanges.length === 0) {
+            return null;
+        }
+        let lastMatchingRange = null;
+        // findLast is not available on [], target is not es6
+        for (let i = cellRanges.length; i >= 0; i--) {
+            const cellRange = cellRanges[i];
+            const minRange = this.getCellColorRangeMinValue(cellRange, column, rangeValueType);
+            const maxRange = this.getCellColorRangeMaxValue(cellRange, column, rangeValueType);
+            if (cellValue >= minRange && cellValue <= maxRange) {
+                lastMatchingRange = cellRange;
+                break;
+            }
+        }
+        return lastMatchingRange;
+    }
+    /**
+     * Gets the Maximum Value to display for a Styled Column
+     * @param styledColumn Styled Column to check
+     * @param rowNode current Row Node
+     * @param cellValue current Cell Value
+     */
+    getNumericStyleMaxValue(styledColumn, column, rowNode, cellValue) {
+        var _a, _b;
+        const columnComparison = styledColumn.GradientStyle
+            ? styledColumn.GradientStyle.ColumnComparison
+            : (_a = styledColumn.PercentBarStyle) === null || _a === void 0 ? void 0 : _a.ColumnComparison;
+        if (columnComparison) {
+            if (!isNaN(Number(columnComparison.MaxValue))) {
+                return Number(columnComparison.MaxValue);
+            }
+            else {
+                let columnId = columnComparison.MaxValue;
+                if (!this.adaptable.api.columnApi.isColumnInGrid(columnId)) {
+                    return 0;
+                }
+                else {
+                    return this.adaptable.api.gridApi.getRawValueFromRowNode(rowNode, columnId);
+                }
+            }
+        }
+        if (styledColumn.GradientStyle) {
+            let range = this.findRangeForColumn(styledColumn.GradientStyle.CellRanges, column, styledColumn.GradientStyle.RangeValueType, cellValue);
+            return this.getCellColorRangeMaxValue(range, column, styledColumn.GradientStyle.RangeValueType);
+        }
+        if (styledColumn.PercentBarStyle) {
+            const ranges = (_b = styledColumn.PercentBarStyle) === null || _b === void 0 ? void 0 : _b.CellRanges;
+            if (ranges) {
+                return this.getCellColorRangeMaxValue(ranges[ranges.length - 1], column, styledColumn.PercentBarStyle.RangeValueType);
+            }
+        }
+    }
+    /**
+     * Returns the smallest number in a Range
+     * @param range Range to check
+     * @param column current Column
+     */
+    getCellColorRangeMinValue(range, column, rangeValueType) {
+        if (!range) {
+            return undefined;
+        }
+        if (range.Min == undefined) {
+            return undefined;
+        }
+        let minValue;
+        if (typeof range.Min === 'number' && rangeValueType === 'Percentage') {
+            const minColumnValue = this.getMinValueForNumericColumn(column);
+            const maxColumnValue = this.getMaxValueForNumericColumn(column);
+            minValue = minColumnValue + (range.Min / 100) * (maxColumnValue - minColumnValue);
+        }
+        else if (range.Min === 'Col-Min') {
+            const minColumnValue = this.getMinValueForNumericColumn(column);
+            minValue = minColumnValue;
+        }
+        else {
+            minValue = range.Min;
+        }
+        return minValue;
+    }
+    /**
+     * Returns the largest number in a Range
+     * @param range Range to check
+     * @param column current Column
+     */
+    getCellColorRangeMaxValue(range, column, rangeValueType) {
+        if (!range) {
+            return undefined;
+        }
+        if (range.Max == undefined) {
+            return undefined;
+        }
+        let maxValue;
+        if (typeof range.Max === 'number' && rangeValueType === 'Percentage') {
+            const minColumnValue = this.getMinValueForNumericColumn(column);
+            const maxColumnValue = this.getMaxValueForNumericColumn(column);
+            maxValue = minColumnValue + (range.Max / 100) * (maxColumnValue - minColumnValue);
+        }
+        else if (range.Max === 'Col-Max') {
+            const maxColumnValue = this.getMaxValueForNumericColumn(column);
+            maxValue = maxColumnValue;
+        }
+        else {
+            maxValue = range.Max;
+        }
+        return maxValue;
+    }
+    /**
+     * Retrieves the ColumnComparison property, if there, from a Styled Column
+     * @param styledColumn Styled Column to Add
+     */
+    getColumnComparisonForStyledColumn(styledColumn) {
+        var _a, _b;
+        if (styledColumn.GradientStyle) {
+            if ((_a = styledColumn.GradientStyle) === null || _a === void 0 ? void 0 : _a.ColumnComparison) {
+                return styledColumn.GradientStyle.ColumnComparison;
+            }
+        }
+        if (styledColumn.PercentBarStyle) {
+            if ((_b = styledColumn.PercentBarStyle) === null || _b === void 0 ? void 0 : _b.ColumnComparison) {
+                return styledColumn.PercentBarStyle.ColumnComparison;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Returns any ColumnIds referenced in a Column Comparison
+     * @param columnComparision Column Comparison to check
+     */
+    getColumnIdsFromColumnComparison(columnComparison) {
+        let returnValues = [];
+        if (typeof columnComparison.MinValue === 'string') {
+            let minIds = this.getDependentColumnIds(columnComparison.MinValue);
+            if (ArrayExtensions_1.default.IsNotNullOrEmpty(minIds)) {
+                returnValues.push(...minIds);
+            }
+        }
+        if (typeof columnComparison.MaxValue === 'string') {
+            let maxIds = this.getDependentColumnIds(columnComparison.MaxValue);
+            if (ArrayExtensions_1.default.IsNotNullOrEmpty(maxIds)) {
+                returnValues.push(...maxIds);
+            }
+        }
+        return returnValues;
+    }
+    getDependentColumnIds(columnId) {
+        if (this.getColumnApi().isCalculatedColumn(columnId)) {
+            return this.getCalculatedColumnApi().internalApi.getReferencedColumnIdsForCalculatedColumnId(columnId);
+        }
+        else {
+            return [columnId];
+        }
+    }
+    /**
+     * Checks if the styled column has a range with a relative value
+     * @param styledColumn Styled Column to Add
+     */
+    hasStyledColumnRelativeCellRange(styledColumn) {
+        var _a, _b, _c, _d, _e;
+        let cellColorRange = null;
+        let rangeValueType = 'Number';
+        if (styledColumn.GradientStyle) {
+            if ((_a = styledColumn.GradientStyle) === null || _a === void 0 ? void 0 : _a.CellRanges) {
+                cellColorRange = styledColumn.GradientStyle.CellRanges;
+            }
+            if ((_b = styledColumn.GradientStyle) === null || _b === void 0 ? void 0 : _b.RangeValueType) {
+                rangeValueType = styledColumn.GradientStyle.RangeValueType;
+            }
+        }
+        if (styledColumn.PercentBarStyle) {
+            if ((_c = styledColumn.PercentBarStyle) === null || _c === void 0 ? void 0 : _c.CellRanges) {
+                cellColorRange = styledColumn.PercentBarStyle.CellRanges;
+            }
+            if ((_d = styledColumn.PercentBarStyle) === null || _d === void 0 ? void 0 : _d.RangeValueType) {
+                rangeValueType = styledColumn.PercentBarStyle.RangeValueType;
+            }
+        }
+        return ((_e = (rangeValueType === 'Percentage' ||
+            (cellColorRange === null || cellColorRange === void 0 ? void 0 : cellColorRange.some((cellColorRange) => {
+                return cellColorRange.Min == 'Col-Min' || cellColorRange.Max == 'Col-Max';
+            })))) !== null && _e !== void 0 ? _e : false);
+    }
+}
+exports.StyledColumnInternalApi = StyledColumnInternalApi;

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

@@ -0,0 +1,11 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { SystemStatusMessageInfo } from '../../PredefinedConfig/Common/SystemStatusMessageInfo';
+export declare class SystemStatusInternalApi extends ApiBase {
+    /**
+     * Fires SystemStatusMessageDisplayed Event
+     * @param systemStatusMessageInfo Info about new System Status Message
+     */
+    fireSystemStatusMessageDisplayedEvent(systemStatusMessageInfo: SystemStatusMessageInfo): void;
+    addSystemStatusMessageInfo(systemStatusMessageInfo: SystemStatusMessageInfo): void;
+    getSystemStatusMessageInfos(): SystemStatusMessageInfo[];
+}

package/src/Api/Internal/SystemStatusInternalApi.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemStatusInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const SystemRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/SystemRedux"));
+class SystemStatusInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Fires SystemStatusMessageDisplayed Event
+     * @param systemStatusMessageInfo Info about new System Status Message
+     */
+    fireSystemStatusMessageDisplayedEvent(systemStatusMessageInfo) {
+        const systemStatusMessageDisplayedInfo = {
+            adaptableApi: this.getAdaptableApi(),
+            systemStatusMessageInfo: systemStatusMessageInfo,
+        };
+        this.getAdaptableApi().eventApi.emit('SystemStatusMessageDisplayed', systemStatusMessageDisplayedInfo);
+    }
+    addSystemStatusMessageInfo(systemStatusMessageInfo) {
+        const maxMessagesInStore = this.getNotificationsOptions().maxSystemMessagesInStore;
+        this.dispatchAction(SystemRedux.SystemStatusMessageInfoAdd(systemStatusMessageInfo, maxMessagesInStore));
+    }
+    getSystemStatusMessageInfos() {
+        return this.getAdaptableState().System.SystemStatusMessages;
+    }
+}
+exports.SystemStatusInternalApi = SystemStatusInternalApi;

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

@@ -0,0 +1,20 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { SharedEntity } from '../../PredefinedConfig/TeamSharingState';
+export declare class TeamSharingInternalApi extends ApiBase {
+    /**
+     * Fires the Team Sharing Entity Changed Event
+     * @param sharedEntity Entity that has been changed
+     */
+    fireTeamSharingEntityChangedEvent(sharedEntity: SharedEntity): void;
+    /**
+     * Trigger loading of shared entries.
+     * By default shared entries are loaded when the Team Sharing popup is visible.
+     */
+    triggerLoadingTeamSharingEntries(): void;
+    /**
+     * Retrieves shared entry dependencies.
+     */
+    getSharedEntryDependencies(sharedEntity: SharedEntity): SharedEntity[];
+    getLocalTeamSharingEntities(): SharedEntity[];
+    waitForTeamSharingImportEnd(): Promise<boolean>;
+}

package/src/Api/Internal/TeamSharingInternalApi.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamSharingInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const TeamSharingRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/TeamSharingRedux"));
+class TeamSharingInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Fires the Team Sharing Entity Changed Event
+     * @param sharedEntity Entity that has been changed
+     */
+    fireTeamSharingEntityChangedEvent(sharedEntity) {
+        if (this.adaptable.isLive) {
+            const teamSharingEntityChangedInfo = {
+                adaptableApi: this.adaptable.api,
+                sharedEntity: sharedEntity,
+            };
+            this.getAdaptableApi().eventApi.emit('TeamSharingEntityChanged', teamSharingEntityChangedInfo);
+        }
+    }
+    /**
+     * Trigger loading of shared entries.
+     * By default shared entries are loaded when the Team Sharing popup is visible.
+     */
+    triggerLoadingTeamSharingEntries() {
+        this.dispatchAction(TeamSharingRedux.TeamSharingGet());
+    }
+    /**
+     * Retrieves shared entry dependencies.
+     */
+    getSharedEntryDependencies(sharedEntity) {
+        var _a;
+        const allEntities = this.getTeamSharingApi().getLoadedSharedEntities();
+        return ((_a = sharedEntity === null || sharedEntity === void 0 ? void 0 : sharedEntity.EntityDependencyIds) !== null && _a !== void 0 ? _a : []).map((id) => allEntities.find((entity) => entity.Uuid === id));
+    }
+    getLocalTeamSharingEntities() {
+        return this.getAdaptableState().TeamSharing.SharedEntities;
+    }
+    waitForTeamSharingImportEnd() {
+        // we have no deterministic means to ensure the teamsharing import is finished (because the import actions are opaque and may have side-effects)
+        // therefore we will listen for state changes and
+        // if the state was unchanged in the last `waitForStableState` ms, we assume/hope the import is finished
+        const waitForStableState = 1000;
+        const waitThreshold = 5000;
+        return new Promise((resolve, reject) => {
+            let pollTimer;
+            // stop the poll after `waitThreshold` ms, if the state hasn't stabilised until now, it probably never will...
+            let breakTimer = setTimeout(() => {
+                unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+                clearTimeout(pollTimer);
+                reject(false);
+            }, waitThreshold);
+            // poll state for changes:
+            const unsubscribe = this.adaptable.api.eventApi.on('AdaptableStateChanged', () => {
+                clearTimeout(pollTimer);
+                pollTimer = setTimeout(() => {
+                    // state is stable, cleanup all subscriptions before returning
+                    unsubscribe();
+                    clearTimeout(breakTimer);
+                    resolve(true);
+                }, waitForStableState);
+            });
+        });
+    }
+}
+exports.TeamSharingInternalApi = TeamSharingInternalApi;

package/src/Api/LayoutApi.d.ts

@@ -53,9 +53,9 @@ export interface LayoutApi {
      * Retrieves all Layouts in Adaptable State
      * @returns layouts
      */
-    getAllLayout(): Layout[];
+    getLayouts(): Layout[];
     /**
-     * Retrieves Layout by id
+     * Retrieves Layout by by the technical ID (from `LayoutState`)
      * @param id Layout id
      * @returns layout
      */
@@ -64,13 +64,6 @@ export interface LayoutApi {
      * Saves current Layout - using column order, visibility, sorting etc. currently in use in the grid
      */
     saveCurrentLayout(): void;
-    /**
-     * Saves given Layout into Adaptable State (creates new Layout if it doesn't exist)
-     * @param layoutToSave the Layout to save
-     *
-     * @deprecated use `createOrUpdateLayout()` instead
-     */
-    saveLayout(layoutToSave: Layout): void;
     /**
      * Creates new Layout into Adaptable State or updates an existing Layout (with same name or id)
      * @param layout the Layout to create or update
@@ -107,33 +100,10 @@ export interface LayoutApi {
      * @param layout Layout to check
      */
     doesLayoutExist(layout: Layout): boolean;
-    /**
-     * Fires the `LayoutChanged` event
-     * @param trigger what caused event to fire
-     * @param oldSate Layout State before change
-     * @param newState Layout State after change
-     */
-    fireLayoutChangedEvent(trigger: string, oldSate: LayoutState, newState: LayoutState, skipEqualityCheck?: boolean): void;
-    /**
-     * Compares 2 Layouts for equality
-     * @param layout1 First Layout
-     * @param layout2 Second Layout
-     */
-    areLayoutsEqual(layout1: Layout, layout2: Layout): boolean;
-    /**
-     * Get a string description of a Layout
-     * @param layout Layout to describe
-     */
-    getLayoutDescription(layout: Layout): string;
-    /**
-     * Creates a Default Layout (when none provided in Config)
-     * @returns layout
-     */
-    createDefaultLayoutIfNeeded(): Layout | null;
     /**
      * Opens Settings Panel with Layout section selected
      */
-    showLayoutPopup(): void;
+    openLayoutSettingsPanel(): void;
     /**
      * Opens Layout Editor - for Current or a named Layout
      * @param layoutName Name of Layout to be edited or cloned; if not specified, uses Current Layout
@@ -145,7 +115,7 @@ export interface LayoutApi {
      */
     action?: 'New' | 'Clone' | 'Edit'): void;
     /**
-     * Sets a new Caption / Header for a Column (this Layout only)
+     * Sets a new Caption / Header for a Column (only for current Layout)
      * @param columnId Column to Update
      * @param caption New Caption to display
      */
@@ -178,10 +148,6 @@ export interface LayoutApi {
      * Checks if the Current Layout is Default Layout
      */
     isCurrentLayoutDefault(): boolean;
-    /**
-     * Returns true if Layouts will contain Expanded Row Groups information
-     */
-    areExpandedRowGroupsSavedInLayouts(): boolean;
     /**
      * Removes a Column from the Current Layout
      * @param columnId Column to remove
@@ -199,12 +165,7 @@ export interface LayoutApi {
      */
     removeColumnFromLayout(columnId: string, layoutName: string): void;
     /**
-     * Checks if the draft layout and the current layout are the same.
-     * Useful when `autoSaveLayouts=true`
-     */
-    areDraftAndCurrentLayoutEqual(): boolean;
-    /**
-     * Returns whant the layout supports.
+     * Returns what the layout supports.
      * This takes into account the data-source.
      */
     getLayoutSupportedFeatures(): {
@@ -214,4 +175,27 @@ export interface LayoutApi {
         ColumnFilters: boolean;
         ColumnSorts: boolean;
     };
+    /**
+     * TO BE REMOVED
+     */
+    /**
+     * @deprecated use `getLayouts()` instead
+     */
+    getAllLayout(): Layout[];
+    /**
+     * @deprecated internal method, will be removed in next major release
+     */
+    fireLayoutChangedEvent(trigger: string, oldSate: LayoutState, newState: LayoutState, skipEqualityCheck?: boolean): void;
+    /**
+     * @deprecated internal method, will be removed in next major release
+     */
+    areLayoutsEqual(layout1: Layout, layout2: Layout): boolean;
+    /**
+     * @deprecated internal method, will be removed in next major release
+     */
+    createDefaultLayoutIfNeeded(): Layout | null;
+    /**
+     * @deprecated use `openLayoutSettingsPanel()` instead
+     */
+    showLayoutPopup(): void;
 }

package/src/Api/PlusMinusApi.d.ts

@@ -16,7 +16,7 @@ export interface PlusMinusApi {
         includeLayoutNotAssociatedObjects?: boolean;
     }): PlusMinusNudge[];
     /**
-     * Retrieves Plus Minus Rule by Id
+     * Retrieves Plus Minus Rule by the technical ID (from `PlusMinusState`)
      * @param id Plus Minus id
      * @returns plus minus rule
      */
@@ -46,7 +46,7 @@ export interface PlusMinusApi {
     /**
      * Opens Settings Panel with Plus Minus section selected and visible
      */
-    showPlusMinusPopup(): void;
+    openPlusMinusSettingsPanel(): void;
     /**
      * Replaces Plus Minus Rule in State with given one
      * @param plusMinusNudge Plus Minus Rule to edit
@@ -71,4 +71,11 @@ export interface PlusMinusApi {
      * @returns plus minus rule
      */
     unSuspendPlusMinusNudge(plusMinusNudge: PlusMinusNudge): PlusMinusNudge;
+    /**
+     * TO BE REMOVED
+     */
+    /**
+     * @deprecated use `openPlusMinusSettingsPanel()` instead
+     */
+    showPlusMinusPopup(): void;
 }

package/src/Api/PredicateApi.d.ts

@@ -46,6 +46,11 @@ export interface PredicateApi {
      * @param predicate Predicate Definition to check
      */
     isValidPredicate(predicate: AdaptablePredicate): boolean;
+    /**
+     * Checks if all predicates are valid
+     * @param predicates Predicates Definitions to check
+     */
+    isEveryPredicateValid(predicates: AdaptablePredicate[]): boolean;
     /**
      * Main Handler function for a Predicate Definition - used by AdapTableQL
      * @param predicate Predicate to handle
@@ -54,30 +59,41 @@ export interface PredicateApi {
      */
     handlePredicate(predicate: AdaptablePredicate | undefined, params: Omit<PredicateDefHandlerParams, 'api' | 'inputs'>, defaultReturn: boolean): boolean;
     /**
-     * Gets the correct Equality-type System Predicate for a particular DataType
-     * @param dataType DataType of Column
+     * Handle and compose (with AND) the given Predicate Definitions
+     * @param predicate Predicate to handle
+     * @param params Additional inputs as required
+     * @param defaultReturn Whether to return the default
      */
-    getEqualityPredicateForDataType(dataType: AdaptableColumnDataType): SystemFilterPredicateId;
+    handlePredicates(predicates: AdaptablePredicate[], params: Omit<PredicateDefHandlerParams, 'api' | 'inputs'>, defaultReturn: boolean): boolean;
     /**
-     * Returns true if the predicate has a dropdown.
-     *
-     * @param predicate
+     * TO BE REMOVED
+     */
+    /**
+     * @deprecated use `IsEveryPredicateValid()` instead
+     */
+    arePredicatesValid(predicates: AdaptablePredicate[]): boolean;
+    /**
+     * @deprecated internal method, will be removed in next major release
      */
     hasPredicateValues(predicate: AdaptablePredicate): boolean;
     /**
-     * Get all Filter Predicate Definitions - System and Custom
+     * @deprecated internal method, will be removed in next major release
      */
     getFilterPredicateDefs(): AdaptablePredicateDef[];
     /**
-     * Get all Alert Predicate Definitions - System and Custom
+     * @deprecated internal method, will be removed in next major release
      */
     getAlertPredicateDefs(): AdaptablePredicateDef[];
     /**
-     * Get all Format Column Predicate Definitions - System and Custom
+     * @deprecated internal method, will be removed in next major release
      */
     getFormatColumnPredicateDefs(): AdaptablePredicateDef[];
     /**
-     * Get all Flashing Cell Predicate Definitions - System and Custom
+     * @deprecated internal method, will be removed in next major release
      */
     getFlashingCellPredicateDefs(): AdaptablePredicateDef[];
+    /**
+     * @deprecated internal method, will be removed in next major release
+     */
+    getEqualityPredicateForDataType(dataType: AdaptableColumnDataType): SystemFilterPredicateId;
 }

package/src/Api/QueryApi.d.ts

@@ -1,4 +1,4 @@
-import { QueryState, NamedQuery } from '../PredefinedConfig/QueryState';
+import { NamedQuery, QueryState } from '../PredefinedConfig/QueryState';
 /**
  * Provides run-time access to Named and Current Queries
  */
@@ -11,7 +11,7 @@ export interface QueryApi {
     /**
      * Gets all Named Queries in Adaptable State
      */
-    getAllNamedQuery(): NamedQuery[];
+    getNamedQueries(): NamedQuery[];
     /**
      * Retrieves Named Query with given name from State
      * @param namedQueryName Name of Named Query
@@ -25,24 +25,10 @@ export interface QueryApi {
         valid: boolean;
         message: string;
     };
-    /**
-     * Returns the name of all the referenced Named Queries as an array of strings
-     * @param expression query string
-     */
-    getReferencedNamedQueryNames(expression: string): string[];
-    /**
-     * Returns all the references in the AdaptableState of the NamedQuery with the given name
-     * @param namedQueryName namedQuery name
-     */
-    getNamedQueryModuleReferences(namedQueryName: string): string[];
     /**
      * Opens Settings Panel with Query section selected and visible
      */
-    showQueryPopup(): void;
-    /**
-     * Opens Expanded Query Popup screen
-     */
-    showExpandedQueryPopup(): void;
+    openQuerySettingsPanel(): void;
     /**
      * Set a Query as Current Query
      * @param query - Query to set
@@ -63,7 +49,26 @@ export interface QueryApi {
      */
     expandCurrentQuery(query?: string): void;
     /**
-     * Fires Query Run Event - typically used to enable querying on the server
+     * TO BE REMOVED
+     */
+    /**
+     * @deprecated use `getNamedQueries()` instead
+     */
+    getAllNamedQuery(): NamedQuery[];
+    /**
+     * @deprecated internal method, will be removed in next major release
+     */
+    getReferencedNamedQueryNames(expression: string): string[];
+    /**
+     * @deprecated internal method, will be removed in next major release
+     */
+    getNamedQueryModuleReferences(namedQueryName: string): string[];
+    /**
+     * @deprecated use `openQuerySettingsPanel()` instead
+     */
+    showQueryPopup(): void;
+    /**
+     * @deprecated internal method, will be removed in next major release
      */
     fireQueryRunEvent(): void;
 }

package/src/Api/QuickSearchApi.d.ts

@@ -31,7 +31,11 @@ export interface QuickSearchApi {
      */
     setQuickSearchStyle(style: AdaptableStyle): void;
     /**
-     * Opens Settings Panel with Quick Search section selected and visible
+     * @deprecated use `openQuickSearchSettingsPanel()` instead
      */
     showQuickSearchPopup(): void;
+    /**
+     * Opens Settings Panel with Quick Search section selected and visible
+     */
+    openQuickSearchSettingsPanel(): void;
 }