@adaptabletools/adaptable 22.0.0-canary.7 → 22.0.0-canary.8

package/src/View/Layout/TransposedPopup.js

@@ -5,72 +5,153 @@ import { useAdaptable } from '../AdaptableContext';
 import { ColumnSelector } from '../Components/Selectors/ColumnSelector';
 import { AdaptableAgGrid } from '../../agGrid/AdaptableAgGrid';
 import { Box, Flex } from '../../components/Flex';
-const adaptableContainerId = `transposed-adaptable-container`;
-const agGridContainerId = `transposed-adaptable-ag-grid-container`;
+import { ExportModuleId } from '../../Utilities/Constants/ModuleConstants';
+import StringExtensions from '../../Utilities/Extensions/StringExtensions';
+const ADAPTABLE_CONTAINER_ID = 'transposed-adaptable-container';
+const AG_GRID_CONTAINER_ID = 'transposed-adaptable-ag-grid-container';
+/** Field used for the first column in transposed grid (hidden, holds column id). */
+const TRANSPOSED_FIRST_COLUMN_FIELD = '_transposed_column_value';
+/** Header used for the first visible column in transposed grid (shows friendly name). */
+const TRANSPOSED_FIRST_COLUMN_HEADER = '_transposed_column_header';
+function buildTransposedAdaptableOptions({ hostOptions, transposedRowsAndColumns, currentTheme, }) {
+    return {
+        primaryKey: TRANSPOSED_FIRST_COLUMN_FIELD,
+        licenseKey: hostOptions.licenseKey,
+        userName: `${hostOptions.userName}`,
+        adaptableId: `${hostOptions.adaptableId}::TransposedView`,
+        containerOptions: {
+            adaptableContainer: ADAPTABLE_CONTAINER_ID,
+            agGridContainer: AG_GRID_CONTAINER_ID,
+        },
+        entitlementOptions: { defaultAccessLevel: 'Hidden' },
+        initialState: {
+            Layout: {
+                Revision: Date.now(),
+                CurrentLayout: 'TransposedView',
+                Layouts: [
+                    {
+                        Name: 'TransposedView',
+                        TableColumns: [
+                            TRANSPOSED_FIRST_COLUMN_HEADER,
+                            ...transposedRowsAndColumns.transposedColumns.map((c) => c.colId),
+                        ],
+                        ColumnPinning: { [TRANSPOSED_FIRST_COLUMN_HEADER]: 'left' },
+                        AutoSizeColumns: true,
+                    },
+                ],
+            },
+            Theme: { CurrentTheme: currentTheme },
+        },
+    };
+}
+function buildTransposedGridOptions({ transposedRowsAndColumns, elevatedColumnId, adaptableApi, }) {
+    const firstColumn = {
+        field: TRANSPOSED_FIRST_COLUMN_HEADER,
+        headerName: adaptableApi.columnApi.getFriendlyNameForColumnId(elevatedColumnId),
+    };
+    return {
+        loading: false,
+        defaultColDef: {
+            floatingFilter: false,
+            filter: false,
+            sortable: true,
+            resizable: true,
+            enableRowGroup: false,
+            editable: false,
+            enablePivot: false,
+            enableValue: false,
+            lockPinned: true,
+            menuTabs: [],
+            width: 120,
+        },
+        columnDefs: [
+            { field: TRANSPOSED_FIRST_COLUMN_FIELD, hide: true },
+            firstColumn,
+            ...transposedRowsAndColumns.transposedColumns.map((col) => ({ field: col.colId, headerName: col.header })),
+        ],
+        rowData: transposedRowsAndColumns.transposedRows,
+        sideBar: false,
+    };
+}
 export const TransposedPopup = (props) => {
     const adaptable = useAdaptable();
-    const { transposedColumnId, hideTransposedColumn, visibleColumns, visibleRows, autosize } = props.popupProps;
-    const rowNodes = React.useMemo(() => {
-        return props.popupProps.visibleRows
-            ? adaptable.api.gridApi.getVisibleRowNodes()
-            : adaptable.api.gridApi.getAllRowNodes();
-    }, [
-    // can be later triggered by tickng data
-    ]);
     const primaryKey = adaptable.api.optionsApi.getPrimaryKey();
-    const [syntheticTransposedByColumnId, doSetSyntheticTransposedByColumnId] = React.useState(transposedColumnId);
-    const setSyntheticTransposedByColumnId = (syntheticTransposedByColumnId) => {
+    const rawConfig = (props.popupProps ?? {});
+    const transposeConfig = {
+        transposedColumnId: rawConfig.transposedColumnId ?? primaryKey,
+        hideTransposedColumn: rawConfig.hideTransposedColumn ?? true,
+        autosize: rawConfig.autosize ?? true,
+        columnsToTranspose: rawConfig.columnsToTranspose,
+        rowsToTranspose: rawConfig.rowsToTranspose,
+    };
+    const rowNodes = React.useMemo(() => {
+        let transposableRowNodes = [];
+        const rowsToTranspose = transposeConfig.rowsToTranspose;
+        if (rowsToTranspose === 'VisibleOnly') {
+            return adaptable.api.gridApi.getVisibleRowNodes();
+        }
+        if (rowsToTranspose === 'All') {
+            return adaptable.api.gridApi.getAllRowNodes();
+        }
+        if (StringExtensions.IsNotNullOrEmpty(rowsToTranspose)) {
+            adaptable.api.gridApi.getAllRowNodes().forEach((rn) => {
+                const shouldTransposeRow = adaptable.api.internalApi
+                    .getQueryLanguageService()
+                    .evaluateBooleanExpression(rowsToTranspose, ExportModuleId, rn);
+                if (shouldTransposeRow) {
+                    transposableRowNodes.push(rn);
+                }
+            });
+            return transposableRowNodes;
+        }
+        return adaptable.api.gridApi.getAllRowNodes();
+    }, [transposeConfig.rowsToTranspose, adaptable.api]);
+    const [elevatedColumnId, setElevatedColumnIdState] = React.useState(() => transposeConfig.transposedColumnId ?? primaryKey);
+    const setElevatedColumnId = (newElevatedColumnId) => {
         transposedAdaptableApiRef.current?.destroy({ unmount: true, destroyAgGrid: true });
-        doSetSyntheticTransposedByColumnId(syntheticTransposedByColumnId);
+        setElevatedColumnIdState(newElevatedColumnId);
     };
     const transposedAdaptableApiRef = React.useRef(null);
     const columns = React.useMemo(() => {
-        // customisable
-        return visibleColumns
-            ? adaptable.api.columnApi.getVisibleColumns()
-            : adaptable.api.columnApi.getUIAvailableColumns();
-    }, []);
+        const allUIColumns = adaptable.api.columnApi.getUIAvailableColumns();
+        const columnsToTranspose = transposeConfig.columnsToTranspose;
+        if (!columnsToTranspose) {
+            return allUIColumns;
+        }
+        const columnIds = typeof columnsToTranspose === 'function'
+            ? columnsToTranspose({
+                ...adaptable.api.internalApi.buildBaseContext(),
+                columns: allUIColumns,
+            })
+            : columnsToTranspose;
+        return columnIds
+            .map((c) => adaptable.api.columnApi.getColumnWithColumnId(c))
+            .filter((col) => col != null);
+    }, [transposeConfig.columnsToTranspose, adaptable.api]);
     /**
-     * This is used as first field
+     * Build transposed structure: original rows become columns (colId = primaryKey value),
+     * original columns become rows. Each transposed row has the column id/header plus
+     * one cell per original row keyed by primaryKey value.
      */
