@adaptabletools/adaptable 13.1.1 → 14.0.0-canary.1

package/src/Api/{Implementation/InternalApiImpl.js → Internal/AdaptableInternalApi.js}

@@ -1,138 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InternalApiImpl = void 0;
+exports.AdaptableInternalApi = void 0;
 const tslib_1 = require("tslib");
 const PopupRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/PopupRedux"));
 const SystemRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/SystemRedux"));
 const SystemRedux_1 = require("../../Redux/ActionsReducers/SystemRedux");
 const GridRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/GridRedux"));
-const AlertRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/AlertRedux"));
 const DeadRedux = tslib_1.__importStar(require("../../Redux/DeadRedux"));
-const ApiBase_1 = require("./ApiBase");
+const ApiBase_1 = require("../Implementation/ApiBase");
 const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
 const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
 const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
-const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
-const AdaptableAlert_1 = require("../../PredefinedConfig/Common/AdaptableAlert");
 const waitForCondition_1 = require("../../Utilities/waitForCondition");
 const AdaptableIconComponent_1 = require("../../components/AdaptableIconComponent");
-class InternalApiImpl extends ApiBase_1.ApiBase {
+class AdaptableInternalApi extends ApiBase_1.ApiBase {
     getSystemState() {
         return this.getAdaptableState().System;
     }
-    getAdaptableFormFromAlertForm(alertForm, context, defaultMessageType) {
-        var _a, _b;
-        const api = this.adaptable.api;
-        let adaptableAlertForm;
-        let isActionForm = false;
-        if (typeof alertForm === 'string') {
-            const alertForms = this.getAlertOptions().alertForms || [];
-            adaptableAlertForm = (_a = alertForms.find((f) => f.name === alertForm)) === null || _a === void 0 ? void 0 : _a.form;
-        }
-        else {
-            adaptableAlertForm = Object.assign(Object.assign({}, alertForm), { buttons: (alertForm.Buttons || []).map((alertButton) => {
-                    return Object.assign(Object.assign({}, alertButton), { onClick: () => {
-                            api.alertApi.executeAlertButton(alertButton, context);
-                        } });
-                }) });
-            isActionForm = true;
-        }
-        if (!adaptableAlertForm) {
-            return;
-        }
-        if (adaptableAlertForm && adaptableAlertForm.buttons) {
-            // dont mutate the form, but clone it
-            adaptableAlertForm = Object.assign({}, adaptableAlertForm);
-            adaptableAlertForm.buttons = (_b = adaptableAlertForm.buttons) === null || _b === void 0 ? void 0 : _b.map((button) => {
-                let buttonStyle = isActionForm
-                    ? button.ButtonStyle
-                    : this.getStyleForButton(button, context);
-                if (defaultMessageType && !(buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.tone)) {
-                    // force the button tone to be the alert tone, if the tone is missing from button style (or button style non-existent)
-                    buttonStyle = Object.assign(Object.assign({}, buttonStyle), { tone: defaultMessageType.toLowerCase() });
-                }
-                let label = isActionForm
-                    ? button.Label
-                    : this.getLabelForButton(button, context);
-                return Object.assign(Object.assign({}, button), { buttonStyle,
-                    label });
-            });
-        }
-        return adaptableAlertForm;
-    }
-    getAdaptableAlerts() {
-        var _a;
-        return (_a = this.getSystemState().AdaptableAlerts) !== null && _a !== void 0 ? _a : [];
-    }
-    getAdaptableCellChangedAlerts() {
-        return this.getAdaptableAlerts().filter(AdaptableAlert_1.isAdaptableCellChangedAlert);
-    }
-    getAdaptableRowChangedAlerts() {
-        return this.getAdaptableAlerts().filter(AdaptableAlert_1.isAdaptableRowChangedAlert);
-    }
-    getAdaptableAlertWithHighlightCell(columnId, rowNode) {
-        // only alerts triggered by cell changes are relevant for HighlightCell actions
-        return this.getAdaptableCellChangedAlerts().find((alert) => {
-            var _a, _b, _c, _d;
-            return ((_a = alert.alertDefinition.AlertProperties) === null || _a === void 0 ? void 0 : _a.HighlightCell) &&
-                ((_c = (_b = alert.cellDataChangedInfo) === null || _b === void 0 ? void 0 : _b.column) === null || _c === void 0 ? void 0 : _c.columnId) === columnId &&
-                ((_d = alert.cellDataChangedInfo) === null || _d === void 0 ? void 0 : _d.rowNode) === rowNode;
-        });
-    }
-    getAdaptableAlertWithHighlightRow(rowNode) {
-        let alertWithRowHighlight;
-        alertWithRowHighlight = this.getAdaptableRowChangedAlerts().find((alert) => {
-            var _a, _b;
-            if ((_a = alert.alertDefinition.AlertProperties) === null || _a === void 0 ? void 0 : _a.HighlightRow) {
-                if ((_b = alert.gridDataChangedInfo) === null || _b === void 0 ? void 0 : _b.rowNodes.map((rowNode) => rowNode.id).includes(rowNode.id)) {
-                    return alert;
-                }
-            }
-        });
-        if (alertWithRowHighlight) {
-            return alertWithRowHighlight;
-        }
-        alertWithRowHighlight = this.getAdaptableCellChangedAlerts().find((alert) => {
-            var _a, _b;
-            if ((_a = alert.alertDefinition.AlertProperties) === null || _a === void 0 ? void 0 : _a.HighlightRow) {
-                if (((_b = alert.cellDataChangedInfo) === null || _b === void 0 ? void 0 : _b.rowNode.id) == rowNode.id) {
-                    return alert;
-                }
-            }
-        });
-        return alertWithRowHighlight;
-    }
-    isAlertDefinitionForAddedRowChangeEvent(alertDefinition) {
-        var _a, _b;
-        const addedRowPredicate = 'AddedRow';
-        return ((_b = (_a = alertDefinition === null || alertDefinition === void 0 ? void 0 : alertDefinition.Rule) === null || _a === void 0 ? void 0 : _a.Predicate) === null || _b === void 0 ? void 0 : _b.PredicateId) === addedRowPredicate;
-    }
-    isAlertDefinitionForRemovedRowChangeEvent(alertDefinition) {
-        var _a, _b;
-        const removedRowPredicate = 'RemovedRow';
-        return ((_b = (_a = alertDefinition === null || alertDefinition === void 0 ? void 0 : alertDefinition.Rule) === null || _a === void 0 ? void 0 : _a.Predicate) === null || _b === void 0 ? void 0 : _b.PredicateId) === removedRowPredicate;
-    }
-    getAdaptableFlashingCellFor(primaryKey, columnId) {
-        var _a;
-        const { AdaptableFlashingCells: AdaptableFlashingAlerts, AdaptableFlashingCellsMap: AdaptableFlashingAlertsMap, } = this.getSystemState();
-        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.isObjectAvailableInLayout(adaptableFlashingCell.flashingCellDefinition, 'FlashingCell', this.getAdaptableApi().layoutApi.getCurrentLayout())) {
-            return;
-        }
-        return adaptableFlashingCell;
-    }
-    addSystemStatusMessageInfo(systemStatusMessageInfo) {
-        const maxMessagesInStore = this.getNotificationsOptions().maxSystemMessagesInStore;
-        this.dispatchAction(SystemRedux.SystemStatusMessageInfoAdd(systemStatusMessageInfo, maxMessagesInStore));
-    }
-    getSystemStatusMessageInfos() {
-        return this.getSystemState().SystemStatusMessages;
-    }
     // Popup Redux Actions
     showPopupConfirmation(confirmation) {
         this.dispatchAction(PopupRedux.PopupShowConfirmation(confirmation));
@@ -157,21 +41,12 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
     hidePopupScreen() {
         this.dispatchAction(PopupRedux.PopupHideScreen());
     }
-    setColumns(columns) {
-        this.dispatchAction(GridRedux.GridSetColumns(columns));
-    }
     setSettingPanelModuleMenuItems(menuItems) {
         this.dispatchAction(GridRedux.SetSettingPanelModuleMenuItems(menuItems));
     }
     setModuleButtonMenuItems(menuItems) {
         this.dispatchAction(GridRedux.SetModuleButtonMenuItems(menuItems));
     }
-    setSelectedCells(selectedCellInfo) {
-        this.dispatchAction(GridRedux.GridSetSelectedCells(selectedCellInfo));
-    }
-    setSelectedRows(selectedRowInfo) {
-        this.dispatchAction(GridRedux.GridSetSelectedRows(selectedRowInfo));
-    }
     setPivotModeOn() {
         this.dispatchAction(GridRedux.SetPivotModeOn());
     }
@@ -190,26 +65,7 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
     isGridInTreeMode() {
         return this.getAdaptableState().Grid.IsGridInTreeMode;
     }
-    addAdaptableColumn(AdaptableColumn) {
-        this.dispatchAction(GridRedux.GridAddColumn(AdaptableColumn));
-    }
-    addAdaptableColumns(AdaptableColumns) {
-        this.dispatchAction(GridRedux.GridAddColumns(AdaptableColumns));
-    }
-    removeAdaptableColumn(colId) {
-        const col = this.getAdaptableState().Grid.Columns.find((c) => c.columnId === colId);
-        if (col) {
-            this.dispatchAction(GridRedux.GridRemoveColumn(col));
-        }
-    }
-    setGridCells(gridCells) {
-        if (ArrayExtensions_1.default.IsNotNullOrEmpty(gridCells)) {
-            gridCells.forEach((gc) => {
-                this.setGridCell(gc);
-            });
-        }
-    }
-    setToolbarTitle() {
+    getToolbarTitle() {
         let toolbarTitle = this.adaptable.api.dashboardApi.getDashboardState().DashboardTitle;
         if (StringExtensions_1.default.IsNullOrEmpty(toolbarTitle)) {
             toolbarTitle = this.adaptable.adaptableOptions.adaptableId;
@@ -219,32 +75,10 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
         }
         return toolbarTitle;
     }
-    setGridCell(gridCell) {
-        const cellDataChangedInfo = this.createDataChangedInfoFromGridCell(gridCell);
-        this.adaptable.setCellValue(cellDataChangedInfo);
-    }
     buildDataChangedInfo(config) {
         var _a;
         return Object.assign(Object.assign({}, config), { rowData: (_a = config.rowNode) === null || _a === void 0 ? void 0 : _a.data, changedAt: Date.now() });
     }
-    createDataChangedInfoFromGridCell(gridCell) {
-        let currentValue = this.adaptable.getDisplayValue(gridCell.primaryKeyValue, gridCell.column.columnId);
-        const currentRowNode = this.adaptable.getRowNodeForPrimaryKey(gridCell.primaryKeyValue);
-        const cellDataChangedInfo = this.buildDataChangedInfo({
-            oldValue: currentValue,
-            newValue: gridCell.rawValue,
-            column: gridCell.column,
-            primaryKeyValue: gridCell.primaryKeyValue,
-            rowNode: currentRowNode,
-        });
-        return cellDataChangedInfo;
-    }
-    setLastAppliedShortCut(gridCell) {
-        this.dispatchAction(SystemRedux.SetLastAppliedShortcut(gridCell));
-    }
-    updateCurrentDraftLayout(layout) {
-        this.dispatchAction(GridRedux.LayoutUpdateCurrentDraft(layout));
-    }
     getPrimaryKey() {
         return this.adaptable.adaptableOptions.primaryKey;
     }
@@ -303,59 +137,12 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
         var _a, _b;
         return ((_b = (_a = this.adaptable.ModuleService.getModuleInfoByModule(adaptableModule)) === null || _a === void 0 ? void 0 : _a.FriendlyName) !== null && _b !== void 0 ? _b : adaptableModule);
     }
-    runModuleInAdaptableQL(adaptableQLModule) {
-        const adaptableQLModules = this.getAdaptableQLOptions().externallyEvaluatedModules;
-        return !adaptableQLModules.includes(adaptableQLModule);
-    }
-    evaluateExpressionInAdaptableQL(module, expression) {
-        var _a;
-        // temporary, until `externallyEvaluatedModules` is removed completely
-        const externallyEvaluatedModules = this.getAdaptableQLOptions().externallyEvaluatedModules;
-        if (externallyEvaluatedModules === null || externallyEvaluatedModules === void 0 ? void 0 : externallyEvaluatedModules.length) {
-            // fallback to deprecated property
-            return this.runModuleInAdaptableQL(module);
-        }
-        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.getColumnFromId(columnId));
-        }
-        return evaluateExpressionExternallyFn(context);
-    }
     forAllRowNodesDo(func) {
         this.adaptable.forAllRowNodesDo(func);
     }
     forAllVisibleRowNodesDo(func) {
         this.adaptable.forAllVisibleRowNodesDo(func);
     }
