@adaptabletools/adaptable 14.0.0-canary.0 → 14.0.0-canary.1

package/src/Api/Internal/QueryInternalApi.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
+class QueryInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Returns the name of all the referenced Named Queries as an array of strings
+     * @param expression query string
+     */
+    getReferencedNamedQueryNames(expression = '') {
+        try {
+            return this.getAdaptableApi()
+                .internalApi.getQueryLanguageService()
+                .getNamedQueryNamesFromExpression(expression);
+        }
+        catch (error) {
+            // defensive programing, this should happen only if someone botched the predefined configs
+            (0, LoggingHelper_1.LogAdaptableWarning)(`QueryApi.getReferencedNamedQueryNames received an invalid expression: ${expression}
+                  Error: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Returns all the references in the AdaptableState of the NamedQuery with the given name
+     * @param namedQueryName namedQuery name
+     */
+    getNamedQueryModuleReferences(namedQueryName) {
+        const references = [];
+        this.adaptable.adaptableModules.forEach((module) => {
+            if (module
+                .getModuleNamedQueryReferences()
+                .some((moduleReference) => moduleReference === namedQueryName)) {
+                references.push(module.moduleInfo.FriendlyName);
+            }
+        });
+        return references;
+    }
+    /**
+     * Fires Query Run Event - typically used to enable querying on the server
+     */
+    fireQueryRunEvent() {
+        if (this.adaptable.isLive) {
+            const currentQuery = this.getQueryApi().getCurrentQuery();
+            const adaptableApi = this.getAdaptableApi();
+            const queryRunInfo = {
+                currentQuery,
+                queryAST: currentQuery
+                    ? adaptableApi.queryLanguageApi.getASTForExpression(currentQuery)
+                    : null,
+                adaptableApi: adaptableApi,
+            };
+            adaptableApi.eventApi.emit('QueryRun', queryRunInfo);
+        }
+    }
+}
+exports.QueryInternalApi = QueryInternalApi;

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

@@ -0,0 +1,11 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableQLModule } from '../../PredefinedConfig/Common/Types';
+export declare class QueryLanguageInternalApi extends ApiBase {
+    /**
+     * Checks if a column is referenced in a given Expression
+     * @param columnId Column to Check
+     * @param expression Expression to Lookup
+     */
+    isColumnReferencedInExpression(columnId: string, expression: string): boolean;
+    evaluateExpressionInAdaptableQL(module: AdaptableQLModule, expression?: string): boolean;
+}

package/src/Api/Internal/QueryLanguageInternalApi.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryLanguageInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class QueryLanguageInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Checks if a column is referenced in a given Expression
+     * @param columnId Column to Check
+     * @param expression Expression to Lookup
+     */
+    isColumnReferencedInExpression(columnId, expression) {
+        const colIds = this.getQueryLanguageApi().getColumnsFromExpression(expression);
+        return colIds.some((c) => c === columnId);
+    }
+    evaluateExpressionInAdaptableQL(module, expression) {
+        var _a;
+        const evaluateExpressionExternallyFn = (_a = this.getAdaptableQLOptions()) === null || _a === void 0 ? void 0 : _a.evaluateAdaptableQLExternally;
+        if (typeof evaluateExpressionExternallyFn !== 'function') {
+            return true;
+        }
+        const context = {
+            adaptableApi: this.getAdaptableApi(),
+            module,
+        };
+        if (expression) {
+            context.expression = expression;
+            context.referencedColumns = this.getAdaptableApi()
+                .queryLanguageApi.getColumnsFromExpression(expression)
+                .map((columnId) => this.getAdaptableApi().columnApi.getColumnWithColumnId(columnId));
+        }
+        return !evaluateExpressionExternallyFn(context);
+    }
+}
+exports.QueryLanguageInternalApi = QueryLanguageInternalApi;

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

@@ -0,0 +1,59 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { CellColorRange, ColumnComparison, NumericStyledColumn, StyledColumn } from '../../PredefinedConfig/StyledColumnState';
+import { RowNode } from '@ag-grid-community/core/dist/cjs/es5/entities/rowNode';
+export declare class StyledColumnInternalApi extends ApiBase {
+    getMinValueForNumericColumn(column: AdaptableColumn): number | undefined;
+    getMaxValueForNumericColumn(column: AdaptableColumn): number | undefined;
+    /**
+     * 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: Omit<StyledColumn, 'ColumnId'>, column: AdaptableColumn, rowNode: RowNode, cellValue: any): number;
+    /**
+     * Returns last range that matches the cell value.
+     *
+     * @param cellRanges
+     * @param column
+     * @param rangeValueType
+     * @param cellValue
+     */
+    findRangeForColumn(cellRanges: CellColorRange[], column: AdaptableColumn, rangeValueType: NumericStyledColumn['RangeValueType'], cellValue: any): CellColorRange | null;
+    /**
+     * 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: Omit<StyledColumn, 'ColumnId'>, column: AdaptableColumn, rowNode: RowNode, cellValue: any): number;
+    /**
+     * Returns the smallest number in a Range
+     * @param range Range to check
+     * @param column current Column
+     */
+    getCellColorRangeMinValue(range: CellColorRange, column: AdaptableColumn, rangeValueType: NumericStyledColumn['RangeValueType']): number | undefined;
+    /**
+     * Returns the largest number in a Range
+     * @param range Range to check
+     * @param column current Column
+     */
+    getCellColorRangeMaxValue(range: CellColorRange, column: AdaptableColumn, rangeValueType: NumericStyledColumn['RangeValueType']): number | undefined;
+    /**
+     * Retrieves the ColumnComparison property, if there, from a Styled Column
+     * @param styledColumn Styled Column to Add
+     */
+    getColumnComparisonForStyledColumn(styledColumn: StyledColumn): ColumnComparison | undefined;
+    /**
+     * Returns any ColumnIds referenced in a Column Comparison
+     * @param columnComparision Column Comparison to check
+     */
+    getColumnIdsFromColumnComparison(columnComparison: ColumnComparison): string[];
+    private getDependentColumnIds;
+    /**
+     * Checks if the styled column has a range with a relative value
+     * @param styledColumn Styled Column to Add
+     */
+    hasStyledColumnRelativeCellRange(styledColumn: StyledColumn): boolean;
+}

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,8 +165,37 @@ 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`
+     * Returns what the layout supports.
+     * This takes into account the data-source.
      */
-    areDraftAndCurrentLayoutEqual(): boolean;
+    getLayoutSupportedFeatures(): {
+        RowGroupedColumns: boolean;
+        AggregationColumns: boolean;
+        PivotColumns: boolean;
+        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/PluginsApi.d.ts

@@ -3,6 +3,7 @@ import { IPushPullApi } from './IPushPullApi';
 import { Glue42Api } from './Glue42Api';
 import { OpenFinApi } from './OpenFinApi';
 import { FinanceApi } from './FinanceApi';
+import { FinsembleApi } from './FinsembleApi';
 /**
  * API methods dealing with AdapTable plugins
  */
@@ -44,4 +45,8 @@ export interface PluginsApi {
      * Returns Finance API class in Adaptable API
      */
     getFinancePluginApi(): FinanceApi;
+    /**
+     * Returns Finsemble API class in Adaptable API
+     */
+    getFinsemblePluginApi(): FinsembleApi;
 }