-    const transposedFirstColumnField = '_transposed_column_value';
-    const transposedFirstColumnHeader = '_transposed_column_header';
     const transposedRowsAndColumns = React.useMemo(() => {
-        /**
-         * transposed column values become primaryKey of the new tarnsposed rows
-         * we build row by row, might be easer
-         */
         const transposedColumns = [];
         const transposedRows = [];
         for (const row of rowNodes) {
-            // we force the col-ids to be strings, easer to work with
-            //row[transposeByColumnId] + '';
             const colId = adaptable.api.gridApi.getNormalisedValueFromRowNode(row, primaryKey) + '';
-            //row[synteticTransposedByColumnId] + '';
-            const header = adaptable.api.gridApi.getNormalisedValueFromRowNode(row, syntheticTransposedByColumnId) +
-                '';
-            transposedColumns.push({
-                colId,
-                header,
-            });
+            const header = adaptable.api.gridApi.getNormalisedValueFromRowNode(row, elevatedColumnId) + '';
+            transposedColumns.push({ colId, header });
         }
         for (const column of columns) {
-            /**
-             * We can hide the transposed column, if we want
-             */
-            if (hideTransposedColumn && column.columnId === syntheticTransposedByColumnId) {
+            if (transposeConfig.hideTransposedColumn &&
+                column.columnId === elevatedColumnId) {
                 continue;
             }
             const transposedRow = {
-                // [transposed-by-column-id]: [other column id],
-                // the value can be set to friendlyname
-                [transposedFirstColumnField]: column.columnId,
-                [transposedFirstColumnHeader]: column.friendlyName,
+                [TRANSPOSED_FIRST_COLUMN_FIELD]: column.columnId,
+                [TRANSPOSED_FIRST_COLUMN_HEADER]: column.friendlyName,
             };
-            for (let row of rowNodes) {
-                // [transposed-by-column-value[n]]: [other column value[n]]
+            for (const row of rowNodes) {
                 const key = adaptable.api.gridApi.getNormalisedValueFromRowNode(row, primaryKey);
-                // row[column.field]
                 let value = adaptable.api.gridApi.getDisplayValueFromRowNode(row, column.columnId);
                 if (value instanceof Date) {
                     value = value.toLocaleString();
@@ -79,90 +160,25 @@ export const TransposedPopup = (props) => {
             }
             transposedRows.push(transposedRow);
         }
-        return {
-            transposedColumns,
-            transposedRows,
-        };
-    }, [rowNodes, primaryKey, syntheticTransposedByColumnId]);
+        return { transposedColumns, transposedRows };
+    }, [rowNodes, primaryKey, elevatedColumnId, columns, transposeConfig.hideTransposedColumn, adaptable.api]);
     React.useEffect(() => {
-        // Mounting in an effect, so the nodes are rendered/available
-        const hostAdaptableOptions = adaptable.adaptableOptions;
-        const adaptableOptions = {
-            primaryKey: transposedFirstColumnField,
-            licenseKey: hostAdaptableOptions.licenseKey,
-            userName: `${hostAdaptableOptions.userName}`,
-            adaptableId: `${hostAdaptableOptions.adaptableId}::TransposedView`,
-            containerOptions: {
-                adaptableContainer: adaptableContainerId,
-                agGridContainer: agGridContainerId,
-            },
-            entitlementOptions: {
-                defaultAccessLevel: 'Hidden',
-            },
-            initialState: {
-                Layout: {
-                    Revision: Date.now(),
-                    CurrentLayout: 'TransposedView',
-                    Layouts: [
-                        {
-                            Name: 'TransposedView',
-                            TableColumns: [
-                                transposedFirstColumnHeader,
-                                ...transposedRowsAndColumns.transposedColumns.map((c) => c.colId),
-                            ],
-                            ColumnPinning: {
-                                [transposedFirstColumnHeader]: 'left',
-                            },
-                            AutoSizeColumns: true,
-                        },
-                    ],
-                },
-                Theme: {
-                    CurrentTheme: adaptable.api.themeApi.getCurrentTheme(),
-                },
-            },
-        };
-        const firstColumn = {
-            field: transposedFirstColumnHeader, // use the column friendly name
-            headerName: adaptable.api.columnApi.getFriendlyNameForColumnId(syntheticTransposedByColumnId),
-        };
-        const agGridOptions = {
-            loading: false,
-            defaultColDef: {
-                floatingFilter: false,
-                filter: false,
-                sortable: true,
-                resizable: true,
-                enableRowGroup: false,
-                editable: false,
-                enablePivot: false,
-                enableValue: false,
-                lockPinned: true,
-                menuTabs: [],
-                width: 120,
-            },
-            columnDefs: [
-                {
-                    field: transposedFirstColumnField,
-                    hide: true,
-                },
-                firstColumn,
-                ...transposedRowsAndColumns.transposedColumns.map((col) => {
-                    return {
-                        field: col.colId,
-                        type: null,
-                        headerName: col.header,
-                    };
-                }),
-            ],
-            rowData: transposedRowsAndColumns.transposedRows,
-            sideBar: false,
-        };
+        const hostOptions = adaptable.adaptableOptions;
+        const adaptableOptions = buildTransposedAdaptableOptions({
+            hostOptions,
+            transposedRowsAndColumns,
+            currentTheme: adaptable.api.themeApi.getCurrentTheme(),
+        });
+        const gridOptions = buildTransposedGridOptions({
+            transposedRowsAndColumns,
+            elevatedColumnId,
+            adaptableApi: adaptable.api,
+        });
         const modules = adaptable.agGridModulesAdapter.getAgGridRegisteredModules();
         AdaptableAgGrid._initInternal({
             variant: 'vanilla',
             adaptableOptions,
-            gridOptions: agGridOptions,
+            gridOptions,
             modules,
         }).then((adaptableApi) => {
             transposedAdaptableApiRef.current = adaptableApi;
@@ -170,30 +186,20 @@ export const TransposedPopup = (props) => {
                 transposedAdaptableApiRef.current?.themeApi.loadTheme(typeof event.theme === 'object' ? event.theme.Name : event.theme);
             });
         });
-    }, [syntheticTransposedByColumnId]);
+    }, [elevatedColumnId, adaptable]);
     React.useEffect(() => {
-        // destroy when closing the popup
         return () => {
             requestAnimationFrame(() => {
                 transposedAdaptableApiRef.current?.destroy({ unmount: true, destroyAgGrid: true });
             });
         };
     }, []);
