@adaptabletools/adaptable 11.1.1-canary.0 → 11.1.1

package/src/Strategy/FlashingCellModule.js

@@ -17,8 +17,10 @@ const getFlashingTargetViewItems_1 = require("./Utilities/getFlashingTargetViewI
 class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.FlashingCellModuleId, 'Flashing Cell', 'flashing-cell', 'FlashingAlert', 'Flash cells when they change', api);
-        this.api.internalApi.getDataService().on('DataChanged', (dataChangedInfo) => {
-            if (dataChangedInfo.trigger === 'undo') {
+        this.api.internalApi
+            .getDataService()
+            .on('CellDataChanged', (cellDataChangedInfo) => {
+            if (cellDataChangedInfo.trigger === 'undo') {
                 // do NOT handle reverted changes
                 return;
             }
@@ -26,8 +28,8 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             // - flash for the underlying small data changes, but the visual does not
             if (this.api.internalApi.getAdaptableOptions().alertOptions.dataChangeDetectionPolicy ===
                 'formattedValue') {
-                const { oldValue, newValue } = dataChangedInfo;
-                const columnId = dataChangedInfo.column.columnId;
+                const { oldValue, newValue } = cellDataChangedInfo;
+                const columnId = cellDataChangedInfo.column.columnId;
                 const oldFormattedValue = this.api.gridApi.getFormattedValueFromRawValue(columnId, oldValue);
                 const newFormattedValue = this.api.gridApi.getFormattedValueFromRawValue(columnId, newValue);
                 if (oldFormattedValue === newFormattedValue) {
@@ -35,7 +37,7 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                     return;
                 }
             }
-            this.handleDataSourceChanged(dataChangedInfo);
+            this.handleDataSourceChanged(cellDataChangedInfo);
         });
     }
     getModuleAdaptableObjects() {
@@ -101,23 +103,27 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         }
         return items;
     }
-    handleDataSourceChanged(dataChangedInfo) {
-        const flashingCellDefinitions = this.getFlashingCellDefinitionsForDataChange(dataChangedInfo);
+    handleDataSourceChanged(cellDataChangedInfo) {
+        const flashingCellDefinitions = this.getFlashingCellDefinitionsForDataChange(cellDataChangedInfo);
         if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(flashingCellDefinitions)) {
-            this.showFlashingCellsForDefinitions(dataChangedInfo, flashingCellDefinitions);
+            this.showFlashingCellsForDefinitions(cellDataChangedInfo, flashingCellDefinitions);
         }
     }
-    showFlashingCellsForDefinitions(dataChangedInfo, flashingCellDefinitions = []) {
+    showFlashingCellsForDefinitions(cellDataChangedInfo, flashingCellDefinitions = []) {
         const allColumnIds = this.api.columnApi.getColumns().map((c) => c.columnId);
-        const columnDataType = dataChangedInfo.column.dataType;
+        const columnDataType = cellDataChangedInfo.column.dataType;
         const numeric = columnDataType === 'Number';
         const isComparableType = numeric || columnDataType === 'Date';
         let up = false;
         let down = false;
         let direction = 'neutral';
         if (isComparableType) {
-            const newValue = numeric ? Number(dataChangedInfo.newValue) : dataChangedInfo.newValue;
-            const oldValue = numeric ? Number(dataChangedInfo.oldValue) : dataChangedInfo.oldValue;
+            const newValue = numeric
+                ? Number(cellDataChangedInfo.newValue)
+                : cellDataChangedInfo.newValue;
+            const oldValue = numeric
+                ? Number(cellDataChangedInfo.oldValue)
+                : cellDataChangedInfo.oldValue;
             up = newValue > oldValue;
             down = newValue < oldValue;
             direction = up ? 'up' : down ? 'down' : 'neutral';
@@ -125,7 +131,7 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         flashingCellDefinitions.forEach((flashingCellDefinition) => {
             var _a;
             let flashTarget = this.api.flashingCellApi.getFlashingCellFlashTarget(flashingCellDefinition);
-            const flashColumnIds = { [dataChangedInfo.column.columnId]: true };
+            const flashColumnIds = { [cellDataChangedInfo.column.columnId]: true };
             /**
              * When flashing a row, all columns in that row are marked to flash.
              */
@@ -134,11 +140,11 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                     flashColumnIds[colId] = true;
                 });
             }
-            const rowPrimaryKey = dataChangedInfo.primaryKeyValue;
+            const rowPrimaryKey = cellDataChangedInfo.primaryKeyValue;
             this.api.flashingCellApi.showFlashingCell({
                 rowPrimaryKey,
                 flashingCellDefinition: flashingCellDefinition,
-                dataChangedInfo,
+                cellDataChangedInfo: cellDataChangedInfo,
                 direction,
                 flashTarget,
                 flashColumnIds,

package/src/Strategy/FormatColumnModule.js

@@ -19,7 +19,9 @@ class FormatColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
          * Use Case: Data (cell/row) has changed
          * Action: Any CheckboxFormatColumns need to be updated, as their disabled state may have changed
          */
-        this.api.internalApi.getDataService().on('DataChanged', (dataChangedInfo) => {
+        this.api.internalApi
+            .getDataService()
+            .on('CellDataChanged', (cellDataChangedInfo) => {
             const activeCheckboxColumnIds = this.api.columnApi
                 .getColumns()
                 .filter((aColumn) => {
@@ -28,7 +30,7 @@ class FormatColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             })
                 .map((aColumn) => aColumn.columnId);
             // no need to refresh the CheckboxColumns if the change was triggered by one of them
-            if (!activeCheckboxColumnIds.includes(dataChangedInfo.column.columnId)) {
+            if (!activeCheckboxColumnIds.includes(cellDataChangedInfo.column.columnId)) {
                 this.api.internalApi
                     .getAdaptableInstance()
                     .refreshCells(null, activeCheckboxColumnIds, true, true);

package/src/Utilities/Constants/DocumentationLinkConstants.js

@@ -11,4 +11,4 @@ exports.AggregatedBooleanQueryDocsLink = `${exports.HOST_URL_DOCS}/guide/adaptab
 exports.AggregatedScalarQueryDocsLink = `${exports.HOST_URL_DOCS}/guide/adaptable-ql-expression-aggregation#aggregated-scalar-expressions`;
 exports.PredicateDocsLink = `${exports.HOST_URL_DOCS}/guide/adaptable-ql-predicate`;
 exports.PrimaryKeyDocsLink = `${exports.HOST_URL_DOCS}/guide/dev-guide-tutorial-primary-key`;
-exports.LicenseDocsLink = `${exports.HOST_URL_DOCS}/licensing`;
+exports.LicenseDocsLink = `${exports.HOST_URL_DOCS}/guide/licensing`;

package/src/Utilities/Emitter.d.ts

@@ -7,7 +7,7 @@ declare class Emittery {
     on(eventName: string, listener: EmitterCallback): any;
     off(eventName: string, listener: EmitterCallback): void;
     once(eventName: string): Promise<unknown>;
-    onIncludeFiredOnce(eventName: string, listener: EmitterCallback): any;
+    onIncludeFiredOnce(eventName: string): Promise<any>;
     onIncludeFired(eventName: string, listener: EmitterCallback): any;
     emit(eventName: string, eventData?: any): Promise<any[]>;
     emitSync(eventName: string, eventData?: any): any[];

package/src/Utilities/Emitter.js

@@ -100,16 +100,13 @@ class Emittery {
             });
         });
     }
-    onIncludeFiredOnce(eventName, listener) {
+    onIncludeFiredOnce(eventName) {
         const triggeredEventsMap = triggeredMap.get(this);
         const eventInfo = triggeredEventsMap.get(eventName);
         if (eventInfo) {
-            listener(eventInfo.data);
-            return () => { };
-        }
-        else {
-            return this.on(eventName, listener);
+            return Promise.resolve(eventInfo.data);
         }
+        return this.once(eventName);
     }
     onIncludeFired(eventName, listener) {
         const triggeredEventsMap = triggeredMap.get(this);

package/src/Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions.d.ts

@@ -1,5 +1,5 @@
 import { ExpressionFunction } from '../../parser/src/types';
-declare type AggregationFunctionName = 'WHERE' | 'COL' | AggregationFunction | ComparisonFunction;
+export declare type AggregationFunctionName = 'WHERE' | 'COL' | AggregationFunction | ComparisonFunction;
 declare type AggregationFunction = 'SUM';
 declare type ComparisonFunction = 'EQ' | 'NEQ' | 'LT' | 'GT' | 'LTE' | 'GTE';
 export declare const aggregatedBooleanExpressionFunctions: Record<AggregationFunctionName, ExpressionFunction>;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.d.ts

@@ -1,7 +1,7 @@
 import { ExpressionContext } from '../../parser/src/types';
 import { AdaptableApi } from '../../Api/AdaptableApi';
 import { Observable } from 'rxjs';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 export interface BaseParameter<T = string, N = string> {
     type: T;
     name: N;
@@ -12,7 +12,7 @@ export interface ColumnParameter extends BaseParameter<'config', 'COL'> {
 export declare const getStringValues: (context: ExpressionContext, ...stringArguments: string[]) => string[];
 export declare const getStringValue: (context: ExpressionContext, stringArgument: string) => string;
 export declare const isTextSearchCaseInsensitive: (context: ExpressionContext) => boolean;
-export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<DataChangedInfo>;
+export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<CellDataChangedInfo>;
 export declare const handleWhereFunction: (args: any[], context: ExpressionContext) => any;
 export declare const extractColumnParameter: (consumingFunctionName: string, args: BaseParameter[]) => ColumnParameter;
 export declare const extractParameter: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T["type"], allowedOperands: T["name"][], args: BaseParameter[], isOptional?: boolean) => T;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -18,7 +18,7 @@ exports.getStringValue = (context, stringArgument) => {
     return exports.isTextSearchCaseInsensitive(context) ? stringArgument.toLowerCase() : stringArgument;
 };
 exports.isTextSearchCaseInsensitive = (context) => !context.api.internalApi.isTextComparisonCaseSensitive();
-// returns an observable which filters the source$ emissions and emits only if the DataChangedInfo relates to the given column
+// returns an observable which filters the source$ emissions and emits only if the CellDataChangedInfo relates to the given column
 // optionally, if a filter function (where clause) is provided, it is also evaluated
 exports.getDataChangeLog$ = (context, columnNameFilter) => {
     let dataChangeLog$ = context.api.internalApi.getDataService().dataChangeLog$;

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.d.ts

@@ -1,5 +1,5 @@
 import { ExpressionFunction } from '../../parser/src/types';
-declare type ObservableFunctionName = 'WHERE' | 'COL' | 'TIMEFRAME' | ObservableFunction | ChangeFunction;
+export declare type ObservableFunctionName = 'WHERE' | 'COL' | 'TIMEFRAME' | ObservableFunction | ChangeFunction;
 declare type ObservableFunction = 'ROW_CHANGE' | 'GRID_CHANGE';
 declare type ChangeFunction = 'MAX' | 'MIN' | 'NONE' | 'COUNT';
 export declare const observableExpressionFunctions: Record<ObservableFunctionName, ExpressionFunction>;

package/src/Utilities/ObjectFactory.d.ts

@@ -13,7 +13,7 @@ import { ConditionalStyle } from '../PredefinedConfig/ConditionalStyleState';
 import { FormatColumn } from '../PredefinedConfig/FormatColumnState';
 import { FreeTextColumn } from '../PredefinedConfig/FreeTextColumnState';
 import { AdaptableStyle } from '../PredefinedConfig/Common/AdaptableStyle';
-import { DataChangedInfo } from '../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../PredefinedConfig/Common/CellDataChangedInfo';
 import { Glue42Report, Glue42Schedule } from '../PredefinedConfig/Glue42State';
 import { IPushPullReport } from '../PredefinedConfig/SystemState';
 import { IPushPullSchedule } from '../PredefinedConfig/IPushPullState';
@@ -34,7 +34,7 @@ export declare function CreateEmptyCalculatedColumn(isFilterable: boolean): Calc
 export declare function CreateEmptyNamedQuery(expression?: string): NamedQuery;
 export declare function CreateEmptyPlusMinusNudge(): PlusMinusNudge;
 export declare function CreateGenericAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition): AdaptableGenericAlert;
-export declare function CreateCellChangedAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition, dataChangedInfo: DataChangedInfo): AdaptableCellChangedAlert;
+export declare function CreateCellChangedAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition, cellDataChangedInfo: CellDataChangedInfo): AdaptableCellChangedAlert;
 export declare function CreateRowChangedAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition, gridDataChange: GridDataChangedInfo): AdaptableRowChangedAlert;
 export declare function CreateEmptyAlertDefinition(): AlertDefinition;
 export declare function CreateEmptyFlashingCellDefinition(): FlashingCellDefinition;

package/src/Utilities/ObjectFactory.js

@@ -61,14 +61,14 @@ function CreateGenericAlert(alertHeader, alertMessage, alertDefinition) {
     };
 }
 exports.CreateGenericAlert = CreateGenericAlert;
-function CreateCellChangedAlert(alertHeader, alertMessage, alertDefinition, dataChangedInfo) {
+function CreateCellChangedAlert(alertHeader, alertMessage, alertDefinition, cellDataChangedInfo) {
     return {
         alertType: 'cellChanged',
         Uuid: Uuid_1.createUuid(),
         header: alertHeader,
         message: alertMessage,
         alertDefinition,
-        dataChangedInfo,
+        cellDataChangedInfo: cellDataChangedInfo,
     };
 }
 exports.CreateCellChangedAlert = CreateCellChangedAlert;

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -12,8 +12,8 @@ class CalculatedColumnExpressionService {
         this.adaptable = adaptable;
         this.adaptable.api.internalApi
             .getDataService()
-            .on('DataChanged', (dataChangedInfo) => {
-            if (dataChangedInfo.trigger === 'aggChange') {
+            .on('CellDataChanged', (cellDataChangedInfo) => {
+            if (cellDataChangedInfo.trigger === 'aggChange') {
                 // do NOT handle changes on group rows
                 return;
             }
@@ -21,7 +21,7 @@ class CalculatedColumnExpressionService {
             this.aggregatedScalarCalculatedColumnsMap.forEach((aggregatedScalarCalculatedColumn) => {
                 if (aggregatedScalarCalculatedColumn
                     .getColumnDependencies()
-                    .includes(dataChangedInfo.column.columnId)) {
+                    .includes(cellDataChangedInfo.column.columnId)) {
                     aggregatedScalarCalculatedColumn.refreshAggregatedColumnValue();
                     refreshedCalculatedColumns.push(aggregatedScalarCalculatedColumn.getCalculatedColumnId());
                 }

package/src/Utilities/Services/DataService.d.ts

@@ -1,21 +1,21 @@
 import { IDataService } from './Interface/IDataService';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { EmitterCallback } from '../../Utilities/Emitter';
 import { Observable } from 'rxjs';
 export declare class DataService implements IDataService {
     private adaptable;
     private emitter;
     private readonly dataChangeLogSubject$;
-    dataChangeLog$: Observable<DataChangedInfo>;
+    dataChangeLog$: Observable<CellDataChangedInfo>;
     private undoChangeLog;
     private undoChangeTimers;
     constructor(adaptable: IAdaptable);
     on: (eventName: string, callback: EmitterCallback) => (() => void);
     emit: (eventName: string, data?: any) => Promise<any>;
-    CreateDataChangedEvent(dataChangedInfo: DataChangedInfo): void;
-    logUndoChange(change: DataChangedInfo): void;
-    extractUndoChange(change: DataChangedInfo): DataChangedInfo | undefined;
+    CreateDataChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
+    logUndoChange(change: CellDataChangedInfo): void;
+    extractUndoChange(change: CellDataChangedInfo): CellDataChangedInfo | undefined;
     destroy(): void;
     private getUndoChangeKey;
     private logDataChange;

package/src/Utilities/Services/DataService.js

@@ -20,11 +20,11 @@ class DataService {
         this.undoChangeLog = new Map();
         this.undoChangeTimers = new Map();
     }
-    CreateDataChangedEvent(dataChangedInfo) {
-        if (dataChangedInfo.newValue != dataChangedInfo.oldValue) {
-            this.emitter.emitSync('DataChanged', dataChangedInfo);
-            this.adaptable.api.gridApi.fireCellChangedEvent(dataChangedInfo);
-            this.logDataChange(dataChangedInfo);
+    CreateDataChangedEvent(cellDataChangedInfo) {
+        if (cellDataChangedInfo.newValue != cellDataChangedInfo.oldValue) {
+            this.emitter.emitSync('CellDataChanged', cellDataChangedInfo);
+            this.adaptable.api.gridApi.fireCellChangedEvent(cellDataChangedInfo);
+            this.logDataChange(cellDataChangedInfo);
         }
     }
     // we need this temporary "shared memory" because the value change and the AG Grid cellChanged event are asynchronous
@@ -69,16 +69,18 @@ class DataService {
             newValue,
         });
     }
-    logDataChange(dataChangedInfo) {
-        const dataChangeLogEntry = this.extractDataChangeLogEntry(dataChangedInfo);
+    logDataChange(cellDataChangedInfo) {
+        const dataChangeLogEntry = this.extractDataChangeLogEntry(cellDataChangedInfo);
         this.dataChangeLogSubject$.next(dataChangeLogEntry);
     }
-    extractDataChangeLogEntry(dataChangedInfo) {
+    extractDataChangeLogEntry(cellDataChangedInfo) {
         // create rowData snapshot
-        const rowData = dataChangedInfo.rowData ? Helper_1.default.cloneObject(dataChangedInfo.rowData) : null;
+        const rowData = cellDataChangedInfo.rowData
+            ? Helper_1.default.cloneObject(cellDataChangedInfo.rowData)
+            : null;
         // strip down rowNode properties as it is pretty "heavy" on the memory
         const rowNode = rowData ? { data: rowData } : null;
-        return Object.assign(Object.assign({}, dataChangedInfo), { rowNode,
+        return Object.assign(Object.assign({}, cellDataChangedInfo), { rowNode,
             rowData });
     }
 }

package/src/Utilities/Services/Interface/IAlertService.d.ts

@@ -1,10 +1,10 @@
 import { AlertDefinition } from '../../../PredefinedConfig/AlertState';
-import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
 import { IAdaptableService } from './IAdaptableService';
 export declare type ReactiveAlertInfo = {
     alertDefinition: AlertDefinition;
     type: 'alert';
-    dataChangeLogEntry: DataChangedInfo;
+    dataChangeLogEntry: CellDataChangedInfo;
 };
 export interface IAlertService extends IAdaptableService {
     createReactiveAlert(alertDefinition: AlertDefinition): void;

package/src/Utilities/Services/Interface/IDataService.d.ts

@@ -1,10 +1,10 @@
-import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
 import { Observable } from 'rxjs';
 import { IAdaptableService } from './IAdaptableService';
 export interface IDataService extends IAdaptableService {
-    CreateDataChangedEvent(dataChangedInfo: DataChangedInfo): void;
-    on(eventName: 'DataChanged', callback: (dataChangedInfo: DataChangedInfo) => void): () => void;
-    readonly dataChangeLog$: Observable<DataChangedInfo>;
-    logUndoChange(undoChange: DataChangedInfo): void;
-    extractUndoChange(undoChange: DataChangedInfo): DataChangedInfo | undefined;
+    CreateDataChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
+    on(eventName: 'CellDataChanged', callback: (cellDataChangedInfo: CellDataChangedInfo) => void): () => void;
+    readonly dataChangeLog$: Observable<CellDataChangedInfo>;
+    logUndoChange(undoChange: CellDataChangedInfo): void;
+    extractUndoChange(undoChange: CellDataChangedInfo): CellDataChangedInfo | undefined;
 }

package/src/Utilities/Services/Interface/IQueryLanguageService.d.ts

@@ -1,15 +1,15 @@
 import { Observable } from 'rxjs';
 import { IAdaptableService } from './IAdaptableService';
 import { RowNode } from '@ag-grid-community/all-modules';
-import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
 import { AdaptableModule } from '../../../PredefinedConfig/Common/Types';
 import { AggregationParameter } from '../../ExpressionFunctions/aggregatedScalarExpressionFunctions';
 import { ModuleExpressionFunctions } from '../../../AdaptableOptions/AdaptableQLOptions';
 export interface IQueryLanguageService extends IAdaptableService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: RowNode): boolean;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: RowNode): any;
-    evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<DataChangedInfo>;
-    evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): Observable<DataChangedInfo>;
+    evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
+    evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
     evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): AggregationParameter;
     validateBoolean(expression: string, module: AdaptableModule, config?: {
         force?: boolean;

package/src/Utilities/Services/Interface/IValidationService.d.ts

@@ -1,10 +1,10 @@
-import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
 import { AlertDefinition } from '../../../PredefinedConfig/AlertState';
 import { IAdaptableService } from './IAdaptableService';
 export interface IValidationService extends IAdaptableService {
-    getValidationRulesForDataChange(dataChangedInfo: DataChangedInfo): AlertDefinition[];
-    performValidation(dataChangedInfo: DataChangedInfo): boolean;
-    performServerValidation(dataChangedInfo: DataChangedInfo, config: {
+    getValidationRulesForDataChange(cellDataChangedInfo: CellDataChangedInfo): AlertDefinition[];
+    performValidation(cellDataChangedInfo: CellDataChangedInfo): boolean;
+    performServerValidation(cellDataChangedInfo: CellDataChangedInfo, config: {
         onServerValidationCompleted: () => void;
     }): () => boolean;
     createValidationDescription(alertDefinition: AlertDefinition): string;

package/src/Utilities/Services/QueryLanguageService.d.ts

@@ -1,7 +1,7 @@
 import { IQueryLanguageService } from './Interface/IQueryLanguageService';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { Observable } from 'rxjs';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { RowNode } from '@ag-grid-community/all-modules';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { ModuleExpressionFunctions } from '../../AdaptableOptions/AdaptableQLOptions';
@@ -17,8 +17,8 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: RowNode): any;
     evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): AggregationParameter;
-    evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
-    evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
+    evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
+    evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
     validateBoolean(expressionInput: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {

package/src/Utilities/Services/ValidationService.d.ts

@@ -1,14 +1,14 @@
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { IValidationService } from './Interface/IValidationService';
 import { AlertDefinition } from '../../PredefinedConfig/AlertState';
 export declare class ValidationService implements IValidationService {
     private adaptable;
     constructor(adaptable: IAdaptable);
-    getValidationRulesForDataChange(dataChangedInfo: DataChangedInfo): AlertDefinition[];
-    performValidation(dataChangedInfo: DataChangedInfo): boolean;
+    getValidationRulesForDataChange(cellDataChangedInfo: CellDataChangedInfo): AlertDefinition[];
+    performValidation(cellDataChangedInfo: CellDataChangedInfo): boolean;
     private IsAlertDefinitionTriggered;
-    performServerValidation(dataChangedInfo: DataChangedInfo, config: {
+    performServerValidation(cellDataChangedInfo: CellDataChangedInfo, config: {
         onServerValidationCompleted: () => void;
     }): () => boolean;
     createValidationDescription(alertDefinition: AlertDefinition): string;

package/src/Utilities/Services/ValidationService.js

@@ -11,28 +11,28 @@ class ValidationService {
         this.adaptable = adaptable;
     }
     // Not sure where to put this: was in the Module but might be better here until I can work out a way of having an event with a callback...
-    getValidationRulesForDataChange(dataChangedInfo) {
+    getValidationRulesForDataChange(cellDataChangedInfo) {
         // if the new value is the same as the old value then we can get out as we dont see it as an edit?
-        if (dataChangedInfo.oldValue == dataChangedInfo.newValue) {
+        if (cellDataChangedInfo.oldValue == cellDataChangedInfo.newValue) {
             return [];
         }
         let editingRules = this.adaptable.api.alertApi
             .getAlertDefinitionsWithPreventEdit()
-            .filter((v) => this.adaptable.api.scopeApi.isColumnInScope(dataChangedInfo.column, v.Scope));
+            .filter((v) => this.adaptable.api.scopeApi.isColumnInScope(cellDataChangedInfo.column, v.Scope));
         let failedValidations = [];
         if (ArrayExtensions_1.ArrayExtensions.IsNotEmpty(editingRules)) {
             editingRules.forEach((alertDefinition) => {
                 if (alertDefinition.Rule.BooleanExpression) {
-                    let isSatisfiedExpression = dataChangedInfo.rowNode != null &&
+                    let isSatisfiedExpression = cellDataChangedInfo.rowNode != null &&
                         this.adaptable.api.internalApi
                             .getQueryLanguageService()
-                            .evaluateBooleanExpression(alertDefinition.Rule.BooleanExpression, ModuleConstants_1.AlertModuleId, dataChangedInfo.rowNode);
+                            .evaluateBooleanExpression(alertDefinition.Rule.BooleanExpression, ModuleConstants_1.AlertModuleId, cellDataChangedInfo.rowNode);
                     if (isSatisfiedExpression) {
                         failedValidations.push(alertDefinition);
                     }
                 }
                 else {
-                    if (this.IsAlertDefinitionTriggered(alertDefinition, dataChangedInfo)) {
+                    if (this.IsAlertDefinitionTriggered(alertDefinition, cellDataChangedInfo)) {
                         failedValidations.push(alertDefinition);
                     }
                 }
@@ -40,15 +40,15 @@ class ValidationService {
         }
         return failedValidations;
     }
-    performValidation(dataChangedInfo) {
-        const failedRules = this.getValidationRulesForDataChange(dataChangedInfo);
+    performValidation(cellDataChangedInfo) {
+        const failedRules = this.getValidationRulesForDataChange(cellDataChangedInfo);
         if (failedRules.length > 0) {
             let alert = {
                 alertType: 'cellChanged',
                 header: 'Alert',
                 message: 'Perform Edit Alert Fired',
                 alertDefinition: failedRules[0],
-                dataChangedInfo: dataChangedInfo,
+                cellDataChangedInfo: cellDataChangedInfo,
             };
             this.adaptable.api.alertApi.publishAlertFiredEvent(alert);
             return false;
@@ -64,25 +64,25 @@ class ValidationService {
             column: dataChangedEvent.column,
         }, false);
     }
-    performServerValidation(dataChangedInfo, config) {
+    performServerValidation(cellDataChangedInfo, config) {
         return () => {
             this.adaptable.adaptableOptions.editOptions
-                .validateOnServer(dataChangedInfo)
+                .validateOnServer(cellDataChangedInfo)
                 .then((validationResult) => {
                 var _a, _b;
                 if (validationResult.NewValue === undefined) {
-                    validationResult.NewValue = dataChangedInfo.newValue;
+                    validationResult.NewValue = cellDataChangedInfo.newValue;
                 }
                 // If they have changed the return value then we should update the grid, log the function change
                 // otherwise the value will persist
-                if (validationResult.NewValue !== dataChangedInfo.newValue) {
-                    dataChangedInfo.newValue = validationResult.NewValue;
-                    // this.adaptable.setValue(dataChangedInfo, false);
-                    const row = (_a = dataChangedInfo.rowNode) === null || _a === void 0 ? void 0 : _a.data;
+                if (validationResult.NewValue !== cellDataChangedInfo.newValue) {
+                    cellDataChangedInfo.newValue = validationResult.NewValue;
+                    // this.adaptable.setValue(cellDataChangedInfo, false);
+                    const row = (_a = cellDataChangedInfo.rowNode) === null || _a === void 0 ? void 0 : _a.data;
                     if (!row) {
                         return;
                     }
-                    row[(_b = this.adaptable.api.columnApi.getAgGridColumnFieldForAdaptableColumn(dataChangedInfo.column.columnId)) !== null && _b !== void 0 ? _b : dataChangedInfo.column.columnId] = validationResult.NewValue;
+                    row[(_b = this.adaptable.api.columnApi.getAgGridColumnFieldForAdaptableColumn(cellDataChangedInfo.column.columnId)) !== null && _b !== void 0 ? _b : cellDataChangedInfo.column.columnId] = validationResult.NewValue;
                     this.adaptable.api.gridApi.updateGridData([row]);
                     if (StringExtensions_1.default.IsNotNullOrEmpty(validationResult.ValidationMessage) &&
                         this.adaptable.adaptableOptions.editOptions.displayServerValidationMessages) {

package/src/View/DataChangeHistory/DataChangeHistoryGrid.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="react" />
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 export interface DataChangeHistoryGridProps {
     adaptableContainerId: string;
     agGridContainerId: string;
-    changeHistoryLog: Record<string, DataChangedInfo>;
+    changeHistoryLog: Record<string, CellDataChangedInfo>;
     onUndoChange: (changeKey: string) => void;
 }
 export declare const DataChangeHistoryGrid: (props: DataChangeHistoryGridProps) => JSX.Element;

package/src/View/DataChangeHistory/DataChangeHistoryPopup.d.ts

@@ -1,11 +1,11 @@
 import { ModuleViewPopupProps } from '../Components/SharedProps/ModuleViewPopupProps';
 import * as React from 'react';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { SystemDataChangeHistoryDisableAction, SystemDataChangeHistoryEnableAction, SystemDataChangeHistoryResumeAction, SystemDataChangeHistorySuspendAction } from '../../Redux/ActionsReducers/SystemRedux';
 import { DataChangeHistoryMode } from '../../PredefinedConfig/SystemState';
 import { AdaptableApi } from '../../Api/AdaptableApi';
 interface DataChangeHistoryPopupProps extends ModuleViewPopupProps<DataChangeHistoryPopupComponent> {
-    changeHistoryLog: Record<string, DataChangedInfo>;
+    changeHistoryLog: Record<string, CellDataChangedInfo>;
     changeHistoryMode: DataChangeHistoryMode;
     activationTime: Date;
     suspensionTime: Date;

package/src/agGrid/ActionColumnRenderer.d.ts

@@ -1,9 +1,4 @@
-import { ICellRendererComp, ICellRendererParams, ITooltipComp, ITooltipParams } from '@ag-grid-community/all-modules';
-export declare class CustomTooltip implements ITooltipComp {
-    private eGui;
-    init(params: ITooltipParams): void;
-    getGui(): any;
-}
+import { ICellRendererComp, ICellRendererParams } from '@ag-grid-community/all-modules';
 export declare class ActionColumnRenderer implements ICellRendererComp {
     private eGui;
     private eventListener;