-    buildStandaloneColumnHeader(column) {
-        return this.adaptable.buildStandaloneColumnHeader(column);
-    }
-    clearFlashingCellState() {
-        this.dispatchAction(AlertRedux.AlertClearFlashingCells());
-    }
-    clearUpdatedRowState() {
-        this.dispatchAction(DeadRedux.UpdatedRowClear());
-    }
-    clearGradientColumnState() {
-        this.dispatchAction(DeadRedux.GradientColumnClear());
-    }
-    clearPercentBarState() {
-        this.dispatchAction(DeadRedux.PercentBarClear());
-    }
-    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));
-    }
     getLabelForButton(button, context) {
         if (!button.label) {
             return '';
@@ -424,46 +211,17 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
         }
         const firstRowData = (_a = Object.assign({}, firstRowNode === null || firstRowNode === void 0 ? void 0 : firstRowNode.data)) !== null && _a !== void 0 ? _a : {};
         // handle CalcCols which are not persisted in the rowModel
-        this.adaptable.api.calculatedColumnApi.getAllCalculatedColumn().forEach((calculatedColumn) => {
+        this.adaptable.api.calculatedColumnApi.getCalculatedColumns().forEach((calculatedColumn) => {
             const columnRawValue = this.adaptable.api.gridApi.getRawValueFromRowNode(firstRowNode, calculatedColumn.ColumnId);
             firstRowData[calculatedColumn.ColumnId] = columnRawValue;
         });
         // handle FreeTextCols which are not persisted in the rowModel
-        this.adaptable.api.freeTextColumnApi.getAllFreeTextColumn().forEach((freeTextColumn) => {
+        this.adaptable.api.freeTextColumnApi.getFreeTextColumns().forEach((freeTextColumn) => {
             const columnRawValue = this.adaptable.api.gridApi.getRawValueFromRowNode(firstRowNode, freeTextColumn.ColumnId);
             firstRowData[freeTextColumn.ColumnId] = columnRawValue;
         });
         return firstRowData;
     }
-    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);
-            });
-        });
-    }
     createFrameworkComponent(containerDomNode, frameworkComponent, componentType) {
         const createComponentFn = () => 
         // delegate the logic to framework wrapper
@@ -527,37 +285,6 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
         }
         return wordToSpell;
     }