-    /**
-     * Need to get all data, manualy pivot the grid using the primary key.
-     *
-     * 1. get the data, and pivot using the primary key
-     * 2. create the col definitios, a col definition for each row
-     * 3. create the grid
-     */
     return (React.createElement(Flex, { flexDirection: "column", className: "twa:w-full twa:h-full" },
         React.createElement(Panel, null,
             React.createElement(FormLayout, null,
                 React.createElement(FormRow, { label: "Elevated Column" },
-                    React.createElement(ColumnSelector, { value: syntheticTransposedByColumnId, onChange: (colId) => {
-                            setSyntheticTransposedByColumnId(colId);
-                        } })))),
+                    React.createElement(ColumnSelector, { value: elevatedColumnId, onChange: setElevatedColumnId })))),
         React.createElement(Flex, { className: "twa:h-full" },
-            React.createElement(Box, { id: adaptableContainerId }),
-            React.createElement(Box, { className: "twa:h-full twa:w-full", id: agGridContainerId }))));
+            React.createElement(Box, { id: ADAPTABLE_CONTAINER_ID }),
+            React.createElement(Box, { className: "twa:h-full twa:w-full", id: AG_GRID_CONTAINER_ID }))));
 };

package/src/View/Schedule/Wizard/ScheduleSettingsWizard/ScheduleSettingsReminder.js

