@adaptabletools/adaptable 18.0.0-canary.4 → 18.0.0-canary.5

package/src/View/Components/Popups/AdaptableLoadingScreen.js

@@ -1,13 +1,23 @@
 import * as React from 'react';
 import Dialog from '../../../components/Dialog';
 import { Box } from 'rebass';
-export class AdaptableLoadingScreen extends React.Component {
-    render() {
-        return (React.createElement(Dialog, { modal: true, isOpen: this.props.showLoadingScreen, onDismiss: this.props.onClose, showCloseButton: false, style: {
-                minHeight: 'auto',
-            } },
-            React.createElement(Box, { padding: 3 },
-                React.createElement("h4", null, "Initialising Grid"),
-                React.createElement("p", null, "Retrieving your settings and setting up the grid..."))));
-    }
+export function AdaptableLoadingScreen(props) {
+    const { showLoadingScreen, loadingScreenDelay, loadingScreenTitle, loadingScreenText } = props;
+    const [delayElapsed, setDelayElapsed] = React.useState(typeof loadingScreenDelay === 'number' ? false : showLoadingScreen);
+    React.useEffect(() => {
+        if (typeof loadingScreenDelay === 'number') {
+            const timeoutId = setTimeout(() => {
+                setDelayElapsed(true);
+            }, loadingScreenDelay);
+            return () => {
+                clearTimeout(timeoutId);
+            };
+        }
+    }, [loadingScreenDelay]);
+    return (React.createElement(Dialog, { modal: true, isOpen: delayElapsed ? showLoadingScreen : false, onDismiss: props.onClose, showCloseButton: false, className: "ab-LoadingScreen", style: {
+            minHeight: 'auto',
+        } },
+        React.createElement(Box, { padding: 3 },
+            React.createElement("h4", null, loadingScreenTitle !== null && loadingScreenTitle !== void 0 ? loadingScreenTitle : 'Initialising Grid'),
+            React.createElement("p", null, loadingScreenText !== null && loadingScreenText !== void 0 ? loadingScreenText : 'Retrieving your settings and setting up the grid...'))));
 }

package/src/View/CustomSort/CustomSortSummary.js

@@ -33,7 +33,7 @@ export class CustomSortSummaryComponent extends React.Component {
     }
     render() {
         const customSort = this.props.CustomSorts.find((c) => c.ColumnId == this.props.summarisedColumn.columnId);
-        const columnSortComparer = this.props.api.customSortApi.internalApi.getCustomSortComparer(this.props.summarisedColumn);
+        const columnSortComparer = this.props.api.customSortApi.internalApi.getCustomSortComparer(this.props.summarisedColumn.columnId);
         let noCustomSort = customSort == null && columnSortComparer == null;
         let customSortRow;
         if (!this.props.summarisedColumn.sortable) {

package/src/View/DataChangeHistory/DataChangeHistoryGrid.js

@@ -65,7 +65,7 @@ export const DataChangeHistoryGrid = (props) => {
         // 2. this UI will be reimplemented with Infinite Table anyway
         const addedRows = mapChangeHistoryRowData(addedChangeHistoryLogs, mainAdaptableInstance);
         const removedRows = mapChangeHistoryRowData(removedChangeHistoryLogs, mainAdaptableInstance);
-        adaptableApi.gridApi.getAgGridInstance().api.applyTransactionAsync({
+        adaptableApi.agGridApi.applyTransactionAsync({
             add: addedRows,
             remove: removedRows,
         });

package/src/View/GridFilter/GridFilterViewPanel.js

@@ -23,6 +23,7 @@ const QueryViewPanelComponent = (props) => {
     const disabled = isReadOnly || isSuspended || gridFilterAccessLevel === 'ReadOnly';
     const handleEnter = (e) => {
         if (e.key === 'Enter') {
+            e.preventDefault();
             runQuery();
         }
     };
@@ -44,8 +45,9 @@ const QueryViewPanelComponent = (props) => {
                         fontFamily: 'monospace',
                         fontSize: 12,
                         maxHeight: 52,
-                        height: 21,
-                        paddingTop: 7,
+                        height: '100%',
+                        paddingTop: 6,
+                        overflow: 'hidden',
                         zIndex: 100,
                     }, placehoder: "Grid Filter", onChange: (x) => setExpression(x.target.value), value: expression })),
             isExpressionValid && (React.createElement(ButtonPlay, { onClick: () => runQuery(), tooltip: '', accessLevel: gridFilterAccessLevel, variant: "text", tone: "neutral", disabled: disabled || expression == '' || expression == (gridFilter === null || gridFilter === void 0 ? void 0 : gridFilter.Expression), marginRight: 1 })),
@@ -71,6 +73,8 @@ const QueryViewPanelComponent = (props) => {
                         maxHeight: 60,
                         paddingTop: 7,
                         zIndex: 100,
+                        height: '100%',
+                        overflow: 'hidden',
                     }, placehoder: "Grid Filter", onChange: (x) => setExpression(x.target.value), value: expression }))));
     };
     const saveButton = (React.createElement(ButtonSave, { onClick: () => saveQuery(), tooltip: "Save as Named Query", accessLevel: namedQueryModuleAccessLevel, disabled: disabled || !isExpressionValid || isExpressionNamedQuery || expression == '', variant: "text", tone: "neutral", marginRight: 1 }));