-    hasLayoutSpecificObjects() {
-        const layoutTagOptions = this.getAdaptableOptions().layoutOptions.layoutTagOptions;
-        if (!layoutTagOptions) {
-            return false;
-        }
-        if (layoutTagOptions.autoCheckTagsForLayouts == true ||
-            typeof (layoutTagOptions === null || layoutTagOptions === void 0 ? void 0 : layoutTagOptions.isObjectAvailableInLayout) === 'function') {
-            return true;
-        }
-        return false;
-    }
-    isObjectAvailableInLayout(object, module, layout) {
-        var _a;
-        if (!this.hasLayoutSpecificObjects()) {
-            return true;
-        }
-        const layoutTagOptions = this.getAdaptableOptions().layoutOptions.layoutTagOptions;
-        if ((layoutTagOptions === null || layoutTagOptions === void 0 ? void 0 : layoutTagOptions.autoCheckTagsForLayouts) == true) {
-            return ArrayExtensions_1.default.IsNullOrEmpty(object.Tags) ? true : (_a = object.Tags) === null || _a === void 0 ? void 0 : _a.includes(layout.Name);
-        }
-        const context = {
-            adaptableObject: object,
-            module,
-            layout,
-            adaptableApi: this.getAdaptableApi(),
-        };
-        return layoutTagOptions === null || layoutTagOptions === void 0 ? void 0 : layoutTagOptions.isObjectAvailableInLayout(context);
-    }
-    showLayoutNotAssociatedObjects() {
-        return this.getAdaptableState().System.ShowLayoutNotAssociatedObjects;
-    }
     shouldDisplayTagSections() {
         return this.getAvailableTags() != undefined;
     }