@@ -53,7 +53,7 @@ export const ScheduleSettingsReminder = (props) => {
             React.createElement(Tabs.Content, null,
                 React.createElement(FormLayout, null,
                     React.createElement(FormRow, { label: "Name" },
-                        React.createElement(Input, { "data-name": "schedule-name", className: "twa:w-[300px]", onChange: handleNameChange, placeholder: "Enter Schedule Name", type: "string", value: props.reminderSchedule?.Name ?? '' })),
+                        React.createElement(Input, { "data-name": "schedule-name", className: "twa:w-[300px]", onChange: handleNameChange, placeholder: "Enter Reminder Name", type: "string", value: props.reminderSchedule?.Name ?? '' })),
                     React.createElement(FormRow, { label: "" },
                         React.createElement(Box, { className: "twa:h-2" })),
                     React.createElement(FormRow, { label: "Header" },

package/src/View/UIHelper.d.ts

@@ -6,6 +6,7 @@ import { Schedule, Weekday } from '../AdaptableState/Common/Schedule';
 import { AdaptableColumnDataType, AdaptableSystemIconName, AdaptableOptions } from '../types';
 import { AdaptableAlert } from '../AdaptableState/Common/AdaptableAlert';
 import { AdaptableMessageType } from '../AdaptableState/Common/AdaptableMessageType';
+import type { ContainerContext } from '../AdaptableOptions/ContainerOptions';
 export declare const BLACK: string;
 export declare const WHITE: string;
 export declare const LIGHT_GRAY: string;
@@ -31,7 +32,7 @@ export declare function getDefaultColors(): string[];
 export declare function getEmptyConfigState(): EditableConfigEntityState;
 export declare function getDescriptionForDataType(dataType: AdaptableColumnDataType): "text" | "number" | "date";
 export declare function getPlaceholderForDataType(dataType: AdaptableColumnDataType): "Enter Value" | "Enter Number" | "Enter Date";
-export declare function getModalContainer(adaptableOptions: AdaptableOptions, document: Document): HTMLElement;
+export declare function getModalContainer(adaptableOptions: AdaptableOptions, document: Document, context?: ContainerContext): HTMLElement;
 export declare function IsEmptyStyle(style: AdaptableStyle): boolean;
 export declare function IsNotEmptyStyle(style: AdaptableStyle): boolean;
 export declare function getMessageTypeByStatusColour(statusColour: StatusColour): AdaptableMessageType;

package/src/View/UIHelper.js

@@ -2,6 +2,7 @@ import { WizardStatus, } from './Components/SharedProps/EditableConfigEntityStat
 import { FontWeight, FontStyle, StatusColour } from '../AdaptableState/Common/Enums';
 import { StringExtensions } from '../Utilities/Extensions/StringExtensions';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
+import { resolveContainerElement } from '../Utilities/resolveContainerElement';
 export const BLACK = 'Black';
 export const WHITE = 'White';
 export const LIGHT_GRAY = 'LightGray';
@@ -120,19 +121,12 @@ export function getPlaceholderForDataType(dataType) {
             return 'Enter Date';
     }
 }
-export function getModalContainer(adaptableOptions, document) {
-    let modalContainer;
-    if (adaptableOptions.containerOptions.modalContainer) {
-        // this has been set, so we use the property
-        modalContainer =
-            typeof adaptableOptions.containerOptions.modalContainer === 'string'
-                ? document.getElementById(adaptableOptions.containerOptions.modalContainer)
-                : adaptableOptions.containerOptions.modalContainer;
-        if (modalContainer) {
-            const modalContainerClassName = ' modal-container';
-            if (!modalContainer.className.includes(modalContainerClassName)) {
-                modalContainer.className += modalContainerClassName;
-            }
+export function getModalContainer(adaptableOptions, document, context) {
+    let modalContainer = resolveContainerElement(adaptableOptions.containerOptions.modalContainer, context, document);
+    if (modalContainer) {
+        const modalContainerClassName = ' modal-container';
+        if (!modalContainer.className.includes(modalContainerClassName)) {
+            modalContainer.className += modalContainerClassName;
         }
     }
     if (!modalContainer) {
@@ -423,7 +417,7 @@ export function getAdaptableToolPanelWidth() {
     return getNumericCSSVariableValue(getCSSVariableValue('--ab-cmp-toolpanel__width'), 200);
 }
 export function getSimpleButtonPaddingWidth() {
-    return getNumericCSSVariableValue(getCSSVariableValue('--ab-space-1'), 4);
+    return getNumericCSSVariableValue(getCSSVariableValue('--ab-base-space'), 4);
 }
 export function getCSSVariableValue(cssVariable) {
     if (!isBrowserDocumentAvailable()) {

package/src/agGrid/Adaptable.js

@@ -5,6 +5,7 @@ import { AdaptableAgGrid } from './AdaptableAgGrid';
 import { getDefaultAdaptableOptions } from '../AdaptableOptions/DefaultAdaptableOptions';
 import { renderReactRoot as defaultRenderReactRoot } from '../renderReactRoot';
 import AdaptableWizardView from '../View/AdaptableWizardView';
+import { resolveContainerElement } from '../Utilities/resolveContainerElement';
 export class Adaptable {
     /**
      * Initializer for Adaptable
@@ -39,19 +40,18 @@ export class AdaptableNoCodeWizard {
         this.render();
     }
     render(container) {
-        let id = getDefaultAdaptableOptions().containerOptions.adaptableContainer || 'adaptable';
         if (!container) {
-            let containerOptionsContainer = this.adaptableOptions.containerOptions?.adaptableContainer;
-            if (containerOptionsContainer) {
-                if (typeof containerOptionsContainer === 'string') {
-                    id = containerOptionsContainer ?? id;
-                }
-                else {
-                    container = containerOptionsContainer;
-                }
-            }
+            const initContext = {
+                adaptableId: this.adaptableOptions?.adaptableId ?? '',
+                adaptableStateKey: this.adaptableOptions?.adaptableStateKey ?? '',
+                adaptableContext: this.adaptableOptions?.adaptableContext,
+            };
+            container = resolveContainerElement(this.adaptableOptions.containerOptions?.adaptableContainer, initContext);
+        }
+        if (!container) {
+            const defaultId = getDefaultAdaptableOptions().containerOptions.adaptableContainer || 'adaptable';
+            container = document.getElementById(defaultId);
         }
-        container = container || document.getElementById(id);
         if (!container) {
             throw new Error('Cannot find container in which to render Adaptable No Code Wizard');
         }

package/src/agGrid/AdaptableAgGrid.d.ts

@@ -1,5 +1,5 @@
 import { AdaptableOptions } from '../AdaptableOptions/AdaptableOptions';
-import { ChartRef, Column, GridApi, GridOptions, IRowNode, Module, RowModelType } from 'ag-grid-enterprise';
+import { ChartRef, Column, GridApi, GridOptions, IRowNode, Module, RowModelType, StatusPanelDef } from 'ag-grid-enterprise';
 import { AdaptableLogger } from './AdaptableLogger';
 import { AdaptableApi, DestroyConfig } from '../Api/AdaptableApi';
 import { AdaptableVariant, IAdaptable, NormalizeAdaptableStateOptions } from '../AdaptableInterfaces/IAdaptable';
@@ -20,7 +20,7 @@ import { Fdc3Service } from '../Utilities/Services/Fdc3Service';
 import { AnnotationsService } from '../Utilities/Services/AnnotationsService';
 import { IModuleCollection } from '../Strategy/Interface/IModule';
 import { AgGridMenuAdapter } from './AgGridMenuAdapter';
-import { AdaptableColumn, AdaptableTheme, ChartDefinition, ColumnSort, DataUpdateConfig, GridCell, InFilterValueResult, Layout, SelectedCellInfo, SelectedRowInfo } from '../types';
+import { AdaptableColumn, AdaptableTheme, ChartDefinition, ColumnSort, DataRowConfig, DataUpdateConfig, GridCell, InFilterValueResult, Layout, SelectedCellInfo, SelectedRowInfo } from '../types';
 import { RenderReactRootFn } from '../renderReactRoot';
 import { AgGridOptionsService } from './AgGridOptionsService';
 import { AgGridColumnAdapter } from './AgGridColumnAdapter';
@@ -119,6 +119,8 @@ export declare class AdaptableAgGrid implements IAdaptable {
      * Temporary, these are MIGRATION technical debts, and should be removed as soon as possible
      */
     private adaptableStatusPanelKeys;
+    private adaptableStatusPanelDefs;
+    hasAdaptableStatusBar: boolean;
     _PRIVATE_adaptableJSXElement: React.JSX.Element;
     private _prevLayout;
     private __prevLayoutForRefresh;
@@ -163,6 +165,11 @@ export declare class AdaptableAgGrid implements IAdaptable {
     private refreshInitialSortIfNeeded;
     showQuickFilter(): void;
     hideQuickFilter(): void;
+    showAdaptableToolPanel(): void;
+    hideAdaptableToolPanel(): void;
+    private buildAdaptableToolPanelDef;
+    showAdaptableStatusBar(): void;
+    hideAdaptableStatusBar(): void;
     private normalizeAdaptableOptions;
     private setInitialGridOptions;
     /**
@@ -170,6 +177,7 @@ export declare class AdaptableAgGrid implements IAdaptable {
      */
     private initializeAgGrid;
     useRowNodeLookUp(): boolean;
+    private buildInitContainerContext;
     getAgGridContainerElement(): HTMLElement | null;
     getAdaptableContainerElement(): HTMLElement;
     refreshSelectedCellsState(): SelectedCellInfo | undefined;
@@ -257,11 +265,7 @@ export declare class AdaptableAgGrid implements IAdaptable {
         added: IRowNode[];
         updated: IRowNode[];
     }>;
-    manageGridRows(dataRows: {
-        add?: any[];
-        update?: any[];
-        delete?: any[];
-    }, config?: DataUpdateConfig): Promise<{
+    manageGridRows(dataRowConfig: DataRowConfig, dataUpdateConfig?: DataUpdateConfig): Promise<{
         addedRows: IRowNode[];
         updatedRows: IRowNode[];
         removedRows: IRowNode[];
@@ -292,7 +296,7 @@ export declare class AdaptableAgGrid implements IAdaptable {
     getGridCellsForColumn(columnId: string, onlyVisibleRows?: boolean): GridCell[] | undefined;
     getRowNodesForPrimaryKeys(primaryKeyValues: any[]): any[];
     getRowNodeByIndex(index: number): IRowNode;
-    getAgGridStatusPanels(): import("ag-grid-enterprise").StatusPanelDef[];
+    getAgGridStatusPanels(): StatusPanelDef[];
     setDataValue(value: any, column: AdaptableColumn, primaryKeyValue: any, rowNode?: IRowNode): void;
     forAllRowNodesDo(func: (rowNode: IRowNode, rowIndex: number) => void, config?: {
         includeGroupRows?: boolean;