package/src/View/GridInfo/GridInfoPopup/GridInfoPopup.js

@@ -9,8 +9,8 @@ import { AdaptableObjectCollection } from '../../Components/AdaptableObjectColle
 import { AdaptableObjectRow } from '../../Components/AdaptableObjectRow';
 import { PopupPanel } from '../../Components/Popups/AdaptablePopup/PopupPanel';
 import { AdaptableObjectsSummary } from './AdaptableObjectsSummary';
-import env from '../../../env';
-const version = env.VERSION;
+import { ADAPTABLE_VERSION } from '../../../EnvVars';
+const version = ADAPTABLE_VERSION;
 export const GridInfoPopup = (props) => {
     const CreateGridSummaries = (colItems) => {
         var _a;
@@ -39,7 +39,6 @@ export const GridInfoPopup = (props) => {
         returnRows.push(createReadOnlyColItem(colItems, 'Column Filters', columnFilterDescription));
         returnRows.push(createReadOnlyColItem(colItems, 'Grid Filter', gridFilterExpression));
         returnRows.push(createReadOnlyColItem(colItems, 'All Rows', props.api.gridApi.getRowCount()));
-        returnRows.push(createReadOnlyColItem(colItems, 'Visible Rows', props.api.gridApi.getVisibleRowCount()));
         returnRows.push(createReadOnlyColItem(colItems, 'Selected Rows', selectedRowInfo === null || selectedRowInfo === void 0 ? void 0 : selectedRowInfo.gridRows.length));
         returnRows.push(createReadOnlyColItem(colItems, 'Visible Selected Rows', selectedRowInfo === null || selectedRowInfo === void 0 ? void 0 : selectedRowInfo.gridRows.filter((gr) => { var _a; return ((_a = gr.rowNode) === null || _a === void 0 ? void 0 : _a.displayed) == true; }).length));
         returnRows.push(createReadOnlyColItem(colItems, 'All Columns', props.api.gridApi.getColumnCount()));

package/src/View/Layout/Wizard/LayoutWizard.js

@@ -34,7 +34,7 @@ export const LayoutWizard = (props) => {
         }
         if (preparedLayout.SuppressAggFuncInHeader === undefined) {
             preparedLayout.SuppressAggFuncInHeader =
-                !!adaptable.api.gridApi.getAgGridInstance().suppressAggFuncInHeader;
+                !!adaptable.agGridAdapter.initialGridOptions.suppressAggFuncInHeader;
         }
         return preparedLayout;
     });

package/src/agGrid/ActionColumnRenderer.js

@@ -32,7 +32,7 @@ const ActionButtons = (props) => {
 };
 export const ReactActionColumnRenderer = (props) => {
     const rerender = useRerender();
-    const adaptable = props.api.__adaptable;
+    const adaptable = props.context.__adaptable;
     const { actionButtons, actionColumn } = adaptable.api.internalApi.getActionButtonsAndActionColumn(props.colDef);
     if (!actionColumn || !actionButtons.length) {
         return null;
@@ -41,7 +41,7 @@ export const ReactActionColumnRenderer = (props) => {
     if (adaptable.api.gridApi.isGroupRowNode(props.node) && !actionColumn.includeGroupedRows) {
         return null;
     }
-    const pkValue = adaptable.getPrimaryKeyValueFromRowNode(props.node);
+    const pkValue = adaptable.getPrimaryKeyValueFromRowNode(props.node, props.api);
     const buttonContext = {
         actionColumn,
         primaryKeyValue: pkValue,
@@ -57,7 +57,7 @@ export const ReactActionColumnRenderer = (props) => {
 export class ActionColumnRenderer {
     // gets called once before the renderer is used
     init(params) {
-        const adaptable = params.api.__adaptable;
+        const adaptable = params.context.__adaptable;
         const { actionButtons, actionColumn } = adaptable.api.internalApi.getActionButtonsAndActionColumn(params.colDef);
         if (!actionColumn || !actionButtons.length) {
             return;
@@ -70,7 +70,7 @@ export class ActionColumnRenderer {
             this.eGui.innerHTML = '';
             return;
         }
-        const pkValue = adaptable.getPrimaryKeyValueFromRowNode(params.node);
+        const pkValue = adaptable.getPrimaryKeyValueFromRowNode(params.node, params.api);
         const buttonContext = {
             actionColumn,
             primaryKeyValue: pkValue,

package/src/agGrid/Adaptable.d.ts

@@ -1,126 +1,8 @@
-import { ChartRef, ColDef, ColGroupDef, Column, ColumnRowGroupChangedEvent, ExcelStyle, GridOptions, IRowNode, Module, ModuleNames, RowModelType } from '@ag-grid-community/core';
-import type { DebouncedFunc } from 'lodash';
-import { AdaptableNoCodeWizardOptions, IAdaptableNoCodeWizard } from '../AdaptableInterfaces/AdaptableNoCodeWizard';
-import { AdaptableVariant, AgGridConfig, DistinctValuesParams, IAdaptable } from '../AdaptableInterfaces/IAdaptable';
+import { AgGridConfig } from '../AdaptableInterfaces/IAdaptable';
 import { AdaptableOptions } from '../AdaptableOptions/AdaptableOptions';
-import { AdaptablePlugin } from '../AdaptableOptions/AdaptablePlugin';
 import { AdaptableApi } from '../Api/AdaptableApi';
-import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
-import { AdaptableStyle } from '../PredefinedConfig/Common/AdaptableStyle';
-import { ColumnSort } from '../PredefinedConfig/Common/ColumnSort';
-import { CellDataChangedInfo } from '../PredefinedConfig/Common/CellDataChangedInfo';
-import { DataUpdateConfig } from '../PredefinedConfig/Common/DataUpdateConfig';
-import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
-import { ReportData } from '../PredefinedConfig/ExportState';
-import { Layout } from '../PredefinedConfig/LayoutState';
-import { GridCell } from '../PredefinedConfig/Selection/GridCell';
-import { SelectedCellInfo } from '../PredefinedConfig/Selection/SelectedCellInfo';
-import { SelectedRowInfo } from '../PredefinedConfig/Selection/SelectedRowInfo';
-import { AdaptableTheme } from '../PredefinedConfig/ThemeState';
-import { IAdaptableStore } from '../Redux/Store/Interface/IAdaptableStore';
-import { IModuleCollection } from '../Strategy/Interface/IModule';
-import { ActionColumnContext, AdaptableButton, ChartDefinition } from '../types';
-import { EmitterCallback } from '../Utilities/Emitter';
-import { IPPStyle } from '../Utilities/Interface/IPPStyle';
-import { LicenseService } from '../Utilities/Services/LicenseService';
-import { ICalculatedColumnExpressionService } from '../Utilities/Services/Interface/ICalculatedColumnExpressionService';
-import { IDataService } from '../Utilities/Services/Interface/IDataService';
-import { IReportService } from '../Utilities/Services/Interface/IReportService';
-import { ITeamSharingService } from '../Utilities/Services/Interface/ITeamSharingService';
-import { IValidationService } from '../Utilities/Services/Interface/IValidationService';
-import { IModuleService } from '../Utilities/Services/Interface/IModuleService';
-import { IEntitlementService } from '../Utilities/Services/Interface/IEntitlementService';
-import { IQueryLanguageService } from '../Utilities/Services/Interface/IQueryLanguageService';
-import { IAlertService } from '../Utilities/Services/Interface/IAlertService';
-import { ColumnSetupInfo } from './ColumnSetupInfo';
-import { CustomSort } from '../PredefinedConfig/CustomSortState';
-import { ColumnValuesComparer } from '../AdaptableOptions/CustomSortOptions';
-import { IMetamodelService } from '../Utilities/Services/Interface/IMetamodelService';
-import { IRowEditService } from '../Utilities/Services/Interface/IRowEditService';
-import { RenderReactRootFn } from '../renderReactRoot';
-import { AdaptableLogger } from './AdaptableLogger';
-import { Fdc3Service } from '../Utilities/Services/Fdc3Service';
-import { CellPopupService } from '../Utilities/Services/CellPopupService';
-type RuntimeConfig = {
-    waitForAgGrid?: boolean;
-    /**
-     * @deprecated
-     */
-    renderReactRoot?: RenderReactRootFn;
-    variant?: AdaptableVariant;
-    gridOptions: AgGridConfig['gridOptions'];
-    modules?: AgGridConfig['modules'];
-};
-export declare class Adaptable implements IAdaptable {
-    api: AdaptableApi;
-    adaptableModules: IModuleCollection;
-    adaptableStore: IAdaptableStore;
-    adaptableOptions: AdaptableOptions;
-    _rawAdaptableOptions: AdaptableOptions;
-    logger: AdaptableLogger;
-    CalculatedColumnExpressionService: ICalculatedColumnExpressionService;
-    DataService: IDataService;
-    EntitlementService: IEntitlementService;
-    ReportService: IReportService;
-    ModuleService: IModuleService;
-    ValidationService: IValidationService;
-    QueryLanguageService: IQueryLanguageService;
-    AlertService: IAlertService;
-    TeamSharingService: ITeamSharingService;
-    MetamodelService: IMetamodelService;
-    RowEditService: IRowEditService;
-    Fdc3Service: Fdc3Service;
-    CellPopupService: CellPopupService;
-    private LicenseService;
-    private ChartingService;
-    private ThemeService;
-    embedColumnMenu: boolean;
-    gridOptions: GridOptions;
-    isInitialised: boolean;
-    hasAdaptableToolPanel: boolean;
-    variant: AdaptableVariant;
-    private useRowNodeLookUp;
-    private abContainerElement;
-    private gridContainerElement;
-    private colDefPropertyCache;
-    private gridOptionsPropertyCache;
-    private columnMinMaxValuesCache;
-    private throttleFilterOnEditDataChange;
-    private throttleFilterOnTickingDataChange;
-    private agGridHelper;
-    private agGridMenuHelper;
-    private runtimeConfig?;
-    private emitter;
-    private _currentEditor;
-    private _id;
-    private currentColumnDefs?;
-    private rowListeners;
-    private isCheckedColumnDataType;
-    private unmountReactRoot?;
-    get isLive(): boolean;
-    _on: (eventName: string, callback: EmitterCallback) => (() => void);
-    _onIncludeFired: (eventName: string, callback: EmitterCallback) => (() => void);
-    _emit: (eventName: string, data?: any) => Promise<any>;
-    _emitSync: (eventName: string, data?: any) => any;
-    private _adaptableReady;
-    isDestroyed: boolean;
-    private listenerKeydown;
-    private listenerMouseEnter;
-    private listenerMouseLeave;
-    renderReactRoot: RenderReactRootFn;
-    private listenerFirstDataRendered;
-    private listenerPivotModeChanged;
-    private listenerPivotChanged;
-    private listenerColumnRowGroupChanged;
-    private listenerCellEditingStarted;
-    private listenerColumnResized;
-    private listenerRangeSelectionChanged;
-    private listenerSortChanged;
-    private listenerModelUpdated;
-    private listenerGlobalSetRowSelection;
-    private listenerGlobalColumnEventsThatTriggerStateChange;
-    private listenerGlobalColumnEventsThatTriggerAutoLayoutSave;
-    private listenerGlobalRowGroupEventsThatTriggerAutoLayoutSave;
+import { AdaptableNoCodeWizardOptions, IAdaptableNoCodeWizard } from '../AdaptableInterfaces/AdaptableNoCodeWizard';
+export declare class Adaptable {
     /**
      * Initializer for Adaptable
      *
@@ -129,339 +11,6 @@ export declare class Adaptable implements IAdaptable {
      * @returns a Promise containing the AdaptableAPI object in order to enable run-time access to Adaptable's properties and functions
      */
     static init(adaptableOptions: AdaptableOptions, agGridConfig: AgGridConfig): Promise<AdaptableApi>;
-    /**
-     * Lazy static constructor for Adaptable
-     * Receives an AdaptableOptions object
-     * Returns a Promise containing the AdaptableAPI object in order to enable run-time access to Adaptable's properties and functions
-     * @param adaptableOptions an instance of AdaptableOptions
-     */
-    static initInternal(adaptableOptions: AdaptableOptions, runtimeConfig: RuntimeConfig): Promise<AdaptableApi>;
-    private static collectInstance;
-    static forEachAdaptable(fn: (adaptable: Adaptable) => void): void;
-    private static dismissInstance;
-    constructor();
-    init(adaptableOptions: AdaptableOptions, runtimeConfig: RuntimeConfig, _staticInit?: boolean): Promise<AdaptableApi>;
-    forPlugins(callback: (plugin: AdaptablePlugin) => any): void;
-    getPlugin(pluginId: string): AdaptablePlugin;
-    getPluginProperty(pluginId: string, propertyName: string, ...args: any): any;
-    lookupPlugins(propertyName: string, ...args: any): any;
-    isPluginLoaded: (pluginId: string) => boolean;
-    private initStore;
-    private performAudit;
-    private initializeAgGrid;
-    private isAgGridReady;
-    private initAgGridContainerFromInitializedAgGrid;
-    private createAdaptableSideBarDef;
-    private createStatusBars;
-    getAgGridStatusPanels(): import("@ag-grid-community/core").StatusPanelDef[];
-    debouncedSetColumnIntoStore: DebouncedFunc<VoidFunction>;
-    debouncedSaveGridLayout: DebouncedFunc<() => void>;
-    debouncedSetSelectedCells: DebouncedFunc<() => void>;
-    debouncedSetSelectedRows: DebouncedFunc<() => void>;
-    debouncedFilterGrid: DebouncedFunc<(callback?: any) => void>;
-    private filterOnEditDataChange;
-    private filterOnTickingDataChange;
-    applyColumnFiltering(): void;
-    applyGridFiltering(): void;
-    isGroupRowNode(rowNode: IRowNode): boolean;
-    isVisibleNode(rowNode: IRowNode): boolean;
-    isPinnedRowNode(rowNode: IRowNode): boolean;
-    clearColumnFiltering(): void;
-    clearColumnFilteringForColumns(columnIds: string[]): void;
-    hideFilterFormPopup: Function;
-    hideColumnFilterForm(): void;
-    updateColumnsIntoStore(): void;
-    private createAdaptableColumn;
-    private safeSetColDefs;
-    /**
-     * The combination of styled column and format cells
-     * This functiond decides when the two can be merged.
-     */
-    private getFormatColumnAndStyledColumnCellStyle;
-    private getStyledColumnStyle;
-    private getFormatColumnAdaptableStyle;
-    private getFormatColumnCellStyle;
-    private getFormatColumnCellClass;
-    private getActiveAlertWithHighlightCell;
-    private getActiveAlertWithHighlightRow;
-    private getAlertCellStyle;
-    private getAlertCellClass;
-    private getAlertRowClass;
-    private getAlertRowStyle;
-    private getFlashingCellStyle;
-    private getNoteCellClassName;
-    private getCommentCellClassName;
-    private getFlashingCellClass;
-    private getCellHighlightStyle;
-    private getRowHighlightStyle;
-    private getRowHighlightClass;
-    private getQuickSearchCellStyle;
-    private getEditableCellStyle;
-    private getReadOnlyCellStyle;
-    private getEditableCellClass;
-    private getReadonlyCellClass;
-    private isQuickSearchActive;
-    getPrimaryKeyValueFromRowNode(rowNode: IRowNode): any;
-    private getSortedColumnStateForVisibleColumns;
-    setColumnOrder(VisibleColumnList: string[]): void;
-    private persistLayout;
-    setLayout(layout?: Layout): void;
-    /**
-     * Setting layout works by modifing the column state.
-     * The column state is based on the current existing columns.
-     * At this point the column groups do not exist, and the widths from layout are not applied.
-     *
-     * After the col sate is applied and the column groups are created we need
-     * to apply the state again to update the widths of the group columns.
-     */
-    private applyGroupColumnWidth;
-    updateRowGroupsExpandedState(layout?: Layout): void;
-    private updateLayoutFromGrid;
-    setSelectedCells(): SelectedCellInfo | undefined;
-    setSelectedRows(): SelectedRowInfo | undefined;
-    setDataValue(value: any, column: AdaptableColumn, primaryKeyValue: any, rowNode?: IRowNode): void;
-    cancelEdit(): void;
-    isCellEditable(rowNode: IRowNode, column: Column): boolean;
-    getGridCellsForColumn(columnId: string): GridCell[] | undefined;
-    getDistinctGridCellsForColumn(column: AdaptableColumn, distinctValuesParams: DistinctValuesParams): GridCell[];
-    private getUniqueGridCells;
-    private getGridCellsForPermittedValues;
-    getDistinctValuesForColumn(column: AdaptableColumn, distinctValuesParams: DistinctValuesParams): GridCell[];
-    getDistinctFilterListValuesForColumn(column: AdaptableColumn, filter: string, distinctValuesParams: DistinctValuesParams): Promise<{
-        suppressClientSideFilter?: boolean;
-        gridCells: GridCell[];
-    }>;
-    getDistinctCustomSortValuesForColumn(column: AdaptableColumn, distinctValuesParams: DistinctValuesParams): Promise<GridCell<any>[]>;
-    getDistinctBulkUpdateValuesForColumn(column: AdaptableColumn, selectedGridCells: GridCell[], distinctValuesParams: DistinctValuesParams): Promise<GridCell<any>[]>;
-    getColumnValueDisplayValuePairList(columnId: string, visibleRowsOnly: boolean, onlyIncludeIds?: {
-        [key: string]: boolean;
-    }): GridCell[];
-    private addDistinctColumnValue;
-    /**
-     * Don't think that this is used - a good thing as its quite verbose
-     */
-    getDisplayValue(primaryKey: any, columnId: string): string | undefined;
-    getGridCellFromRowNode(rowNode: IRowNode, columnId: string): GridCell | undefined;
-    getDisplayValueFromRowNode(rowNode: IRowNode, columnId: string): string | undefined;
-    getDisplayValueFromRawValue(rowNode: IRowNode, columnId: string, rawValue: any): string | undefined;
-    private getFormattedValue;
-    getNormalisedValueFromRawValue(rawValue: any, column: AdaptableColumn): string | number | boolean | Date | unknown;
-    getRawValueFromRowNode(rowNode: IRowNode, columnId: string): any;
-    getDataRowFromRowNode(rowNode: IRowNode): any;
-    getRowNodeForPrimaryKey(primaryKeyValue: any): any;
-    getRowNodeByIndex(index: number): IRowNode;
-    getRowNodesForPrimaryKeys(primaryKeyValues: any[]): any[];
-    forAllRowNodesDo(func: (rowNode: IRowNode, rowIndex: number) => void, config?: {
-        includeGroupRows?: boolean;
-        filterFn?: (rowNode: IRowNode) => boolean;
-    }): void;
-    forAllVisibleRowNodesDo(func: (rowNode: IRowNode, rowIndex: number) => void, config?: {
-        includeGroupRows?: boolean;
-        filterFn?: (rowNode: IRowNode) => boolean;
-    }): void;
-    getVisibleRowNodes(config?: {
-        includeGroupRows?: boolean;
-        filterFn?: (rowNode: IRowNode) => boolean;
-    }): IRowNode[];
-    getAllRowNodes(config?: {
-        includeGroupRows?: boolean;
-        filterFn?: (rowNode: IRowNode) => boolean;
-    }): IRowNode[];
-    getGroupRowNodes(config?: {
-        filterFn?: (rowNode: IRowNode) => boolean;
-    }): IRowNode[];
-    getRowsInViewport(): IRowNode[];
-    selectNodes(rowNodes: IRowNode[], clearSelection: boolean): void;
-    deSelectNodes(rowNodes: IRowNode[], clearSelection: boolean): void;
-    selectNode(rowNode: IRowNode, clearSelection: boolean): void;
-    deSelectNode(rowNode: IRowNode, clearSelection: boolean): void;
-    selectCells(columnIds: string[], startNode: IRowNode, endNode: IRowNode, clearSelection?: boolean): void;
-    isRowNodeVisible(rowNode: IRowNode): boolean;
-    redrawBody(): void;
-    redrawRenderedRows(): void;
-    redrawHeader(): void;
-    redrawRow(rowNode: IRowNode): void;
-    redrawRows(rowNodes: IRowNode[]): void;
-    refreshCells(rowNodes: IRowNode[], columns: (string | Column)[], forceUpdate: boolean, suppressFlash?: boolean): void;
-    refreshColumns(columns: (string | Column)[], forceUpdate: boolean, suppressFlash?: boolean): void;
-    jumpToRow(rowNode: IRowNode): void;
-    jumpToColumn(columnId: string): void;
-    jumpToCell(columnId: string, rowNode: IRowNode): void;
-    /**
-     * This creates a clone of the current column definitions. If config.removeEmpty is true, will also remove empty column groups
-     *
-     */
-    private mapColumnDefs;
-    private getColDefsForSpecialColumns;
-    getColDefsForFreeTextColumns(): ColDef<any, any>[];
-    setupColumnValueGetter({ col }: ColumnSetupInfo): void;
-    getActionRowButtonDefs(): AdaptableButton<ActionColumnContext<any>>[];
-    private getColDefsForActionRowColumns;
-    getColDefsForActionColumns(): ColDef<any, any>[];
-    updateColDefsForSpecialColumns(): void;
-    private getColDefsForCalculatedColumns;
-    private isRegularColDef;
-    private isGroupColDef;
-    getGroupAndColumnDefs: () => (ColDef | ColGroupDef)[];
-    getColDefs(): ColDef[];
-    getGroupedColDefs(): ColDef[];
-    getColumnDefsWithCorrectVisibility: () => ColDef[];
-    getFirstRowNode(): IRowNode | undefined;
-    getFirstDisplayedRowNode(): IRowNode;
-    destroy(config?: {
-        unmount: boolean;
-        destroyApi?: boolean;
-    }): void;
-    getDefaultIPPStyle(): IPPStyle;
-    getCurrentIPPStyle(): IPPStyle;
-    getAdaptableContainerElement(): HTMLElement | null;
-    getAgGridContainerElement(): HTMLElement | null;
-    private initInternalGridLogic;
-    private updateColumnFilterActiveState;
-    buildStandaloneColumnHeader(adaptableColumn: AdaptableColumn): AdaptableMenuItem[];
-    prepareGrid(): void;
-    setupColumns(): void;
-    revertGridOptionsPropertiesToUserValue<T extends keyof GridOptions>(propertyNames: T[]): void;
-    setGridOptionsProperty<T extends keyof GridOptions>(propertyName: T, propertyGetter: (userPropertyValue: GridOptions[T]) => GridOptions[T] | undefined): void;
-    setColDefProperty<T extends keyof ColDef>(col: Column, propertyName: T, propertyGetter: (userPropertyValue: ColDef[T]) => ColDef[T] | undefined): void;
-    private getUserColDefProperty;
-    setupColumnCellStyle({ col, colId, abColumn }: ColumnSetupInfo): void;
-    setupColumnCellClass({ col, colId, abColumn }: ColumnSetupInfo): void;
-    getExcelClassNameForCell(colId: string, primaryKeyValue: any, userDefinedCellClass?: string | string[]): string;
-    setupColumnCellEditor({ colId, col }: ColumnSetupInfo): void;
-    setupColumnCellRenderer({ col, colId, abColumn }: ColumnSetupInfo): void;
-    setupColumnTooltipValueGetter({ col, colId, abColumn }: ColumnSetupInfo): void;
-    setupColumnQuickFilerText({ col, abColumn }: ColumnSetupInfo): void;
-    setupAllowedAggFuncs({ col, abColumn }: ColumnSetupInfo): void;
-    triggerSetupColumnKeyCreator(colId: string): void;
-    setupColumnKeyCreator(columnSetupInfo: ColumnSetupInfo): void;
-    setupColumnCellDataType(columnSetupInfo: ColumnSetupInfo): void;
-    setupColumnHeader({ col, abColumn }: ColumnSetupInfo): boolean;
-    setupColumnFilter({ col, colDef }: ColumnSetupInfo): void;
-    setupColumnFloatingFilter({ col, colDef }: ColumnSetupInfo): void;
-    setupColumnValueFormatter({ col, abColumn }: ColumnSetupInfo): void;
-    setupColumnEditable({ col }: ColumnSetupInfo): void;
-    setupColumnValueSetter({ col, colId, abColumn }: ColumnSetupInfo): void;
-    setupColumnComparator({ col, colId, abColumn }: ColumnSetupInfo): void;
-    private applyCurrentTheme;
-    private applyFinalRendering;
-    isAgGridModulePresent(moduleName: ModuleNames): boolean;
-    private getAllAgGridRegisteredModules;
-    getAgGridRegisteredModules(): Module[];
-    private getAgGridRegisteredModuleNames;
-    private onRowDataChanged;
-    private onCellDataChanged;
-    private isUndoChange;
-    /**
-     * There are a few things that we need to do AFTER we edit a cell and it makes sense to put them in one place
-     */
-    private performPostEditChecks;
-    private refreshCellsBasedOnCellDataChange;
-    private getFormatColumnExpressionStylesChanges;
-    private getFormatColumnPredicateStyleChanges;
-    private getStyledColumnComparisonChanges;
-    private checkChangedCellCurrentlySelected;
-    refreshColumnForRelativeRangeStyledColumns(cellDataChangedInfos: CellDataChangedInfo[]): void;
-    private getColumnSorts;
-    private onSortChanged;
-    expandAllRowGroups(): void;
-    closeAllRowGroups(): void;
-    expandRowGroupsForValues(columnValues: any[]): void;
-    getAgGridColumnForColumnId(columnId: string): Column;
-    getAgGridAllGridColumns(): Column<any>[];
-    setRowGroupColumns(columnIds: string[]): void;
-    clearRowGroupColumns(): void;
-    getExpandRowGroupsKeys(): any[];
-    getRowCount(): number;
-    getColumnCount(): number;
-    getVisibleRowCount(): number;
-    getVisibleColumnCount(): number;
-    selectColumns(columnIds: string[], config?: {
-        keepExistingSelection?: boolean;
-    }): void;
-    selectColumn(columnId: string, config?: {
-        keepExistingSelection?: boolean;
-    }): void;
-    selectAll(): void;
-    deselectAll(): void;
-    hideColumn(columnId: string): void;
-    showColumn(columnId: string): void;
-    autoSizeColumn(columnId: string): void;
-    autoSizeColumns(columnIds: string[]): void;
-    autoSizeAllColumns(): void;
-    setColumnSort(columnSorts: ColumnSort[]): void;
-    clearColumnSort(): void;
-    setGridData(dataSource: any[]): void;
-    getGridData(): any[];
-    getFilteredData(): any[];
-    updateRows(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
-    addRows(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
-    addOrUpdateRows(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<{
-        added: IRowNode[];
-        updated: IRowNode[];
-    }>;
-    deleteRows(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
-    getFirstGroupedColumn(): AdaptableColumn | undefined;
-    private checkColumnsDataTypeSet;
-    private updateColumnDataTypeIfRowDataIsEmpty;
-    private runAdaptableComparerFunction;
-    isGridSelectable(): boolean;
-    isGridRangeSelectable(): boolean;
-    isGridGroupable(): boolean;
-    isGridGroupingActive(): boolean;
-    isGridPivotable(): boolean;
-    isQuickFilterAvailable(): boolean;
-    setAgGridQuickSearch(searchText: string): void;
-    private hasFloatingFilterOnAtLeastOneColumn;
-    showQuickFilter(): void;
-    hideQuickFilter(): void;
-    getAgGridColumnType(columnId: string): string | string[];
-    getActiveColumnComparator(columnId: string, customSort?: CustomSort, customSortComparer?: ColumnValuesComparer): (valueA: any, valueB: any, nodeA?: IRowNode, nodeB?: IRowNode, isInverted?: boolean) => number | undefined;
-    getAgGridLightThemeName(): string;
-    getAgGridCurrentThemeName(): string;
-    applyAdaptableTheme(theme: AdaptableTheme | string): void;
-    private setupRowStyling;
-    private setupColumnHeaderAggregations;
-    private getGridOptionsApi;
-    canGenerateCharts(): boolean;
-    canDisplaySparklines(): boolean;
-    canExportToExcel(): boolean;
-    exportToExcel(reportData: ReportData, fileName: string): void;
-    private setExcelStylesForExport;
-    exportVisualDataToExcel(): void;
-    convertAdaptableStyleToCSS(style: AdaptableStyle): {
-        [cssProperty: string]: string;
-    };
-    convertCSSToExcelStyle(style: CSSStyleDeclaration): Partial<ExcelStyle>;
-    private processCellForExcelExport;
-    private processRowGroupForExcelExport;
-    private hasAutogeneratedPrimaryKey;
-    private addSyntheticPrimaryKey;
-    private addSyntheticPrimaryKeyIfMissing;
-    initLicenseService(): LicenseService;
-    showCharts(chartsDefinitions: ChartDefinition[], chartContainer?: HTMLElement): ChartRef[];
-    showChart(chartDefinition: ChartDefinition, container?: HTMLElement): ChartRef;
-    updateChart(chart: ChartDefinition): void;
-    getChartRef(chartId: string): ChartRef;
-    getChartModels(): import("@ag-grid-community/core").ChartModel[];
-    getAgGridRowModelType(): RowModelType;
-    private getActiveAdaptableAggFuncForCol;
-    private registerAdaptableAggFuncs;
-    /**
-     * When reading the state from the grid, we have to make sure 'avg' is not overriden with the 'avg' string.
-     */
-    private mapAggregationColumnsFromGrid;
-    resetMinMaxCachedValueForColumn(column: AdaptableColumn): void;
-    getMinMaxCachedValueForColumn(column: AdaptableColumn, minMax: 'min' | 'max'): number;
-    persistColumnIndexBeforeGrouping(params: ColumnRowGroupChangedEvent): void;
-    /**
-     * Restores the order previous grouping order.
-  
-     */
-    restoreUnGroupColumnOrder({ newGroupColumns, columnOrder, }: {
-        newGroupColumns: string[];
-        columnOrder: string[];
-    }): string[];
 }
 export declare class AdaptableNoCodeWizard implements IAdaptableNoCodeWizard {
     private init;
@@ -474,4 +23,3 @@ export declare class AdaptableNoCodeWizard implements IAdaptableNoCodeWizard {
     constructor(adaptableOptions: AdaptableOptions, extraOptions?: AdaptableNoCodeWizardOptions, agGridOptons?: AgGridConfig);
     render(container?: HTMLElement | null): void;
 }
-export {};