@@ -592,14 +319,14 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
         }
         if (this.adaptable.adaptableOptions.layoutOptions.layoutTagOptions.autoGenerateTagsForLayouts ===
             true) {
-            return this.adaptable.api.layoutApi.getAllLayout().map((layout) => {
+            return this.adaptable.api.layoutApi.getLayouts().map((layout) => {
                 return layout.Name;
             });
         }
         if (typeof this.adaptable.adaptableOptions.layoutOptions.layoutTagOptions
             .autoGenerateTagsForLayouts === 'function') {
             const autoGenerateTagsForLayoutsContext = {
-                layouts: this.adaptable.api.layoutApi.getAllLayout(),
+                layouts: this.adaptable.api.layoutApi.getLayouts(),
                 objectTags: this.getAdaptableApi().userInterfaceApi.getAdaptableObjectTags(),
                 adaptableApi: this.adaptable.api,
             };
@@ -624,30 +351,6 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
         // not very interesting right now, but useful later when tag is not only a plain string
         return adaptableObjectTag;
     }
-    getEditLookUpValuesForColumn(editLookUpItem, column, gridCell) {
-        if (!editLookUpItem || !column) {
-            return undefined;
-        }
-        let editLookUpValues = editLookUpItem.values;
-        // first do the function then get hardcoded items
-        if (editLookUpValues != null && typeof editLookUpValues === 'function') {
-            const editLookUpContext = {
-                adaptableApi: this.adaptable.api,
-                column: column,
-                gridCell,
-            };
-            return editLookUpValues(editLookUpContext);
-        }
-        else {
-            let arr = editLookUpValues;
-            if (arr && ArrayExtensions_1.default.IsNotNullOrEmpty(arr)) {
-                return arr;
-            }
-        }
-        // if no hard-coded values or function provided then just get the distinct values for the column
-        // this will use the columnApi method that first looks for permitted values and then distinct values
-        return this.adaptable.api.columnApi.getDistinctDisplayValuesForColumn(column.columnId);
-    }
     getAdaptableQueryExpressionText(query) {
         var _a;
         if (!query) {
@@ -729,5 +432,24 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
         }
         return rowData;
     }
+    findAdaptableObjectsByLookupCriteria({ scope, tag, ids }, specificAdaptableObjects) {
+        if (!(ids === null || ids === void 0 ? void 0 : ids.length) && !tag && !scope) {
+            return [];
+        }
+        let locatedAdaptableObjects = [...specificAdaptableObjects];
+        // IDs are the most specific locators
+        if (ids === null || ids === void 0 ? void 0 : ids.length) {
+            locatedAdaptableObjects = locatedAdaptableObjects.filter((adaptableObject) => ids.includes(adaptableObject.Uuid));
+        }
+        // secondly filter by Tags
+        if (tag) {
+            locatedAdaptableObjects = locatedAdaptableObjects.filter((adaptableObject) => { var _a; return (_a = adaptableObject.Tags) === null || _a === void 0 ? void 0 : _a.includes(tag); });
+        }
+        // lastly filter by scope
+        if (scope) {
+            locatedAdaptableObjects = locatedAdaptableObjects.filter((adaptableObject) => this.getAdaptableApi().scopeApi.isScopeInScope(adaptableObject.Scope, scope));
+        }
+        return locatedAdaptableObjects;
+    }
 }
-exports.InternalApiImpl = InternalApiImpl;
+exports.AdaptableInternalApi = AdaptableInternalApi;

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

@@ -0,0 +1,148 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableForm, AdaptableFormData } from '../../PredefinedConfig/Common/AdaptableForm';
+import { AlertFormContext } from '../../AdaptableOptions/AlertOptions';
+import { AdaptableAlertAction, AlertButton, AlertButtonForm, AlertDefinition } from '../../PredefinedConfig/AlertState';
+import { AdaptableAlert, AdaptableCellChangedAlert, AdaptableRowChangedAlert } from '../../PredefinedConfig/Common/AdaptableAlert';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { GridDataChangedInfo } from '../Events/GridDataChanged';
+import { AdaptableScope } from '../../PredefinedConfig/Common/AdaptableScope';
+import { AdaptablePredicateDef } from '../../PredefinedConfig/Common/AdaptablePredicate';
+import { AdaptableMessageType } from '../../PredefinedConfig/Common/AdaptableMessageType';
+import { AdaptableButton } from '../../PredefinedConfig/Common/AdaptableButton';
+import { ButtonStyle } from '../../PredefinedConfig/Common/ButtonStyle';
+import { RowNode } from '@ag-grid-community/core';
+export declare class AlertInternalApi extends ApiBase {
+    /**
+     * Retrieves the Adaptable Form with the given name
+     * @param name name of the Form
+     */
+    getAdaptableFormByName(name: string): AdaptableForm<AlertFormContext> | undefined;
+    /**
+     * Retrieves all Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
+     * @returns alert definitions
+     */
+    getNonReactiveAlertDefinitions(): AlertDefinition[];
+    /**
+     * Retrieves all active (non-suspended) Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
+     * @returns alert definitions
+     */
+    getActiveNonReactiveAlertDefinitions(): AlertDefinition[];
+    /**
+     *
+     * Retrieves all Alert Definitions in Alert State which are reactive (ObservableQuery & AggregationQuery)
+     * @returns alert definitions
+     */
+    getReactiveAlertDefinitions(): AlertDefinition[];
+    /**
+     *
+     * Retrieves all active (non-suspended) Alert Definitions in Alert State which are reactive (ObservableQuery & AggregationQuery)
+     * @returns alert definitions
+     */
+    getActiveReactiveAlertDefinitions(): AlertDefinition[];
+    /**
+     * Retrieves all Alert Definitions which prevent a Cell Edit
+     * @returns alert definitions
+     */
+    getAlertDefinitionsWithPreventEdit(): AlertDefinition[];
+    /**
+     * Retrieves all Alert Definitions which allow a Cell Edit
+     *  @returns alert definitions
+     */
+    getAlertDefinitionsWithAllowEdit(): AlertDefinition[];
+    /**
+     * Publishes an event when an Alert is triggered
+     * @param alertToFire Alerts which has just triggered
+     */
+    publishAlertFiredEvent(alertToFire: AdaptableAlert): void;
+    /**
+     * Runs after a button in an Alert Form is clicked
+     */
+    executeAlertButton(button: AlertButton<AlertFormContext>, context: AlertFormContext): void;
+    /**
+     * Runs after an Alert Action is invoked
+     * @param actionName Action which has been invoked
+     * @param details Info about the Alert and Form
+     */
+    executeAlertAction(actionName: AdaptableAlertAction | string, details: {
+        alertDefinition: AlertDefinition;
+        cellDataChangedInfo?: CellDataChangedInfo;
+        gridDataChangedInfo?: GridDataChangedInfo;
+        formData?: AdaptableFormData;
+    }): void;
+    /**
+     * Retrieves all Predicate Defs that match given Scope
+     * @param scope the Scope to check
+     */
+    getAlertPredicateDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    /**
+     * Returns a description of an Alert Definition
+     * @param alertDefinition Alert Definition to use
+     */
+    getAlertDescription(alertDefinition: AlertDefinition, cellDataChangedInfo?: CellDataChangedInfo): string;
+    /**
+     * Returns a description title of an Alert Definition
+     * @param alertDefinition Alert Definition to use
+     */
+    getAlertMessageTitle(alertDefinition: AlertDefinition, cellDataChangedInfo?: CellDataChangedInfo): string;
+    /**
+     * Returns custom description for alert using the 'alertMessageText' property
+     *
+     * @param alertDefinition Alert Definition to use
+     * @param dataChangedInfo data change info, it can be eighter grid or cell data chantged info
+     */
+    getCustomAlertDescription(alertDefinition: AlertDefinition, dataChangedInfo?: {
+        cellDataChangedInfo?: CellDataChangedInfo;
+        gridDataChangedInfo?: GridDataChangedInfo;
+    }): string;
+    /**
+     * Returns custom title defined by 'alertMessageTitle' property
+     * @param alertDefinition Alert Definition to use
+     * @param dataChangedInfo Data change info, it can be eighter grid or cell data chantged info
+     */
+    getCustomAlertMessageTitle(alertDefinition: AlertDefinition, dataChangedInfo?: {
+        cellDataChangedInfo?: CellDataChangedInfo;
+        gridDataChangedInfo?: GridDataChangedInfo;
+    }): string;
+    /**
+     * Returns a description of an Alert Definition's Rule
+     * @param alertDefinition Alert Definition to use
+     */
+    getAlertRuleDescription(alertDefinition: AlertDefinition): string;
+    /**
+     * Was Adaptable Alert fired due to a Cell Change
+     * @param alert AdaptableAlert to check
+     */
+    isCellChangedAdaptableAlert(alert: AdaptableAlert): boolean;
+    /**
+     * Was Adaptable Alert fired due to a Row Change
+     * @param alert AdaptableAlert to check
+     */
+    isRowChangedAdaptableAlert(alert: AdaptableAlert): boolean;
+    /**
+     * Is Adaptable Alert a Generic one
+     * @param alert AdaptableAlert to check
+     */
+    isGenericAdaptableAlert(alert: AdaptableAlert): boolean;
+    /**
+     * Returns for the Alert Type for an Adaptable Alert
+     * @param alert AdaptableAlert to check
+     */
+    getAlertTypeForAdaptableAlert(alert: AdaptableAlert): 'cellChanged' | 'rowChanged' | 'generic';
+    getAdaptableFormFromAlertForm(alertForm: string | AlertButtonForm, context: any, defaultMessageType?: AdaptableMessageType): (Omit<AdaptableForm<AlertFormContext>, 'buttons'> & {
+        buttons?: (Omit<AdaptableButton<AlertFormContext>, 'buttonStyle'> & {
+            buttonStyle?: ButtonStyle;
+        })[];
+    }) | undefined;
+    getAdaptableAlerts(): AdaptableAlert[];
+    getAdaptableCellChangedAlerts(): AdaptableCellChangedAlert[];
+    getAdaptableRowChangedAlerts(): AdaptableRowChangedAlert[];
+    getAdaptableAlertWithHighlightCell(columnId: string, rowNode: RowNode): AdaptableAlert | undefined;
+    getAdaptableAlertWithHighlightRow(rowNode: RowNode): AdaptableAlert | undefined;
+    isAlertDefinitionForAddedRowChangeEvent(alertDefinition: AlertDefinition): boolean;
+    isAlertDefinitionForRemovedRowChangeEvent(alertDefinition: AlertDefinition): boolean;
+    getAlertDefinitionsForCellDataChange(dataChangedEvent: CellDataChangedInfo): AlertDefinition[];
+    private isAggregationAlertTriggered;
+    private isAlertPredicateTriggered;
+    isAlertDefinitionForRowChangeEvent(alertDefinition: AlertDefinition): boolean;
+    showAlertForDefinitions(cellDataChangedInfo: CellDataChangedInfo, alertDefinitions?: AlertDefinition[]): void;
+}