@adaptabletools/adaptable 18.0.0-canary.30 → 18.0.0-canary.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "18.0.0-canary.30",
+  "version": "18.0.0-canary.32",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",

package/src/AdaptableOptions/ActionColumnOptions.d.ts

@@ -1,4 +1,5 @@
 import { IRowNode } from '@ag-grid-community/core';
+import { RowScope } from "../PredefinedConfig/Common/RowScope";
 import { AdaptableButton, AdaptableObject, BaseContext } from '../types';
 /**
  * Options related to Action Columns in AdapTable
@@ -27,9 +28,9 @@ export interface ActionColumn<TData = any> extends AdaptableObject {
      */
     actionColumnButton: AdaptableButton<ActionColumnContext<TData>> | AdaptableButton<ActionColumnContext<TData>>[];
     /**
-     * Shows Action Column also in grouped rows
+     * Which types of Rows should contain buttons (data, grouped, summary)
      */
-    includeGroupedRows?: boolean;
+    rowScope?: RowScope;
     /**
      * Additional optional properties for Column (e.g. filterable, resizable)
      */

package/src/AdaptableOptions/CustomSortOptions.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableScope } from '../../types';
+import { ColumnScope } from '../../types';
 import { AdaptableComparerFunction } from '../PredefinedConfig/Common/AdaptableComparerFunction';
 /**
  * Options for providing Custom Sorts comparers
@@ -16,7 +16,7 @@ export interface ColumnValuesComparer<TData = any> {
     /**
      * Column for which to compare values
      */
-    scope: AdaptableScope;
+    scope: ColumnScope;
     /**
      * Comparer function to use
      */

package/src/AdaptableOptions/FormatColumnOptions.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableScope } from '../PredefinedConfig/Common/AdaptableScope';
+import { ColumnScope } from '../PredefinedConfig/Common/ColumnScope';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { BaseContext } from '../../types';
 import { IRowNode } from '@ag-grid-community/core';
@@ -30,7 +30,7 @@ export interface CustomDisplayFormatter {
     /**
      * Where Custom Display Format can be applied
      */
-    scope: AdaptableScope;
+    scope: ColumnScope;
 }
 /**
  * Context used in handler of CustomDisplayFormatter

package/src/AdaptableOptions/PredicateOptions.d.ts

@@ -1,4 +1,4 @@
-import { AdaptablePredicateDef, AdaptableScope, BaseContext, PredicateModuleScope, SystemAlertPredicateId, SystemAlertPredicateIds, SystemBadgeStylePredicateId, SystemBadgeStylePredicateIds, SystemFilterPredicateId, SystemFilterPredicateIds, SystemFlashingCellPredicateId, SystemFlashingCellPredicateIds, SystemFormatColumnPredicateId, SystemFormatColumnPredicateIds } from '../types';
+import { AdaptablePredicateDef, ColumnScope, BaseContext, PredicateModuleScope, SystemAlertPredicateId, SystemAlertPredicateIds, SystemBadgeStylePredicateId, SystemBadgeStylePredicateIds, SystemFilterPredicateId, SystemFilterPredicateIds, SystemFlashingCellPredicateId, SystemFlashingCellPredicateIds, SystemFormatColumnPredicateId, SystemFormatColumnPredicateIds } from '../types';
 /**
  * Options for managing Adaptable Predicates using AdaptableQL
  */
@@ -51,5 +51,5 @@ export interface SystemPredicatesContext<PREDICATE_TYPE = string> extends BaseCo
     /**
      * Current Scope where Predicates are being used
      */
-    columnScope: AdaptableScope;
+    columnScope: ColumnScope;
 }

package/src/AdaptableOptions/UserInterfaceOptions.d.ts

@@ -1,6 +1,6 @@
 import { AdaptableIcon } from '../PredefinedConfig/Common/AdaptableIcon';
 import { DateInputOptions } from './DateInputOptions';
-import { AdaptableScope } from '../PredefinedConfig/Common/AdaptableScope';
+import { ColumnScope } from '../PredefinedConfig/Common/ColumnScope';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableObjectTag } from '../PredefinedConfig/Common/AdaptableObject';
 import { AdaptableStyle } from '../PredefinedConfig/Common/AdaptableStyle';
@@ -136,7 +136,7 @@ export interface BasePermittedValues {
     /**
      * Scope where Values will appear (Mandatory property)
      */
-    scope: AdaptableScope;
+    scope: ColumnScope;
 }
 /**
  * Permitted/possible values, when column values can be selected (e.g. sort, bulk-update)

package/src/Api/AdaptableApi.d.ts

@@ -29,7 +29,7 @@ import { ExpressionApi } from './ExpressionApi';
 import { TeamSharingApi } from './TeamSharingApi';
 import { ColumnApi } from './ColumnApi';
 import { ApplicationApi } from './ApplicationApi';
-import { ScopeApi } from './ScopeApi';
+import { ColumnScopeApi } from './ColumnScopeApi';
 import { PredicateApi } from './PredicateApi';
 import { DataChangeHistoryApi } from './DataChangeHistoryApi';
 import { FlashingCellApi } from './FlashingCellApi';
@@ -193,7 +193,7 @@ export interface AdaptableApi {
     /**
      * Manages the `Scope` object - used widely to determine where objects are applied
      */
-    scopeApi: ScopeApi;
+    columnScopeApi: ColumnScopeApi;
     /**
      * Provides access to the Shortcut Module
      */

package/src/Api/{ScopeApi.d.ts → ColumnScopeApi.d.ts}

@@ -1,125 +1,125 @@
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
-import { AdaptableScope, ScopeDataType } from '../PredefinedConfig/Common/AdaptableScope';
+import { ColumnScope, ScopeDataType } from '../PredefinedConfig/Common/ColumnScope';
 import { CellColorRange } from '../PredefinedConfig/StyledColumnState';
 /**
- * Provides access to a suite of functions related to the `Scope` object
+ * Provides access to a suite of functions related to the `Column Scope` object
  */
-export interface ScopeApi {
+export interface ColumnScopeApi {
     /**
      * True if Column is in given Scope
      * @param column Column to check
      * @param scope   The Scope to check
      */
-    isColumnInScope(column: AdaptableColumn | undefined, scope: AdaptableScope): boolean;
+    isColumnInScope(column: AdaptableColumn | undefined, scope: ColumnScope): boolean;
     /**
      * Returns list of all Columns in the given Scope
      * @param scope the Scope to check
      */
-    getColumnsForScope(scope: AdaptableScope): AdaptableColumn[];
+    getColumnsForScope(scope: ColumnScope): AdaptableColumn[];
     /**
      * True if Scope is empty
      * @param scope Scope to check
      */
-    scopeIsEmpty(scope: AdaptableScope): boolean;
+    scopeIsEmpty(scope: ColumnScope): boolean;
     /**
      * True if Scope is 'All'
      * @param scope Scope to check
      */
-    scopeIsAll(scope: AdaptableScope): boolean;
+    scopeIsAll(scope: ColumnScope): boolean;
     /**
      * True if Scope contains DataTypes
      * @param scope Scope to check
      */
-    scopeHasDataType(scope: AdaptableScope): boolean;
+    scopeHasDataType(scope: ColumnScope): boolean;
     /**
      * True if Scope contains ColumnTypes
      * @param scope Scope to check
      */
-    scopeHasColumnType(scope: AdaptableScope): boolean;
+    scopeHasColumnType(scope: ColumnScope): boolean;
     /**
      * True if the Scope is DataTypes and contains only Boolean
      * @param scope Scope to check
      */
-    scopeHasOnlyBooleanDataType(scope: AdaptableScope): boolean;
+    scopeHasOnlyBooleanDataType(scope: ColumnScope): boolean;
     /**
      * True if Scope contains just 1 ColumnId
      * @param scope Scope to check
      */
-    isSingleColumnScope(scope: AdaptableScope): boolean;
+    isSingleColumnScope(scope: ColumnScope): boolean;
     /**
      * Gets the only Column in given Scope
      * @param scope Scope to check
      */
-    getSingleColumnInScope(scope: AdaptableScope): string | undefined;
+    getSingleColumnInScope(scope: ColumnScope): string | undefined;
     /**
      * True if Scope contains just 1 numeric Column
      * @param scope Scope to check
      */
-    isSingleNumericColumnScope(scope: AdaptableScope): boolean;
+    isSingleNumericColumnScope(scope: ColumnScope): boolean;
     /**
      * True if Scope contains just 1 boolean Column
      * @param scope Scope to check
      */
-    isSingleBooleanColumnScope(scope: AdaptableScope): boolean;
+    isSingleBooleanColumnScope(scope: ColumnScope): boolean;
     /**
      * True if all selected columns are boolean
      * @param scope Scope to check
      */
-    areAllBooleanColumnsInScope(scope: AdaptableScope): boolean;
+    areAllBooleanColumnsInScope(scope: ColumnScope): boolean;
     /**
      * True if Scope contains ColumnIds
      * @param scope Scope to check
      */
-    scopeHasColumns(scope: AdaptableScope): boolean;
+    scopeHasColumns(scope: ColumnScope): boolean;
     /**
      * Gets string representation of the Scope
      * @param scope Scope to check
      */
-    getScopeToString(scope: AdaptableScope): string;
+    getScopeToString(scope: ColumnScope): string;
     /**
      * Whether PK column is included in Scope's column section
      * @param scope Scope to check
      */
-    isPrimaryKeyColumnInScopeColumns(scope: AdaptableScope): boolean;
+    isPrimaryKeyColumnInScopeColumns(scope: ColumnScope): boolean;
     /**
      * True if Column is in Scope's 'ColumnIds' section
      * @param column Column to check
      * @param scope Scope to check
      */
-    isColumnInScopeColumns(column: AdaptableColumn, scope: AdaptableScope): boolean;
+    isColumnInScopeColumns(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * Returns all the ColumnIds in the Scope
      * @param scope Scope to check
      */
-    getColumnIdsInScope(scope: AdaptableScope): string[] | undefined;
+    getColumnIdsInScope(scope: ColumnScope): string[] | undefined;
     /**
      * Returns all the ColumnTypes in the Scope
      * @param scope Scope to check
      */
-    getColumnTypesInScope(scope: AdaptableScope): string[] | undefined;
+    getColumnTypesInScope(scope: ColumnScope): string[] | undefined;
     /**
      * Returns all the DataTypes in the Scope
      * @param scope Scope to check
      */
-    getDataTypesInScope(scope: AdaptableScope): ScopeDataType[] | undefined;
+    getDataTypesInScope(scope: ColumnScope): ScopeDataType[] | undefined;
     /**
      * True if Scope has Numeric DataType containing Column
      * @param column Column to check
      * @param scope Scope to check
      */
-    isColumnInNumericScope(column: AdaptableColumn, scope: AdaptableScope): boolean;
+    isColumnInNumericScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * True if Scope has String DataType containing Column
      * @param column Column to check
      * @param scope Scope to check
      */
-    isColumnInStringsScope(column: AdaptableColumn, scope: AdaptableScope): boolean;
+    isColumnInStringsScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * True if Scope has Data DataType which contains Column
      * @param column Column to check
      * @param scope Scope to check
      */
-    isColumnInDateScope(column: AdaptableColumn, scope: AdaptableScope): boolean;
+    isColumnInDateScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * True if first scope is in second Scope
      *
@@ -135,15 +135,15 @@ export interface ScopeApi {
      * @param scopeA first Scope
      * @param scopeB second Scope
      */
-    isScopeInScope(scopeA: AdaptableScope, scopeB: AdaptableScope): boolean;
+    isScopeInScope(scopeA: ColumnScope, scopeB: ColumnScope): boolean;
     /**
      * Provides a description for the Scope
      * @param scope The Scope to check
      */
-    getScopeDescription(scope: AdaptableScope): string;
+    getScopeDescription(scope: ColumnScope): string;
     /**
      * Creates Cell Color Ranges (used in Format Column) for given Scope
      * @param scope Scope to use
      */
-    createCellColorRangesForScope(scope: AdaptableScope): CellColorRange[];
+    createCellColorRangesForScope(scope: ColumnScope): CellColorRange[];
 }

package/src/Api/FlashingCellApi.d.ts

@@ -1,6 +1,6 @@
 import { AdaptableFlashingCell } from '../PredefinedConfig/Common/AdaptableFlashingCell';
 import { AdaptablePredicateDef } from '../PredefinedConfig/Common/AdaptablePredicate';
-import { AdaptableScope } from '../PredefinedConfig/Common/AdaptableScope';
+import { ColumnScope } from '../PredefinedConfig/Common/ColumnScope';
 import { FlashingCellDefinition, FlashingCellState } from '../PredefinedConfig/FlashingCellState';
 import { AdaptableObjectLookupCriteria } from '../PredefinedConfig/Common/AdaptableObject';
 /**
@@ -83,7 +83,7 @@ export interface FlashingCellApi {
      * Retrieves all Predicate Defs that match given Scope
      * @param scope the Scope to check
      */
-    getFlashingCellPredicateDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    getFlashingCellPredicateDefsForScope(scope: ColumnScope): AdaptablePredicateDef[];
     /**
      * Clears all Cells and Rows which have been flashed (primarily used if duration is 'Always')
      */

package/src/Api/GridApi.d.ts

@@ -385,6 +385,11 @@ export interface GridApi {
      * @param rowNode Node to check
      */
     isGroupRowNode(rowNode: IRowNode): boolean;
+    /**
+     * Whether given Row Node is in a Smmary Row
+     * @param rowNode Node to check
+     */
+    isSummaryNode(rowNode: IRowNode): boolean;
     /**
      * Whether Quick Filter is available in the Grid
      */

package/src/Api/Implementation/AdaptableApiImpl.d.ts

@@ -31,7 +31,7 @@ import { ExpressionApi } from '../ExpressionApi';
 import { TeamSharingApi } from '../TeamSharingApi';
 import { ColumnApi } from '../ColumnApi';
 import { ApplicationApi } from '../ApplicationApi';
-import { ScopeApi } from '../ScopeApi';
+import { ColumnScopeApi } from '../ColumnScopeApi';
 import { PredicateApi } from '../PredicateApi';
 import { DataChangeHistoryApi } from '../DataChangeHistoryApi';
 import { FlashingCellApi } from '../FlashingCellApi';
@@ -86,7 +86,7 @@ export declare class AdaptableApiImpl implements AdaptableApi {
     styledColumnApi: StyledColumnApi;
     toolPanelApi: ToolPanelApi;
     teamSharingApi: TeamSharingApi;
-    scopeApi: ScopeApi;
+    columnScopeApi: ColumnScopeApi;
     dataChangeHistoryApi: DataChangeHistoryApi;
     chartingApi: ChartingApi;
     statusBarApi: StatusBarApi;

package/src/Api/Implementation/AdaptableApiImpl.js

@@ -28,7 +28,7 @@ import { ScheduleApiImpl } from './ScheduleApiImpl';
 import { TeamSharingApiImpl } from './TeamSharingApiImpl';
 import { ColumnApiImpl } from './ColumnApiImpl';
 import { ApplicationApiImpl } from './ApplicationApiImpl';
-import { ScopeApiImpl } from './ScopeApiImpl';
+import { ColumnScopeApiImpl } from './ColumnScopeApiImpl';
 import { DataChangeHistoryApiImpl } from './DataChangeHistoryApiImpl';
 import { ExpressionApiImpl } from './ExpressionApiImpl';
 import { FlashingCellApiImpl } from './FlashingCellApiImpl';
@@ -90,7 +90,7 @@ export class AdaptableApiImpl {
         this.styledColumnApi = new StyledColumnApiImpl(adaptable);
         this.toolPanelApi = new ToolPanelApiImpl(adaptable);
         this.teamSharingApi = new TeamSharingApiImpl(adaptable);
-        this.scopeApi = new ScopeApiImpl(adaptable);
+        this.columnScopeApi = new ColumnScopeApiImpl(adaptable);
         this.dataChangeHistoryApi = new DataChangeHistoryApiImpl(adaptable);
         this.chartingApi = new ChartingApiImpl(adaptable);
         this.statusBarApi = new StatusBarApiImpl(adaptable);
@@ -144,7 +144,7 @@ export class AdaptableApiImpl {
         this.expressionApi = null;
         this.quickSearchApi = null;
         this.scheduleApi = null;
-        this.scopeApi = null;
+        this.columnScopeApi = null;
         this.settingsPanelApi = null;
         this.shortcutApi = null;
         this.smartEditApi = null;

package/src/Api/Implementation/AlertApiImpl.js

@@ -162,7 +162,7 @@ export class AlertApiImpl extends ApiBase {
     }
     evaluateAlertDefinitions(alertDefinitions) {
         const filterScopeAllDefinitions = (alertDefinition) => {
-            if (this.getAdaptableApi().scopeApi.scopeIsAll(alertDefinition.Scope) &&
+            if (this.getAdaptableApi().columnScopeApi.scopeIsAll(alertDefinition.Scope) &&
                 !this.getAdaptableApi().expressionApi.getAdaptableQueryExpression(alertDefinition.Rule)) {
                 // we don't support scope ALL without an expression
                 // the predicates for scope ALL do NOT make any sense for a programmatic evaluation
@@ -197,7 +197,7 @@ export class AlertApiImpl extends ApiBase {
         //  if there is an Expression defined, extract only the columns from there (in that case the Scope would be 'All' anyway)
         // columns referenced in rule expression
         const ruleExpression = this.getAdaptableApi().expressionApi.getAdaptableQueryExpression(alertDefinition.Rule);
-        if (this.getAdaptableApi().scopeApi.scopeIsAll(alertDefinition.Scope) &&
+        if (this.getAdaptableApi().columnScopeApi.scopeIsAll(alertDefinition.Scope) &&
             StringExtensions.IsNotNullOrEmpty(ruleExpression)) {
             // return only first referenced column (otherwise we would generate multiple alerts for the same row)
             const queryColumns = this.getAdaptableApi()
@@ -208,7 +208,7 @@ export class AlertApiImpl extends ApiBase {
         else {
             // otherwise return all columns for given scope
             return this.getAdaptableApi()
-                .scopeApi.getColumnsForScope(alertDefinition.Scope)
+                .columnScopeApi.getColumnsForScope(alertDefinition.Scope)
                 .map((adaptableColumn) => adaptableColumn.columnId);
         }
     }

package/src/Api/Implementation/ApiBase.d.ts

@@ -7,7 +7,7 @@ import { ModuleInfo } from '../../Strategy/Interface/IModule';
 import { AdaptableOptions } from '../../AdaptableOptions/AdaptableOptions';
 import { AdaptableApi } from '../AdaptableApi';
 import { ExportOptions } from '../../AdaptableOptions/ExportOptions';
-import { ActionColumnApi, ActionColumnOptions, ActionRowApi, ActionRowOptions, AlertApi, AlertOptions, ApplicationApi, BulkUpdateApi, CalculatedColumnApi, CalendarApi, CalendarOptions, CellSummaryApi, CellSummaryOptions, ChartingApi, ChartingOptions, ColumnApi, ColumnFilterApi, ColumnFilterOptions, ColumnOptions, CommentOptions, ConfigApi, ContainerOptions, CustomSortApi, CustomSortOptions, DashboardApi, DashboardOptions, DataChangeHistoryApi, DataChangeHistoryOptions, DataSetApi, DataSetOptions, EditOptions, EntitlementApi, EntitlementOptions, EventApi, ExportApi, ExpressionApi, ExpressionOptions, Fdc3Api, Fdc3Options, FlashingCellApi, FlashingCellOptions, FormatColumnApi, FormatColumnOptions, FreeTextColumnApi, GridApi, GridFilterApi, GroupingOptions, LayoutApi, LayoutAssociatedObject, LayoutOptions, MenuOptions, NamedQueryApi, NoteOptions, NotificationsOptions, PluginsApi, PlusMinusApi, PredicateApi, PredicateOptions, QuickSearchApi, QuickSearchOptions, ScheduleApi, ScopeApi, SettingsPanelApi, SettingsPanelOptions, ShortcutApi, SmartEditApi, StateOptions, StatusBarApi, StyledColumnApi, SystemStatusApi, TeamSharingApi, TeamSharingOptions, ThemeApi, ToolPanelApi, ToolPanelOptions, UserInterfaceApi, UserInterfaceOptions } from '../../types';
+import { ActionColumnApi, ActionColumnOptions, ActionRowApi, ActionRowOptions, AlertApi, AlertOptions, ApplicationApi, BulkUpdateApi, CalculatedColumnApi, CalendarApi, CalendarOptions, CellSummaryApi, CellSummaryOptions, ChartingApi, ChartingOptions, ColumnApi, ColumnFilterApi, ColumnFilterOptions, ColumnOptions, CommentOptions, ConfigApi, ContainerOptions, CustomSortApi, CustomSortOptions, DashboardApi, DashboardOptions, DataChangeHistoryApi, DataChangeHistoryOptions, DataSetApi, DataSetOptions, EditOptions, EntitlementApi, EntitlementOptions, EventApi, ExportApi, ExpressionApi, ExpressionOptions, Fdc3Api, Fdc3Options, FlashingCellApi, FlashingCellOptions, FormatColumnApi, FormatColumnOptions, FreeTextColumnApi, GridApi, GridFilterApi, GroupingOptions, LayoutApi, LayoutAssociatedObject, LayoutOptions, MenuOptions, NamedQueryApi, NoteOptions, NotificationsOptions, PluginsApi, PlusMinusApi, PredicateApi, PredicateOptions, QuickSearchApi, QuickSearchOptions, ScheduleApi, ColumnScopeApi, SettingsPanelApi, SettingsPanelOptions, ShortcutApi, SmartEditApi, StateOptions, StatusBarApi, StyledColumnApi, SystemStatusApi, TeamSharingApi, TeamSharingOptions, ThemeApi, ToolPanelApi, ToolPanelOptions, UserInterfaceApi, UserInterfaceOptions } from '../../types';
 import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupProps';
 export declare abstract class ApiBase {
     protected adaptable: IAdaptable;
@@ -123,7 +123,7 @@ export declare abstract class ApiBase {
     protected getStyledColumnApi(): StyledColumnApi;
     protected getToolPanelApi(): ToolPanelApi;
     protected getTeamSharingApi(): TeamSharingApi;
-    protected getScopeApi(): ScopeApi;
+    protected getColumnScopeApi(): ColumnScopeApi;
     protected getDataChangeHistoryApi(): DataChangeHistoryApi;
     protected getChartingApi(): ChartingApi;
     protected getStatusBarApi(): StatusBarApi;

package/src/Api/Implementation/ApiBase.js

@@ -311,8 +311,8 @@ export class ApiBase {
     getTeamSharingApi() {
         return this.getAdaptableApi().teamSharingApi;
     }
-    getScopeApi() {
-        return this.getAdaptableApi().scopeApi;
+    getColumnScopeApi() {
+        return this.getAdaptableApi().columnScopeApi;
     }
     getDataChangeHistoryApi() {
         return this.getAdaptableApi().dataChangeHistoryApi;

package/src/Api/Implementation/ColumnFilterApiImpl.js

@@ -14,7 +14,7 @@ export class ColumnFilterApiImpl extends ApiBase {
         };
         return this.getAdaptableApi()
             .predicateApi.internalApi.getFilterPredicateDefs(scope)
-            .filter((predicate) => this.getAdaptableApi().scopeApi.isColumnInScope(column, predicate.columnScope));
+            .filter((predicate) => this.getAdaptableApi().columnScopeApi.isColumnInScope(column, predicate.columnScope));
     }
     getFilterPredicateDefsForColumnId(columnId) {
         const column = this.getAdaptableApi().columnApi.getColumnWithColumnId(columnId);

package/src/Api/Implementation/ColumnScopeApiImpl.d.ts

@@ -0,0 +1,33 @@
+import { ApiBase } from './ApiBase';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { ColumnScope, ScopeDataType } from '../../PredefinedConfig/Common/ColumnScope';
+import { ColumnScopeApi } from '../ColumnScopeApi';
+import { CellColorRange } from '../../PredefinedConfig/StyledColumnState';
+export declare class ColumnScopeApiImpl extends ApiBase implements ColumnScopeApi {
+    isColumnInScope(column: AdaptableColumn | undefined, scope: ColumnScope | undefined): boolean;
+    getColumnsForScope(scope: ColumnScope): AdaptableColumn[];
+    getScopeDescription(scope: ColumnScope): string;
+    scopeIsEmpty(scope: ColumnScope): boolean;
+    scopeIsAll(scope: ColumnScope): boolean;
+    scopeHasDataType(scope: ColumnScope): boolean;
+    scopeHasColumnType(scope: ColumnScope): boolean;
+    scopeHasOnlyBooleanDataType(scope: ColumnScope): boolean;
+    scopeHasColumns(scope: ColumnScope): boolean;
+    isSingleColumnScope(scope: ColumnScope): boolean;
+    getSingleColumnInScope(scope: ColumnScope): string | undefined;
+    isSingleNumericColumnScope(scope: ColumnScope): boolean;
+    isSingleBooleanColumnScope(scope: ColumnScope): boolean;
+    areAllBooleanColumnsInScope(scope: ColumnScope): boolean;
+    isColumnInScopeColumns(column: AdaptableColumn, scope: ColumnScope): boolean;
+    isPrimaryKeyColumnInScopeColumns(scope: ColumnScope): boolean;
+    getScopeToString(scope: ColumnScope): string;
+    getColumnIdsInScope(scope: ColumnScope): string[] | undefined;
+    getColumnTypesInScope(scope: ColumnScope): string[] | undefined;
+    getDataTypesInScope(scope: ColumnScope): ScopeDataType[] | undefined;
+    isColumnInNumericScope(column: AdaptableColumn, scope: ColumnScope): boolean;
+    isColumnInStringsScope(column: AdaptableColumn, scope: ColumnScope): boolean;
+    isColumnInDateScope(column: AdaptableColumn, scope: ColumnScope): boolean;
+    isScopeInScope(a: ColumnScope, b: ColumnScope): boolean;
+    createCellColorRangesForScope(scope: ColumnScope): CellColorRange[];
+    private distinctColumnValuesAreEmpty;
+}

package/src/Api/Implementation/{ScopeApiImpl.js → ColumnScopeApiImpl.js}

@@ -1,7 +1,7 @@
 import { ApiBase } from './ApiBase';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { DARK_GREEN, getHexForName, GRAY, RED } from '../../View/UIHelper';
-export class ScopeApiImpl extends ApiBase {
+export class ColumnScopeApiImpl extends ApiBase {
     isColumnInScope(column, scope) {
         if (!column) {
             return false;
@@ -276,7 +276,7 @@ export class ScopeApiImpl extends ApiBase {
         return false;
     }
     createCellColorRangesForScope(scope) {
-        let distinctColumnsValues = this.getAdaptableApi().gridApi.internalApi.getDistinctRawValuesForColumn(this.getAdaptableApi().scopeApi.getSingleColumnInScope(scope));
+        let distinctColumnsValues = this.getAdaptableApi().gridApi.internalApi.getDistinctRawValuesForColumn(this.getAdaptableApi().columnScopeApi.getSingleColumnInScope(scope));
         let minValue = Math.min(...distinctColumnsValues);
         let maxValue = Math.max(...distinctColumnsValues);
         const ranges = [];

package/src/Api/Implementation/FlashingCellApiImpl.d.ts

@@ -3,7 +3,7 @@ import { AdaptableFlashingCell } from '../../PredefinedConfig/Common/AdaptableFl
 import { FlashingCellApi } from '../FlashingCellApi';
 import { FlashingCellDefinition, FlashingCellState } from '../../PredefinedConfig/FlashingCellState';
 import { AdaptablePredicateDef } from '../../PredefinedConfig/Common/AdaptablePredicate';
-import { AdaptableScope } from '../../PredefinedConfig/Common/AdaptableScope';
+import { ColumnScope } from '../../PredefinedConfig/Common/ColumnScope';
 import { FlashingCellInternalApi } from '../Internal/FlashingCellInternalApi';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { AdaptableObjectLookupCriteria } from '../../types';
@@ -23,7 +23,7 @@ export declare class FlashingCellApiImpl extends ApiBase implements FlashingCell
     unSuspendFlashingCellDefinition(flashingCellDefinition: FlashingCellDefinition): FlashingCellDefinition;
     addFlashingCellDefinitions(flashingCellDefinitions: FlashingCellDefinition[]): FlashingCellDefinition[];
     editFlashingCellDefinitions(flashingCellDefinitions: FlashingCellDefinition[]): FlashingCellDefinition[];
-    getFlashingCellPredicateDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    getFlashingCellPredicateDefsForScope(scope: ColumnScope): AdaptablePredicateDef[];
     clearAllFlashingCells(): void;
     isAnyFlashingCellActive(): boolean;
     findFlashingCellDefinitions(criteria: AdaptableObjectLookupCriteria): FlashingCellDefinition[];

package/src/Api/Implementation/FlashingCellApiImpl.js

@@ -79,7 +79,7 @@ export class FlashingCellApiImpl extends ApiBase {
     getFlashingCellPredicateDefsForScope(scope) {
         return this.getAdaptableApi()
             .predicateApi.internalApi.getFlashingCellPredicateDefs(scope)
-            .filter((predicateDef) => this.getAdaptableApi().scopeApi.isScopeInScope(scope, predicateDef.columnScope));
+            .filter((predicateDef) => this.getAdaptableApi().columnScopeApi.isScopeInScope(scope, predicateDef.columnScope));
     }
     clearAllFlashingCells() {
         this.dispatchAction(SystemRedux.SystemFlashingCellDeleteAll());

package/src/Api/Implementation/FormatColumnApiImpl.js

@@ -75,13 +75,13 @@ export class FormatColumnApiImpl extends ApiBase {
         this.showModulePopup(ModuleConstants.FormatColumnModuleId);
     }
     getFormatColumnsWithAllScope(formatColumns) {
-        return formatColumns.filter((fc) => this.getAdaptableApi().scopeApi.scopeIsAll(fc.Scope));
+        return formatColumns.filter((fc) => this.getAdaptableApi().columnScopeApi.scopeIsAll(fc.Scope));
     }
     getFormatColumnsWithDataTypeScope(formatColumns) {
-        return formatColumns.filter((fc) => this.getAdaptableApi().scopeApi.scopeHasDataType(fc.Scope));
+        return formatColumns.filter((fc) => this.getAdaptableApi().columnScopeApi.scopeHasDataType(fc.Scope));
     }
     getFormatColumnsWithColumnScope(formatColumns) {
-        return formatColumns.filter((fc) => this.getAdaptableApi().scopeApi.scopeHasColumns(fc.Scope));
+        return formatColumns.filter((fc) => this.getAdaptableApi().columnScopeApi.scopeHasColumns(fc.Scope));
     }
     hasCustomDisplayFormatter(formatColumn) {
         var _a;

package/src/Api/Implementation/GridApiImpl.d.ts

@@ -99,6 +99,7 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     isGridRowGrouped(): boolean;
     isGridInPivotMode(): boolean;
     isGroupRowNode(rowNode: IRowNode): boolean;
+    isSummaryNode(rowNode: IRowNode): boolean;
     isQuickFilterAvailable(): boolean;
     redrawGrid(): void;
     getGridCellsForRawValue(columnId: string, rawValue: any): GridCell[] | undefined;

package/src/Api/Implementation/GridApiImpl.js

@@ -6,6 +6,7 @@ import { GridInternalApi } from '../Internal/GridInternalApi';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { logDeprecation } from '../../Utilities/logDeprecation';
 import { WINDOW_SHOW_TRANSPOSED_VIEW } from '../../View/Components/Popups/WindowPopups/windowFactory';
+import { ROW_SUMMARY_ROW_ID } from '../../PredefinedConfig/Common/RowSummary';
 export class GridApiImpl extends ApiBase {
     constructor(adaptable) {
         super(adaptable);
@@ -374,6 +375,10 @@ export class GridApiImpl extends ApiBase {
     isGroupRowNode(rowNode) {
         return this.adaptable.isGroupRowNode(rowNode);
     }
+    isSummaryNode(rowNode) {
+        var _a;
+        return (_a = rowNode === null || rowNode === void 0 ? void 0 : rowNode.data) === null || _a === void 0 ? void 0 : _a[ROW_SUMMARY_ROW_ID];
+    }
     isQuickFilterAvailable() {
         return this.adaptable.isQuickFilterAvailable();
     }

package/src/Api/Implementation/UserInterfaceApiImpl.js

@@ -42,21 +42,21 @@ export class UserInterfaceApiImpl extends ApiBase {
         // columns id
         permittedValuesItem = permittedValues.find((permittedValue) => {
             return ('ColumnIds' in permittedValue.scope &&
-                this.getAdaptableApi().scopeApi.isColumnInScope(column, permittedValue.scope));
+                this.getAdaptableApi().columnScopeApi.isColumnInScope(column, permittedValue.scope));
         });
         if (permittedValuesItem) {
             return permittedValuesItem;
         }
         permittedValuesItem = permittedValues.find((permittedValue) => {
             return ('DataTypes' in permittedValue.scope &&
-                this.getAdaptableApi().scopeApi.isColumnInScope(column, permittedValue.scope));
+                this.getAdaptableApi().columnScopeApi.isColumnInScope(column, permittedValue.scope));
         });
         if (permittedValuesItem) {
             return permittedValuesItem;
         }
         permittedValuesItem = permittedValues.find((permittedValue) => {
             return ('All' in permittedValue.scope &&
-                this.getAdaptableApi().scopeApi.isColumnInScope(column, permittedValue.scope));
+                this.getAdaptableApi().columnScopeApi.isColumnInScope(column, permittedValue.scope));
         });
         if (permittedValuesItem) {
             return permittedValuesItem;

package/src/Api/Internal/AdaptableInternalApi.js

@@ -421,7 +421,7 @@ export class AdaptableInternalApi extends ApiBase {
         }
         // lastly filter by scope
         if (scope) {
-            locatedAdaptableObjects = locatedAdaptableObjects.filter((adaptableObject) => this.getAdaptableApi().scopeApi.isScopeInScope(adaptableObject.Scope, scope));
+            locatedAdaptableObjects = locatedAdaptableObjects.filter((adaptableObject) => this.getAdaptableApi().columnScopeApi.isScopeInScope(adaptableObject.Scope, scope));
         }
         return locatedAdaptableObjects;
     }

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

@@ -5,7 +5,7 @@ import { AlertFormContext } from '../../AdaptableOptions/AlertOptions';
 import { AdaptableAlert, AdaptableCellChangedAlert, AdaptableRowChangedAlert } from '../../PredefinedConfig/Common/AdaptableAlert';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { GridDataChangedInfo } from '../Events/GridDataChanged';
-import { AdaptableScope } from '../../PredefinedConfig/Common/AdaptableScope';
+import { ColumnScope } from '../../PredefinedConfig/Common/ColumnScope';
 import { AdaptablePredicateDef } from '../../PredefinedConfig/Common/AdaptablePredicate';
 import { AdaptableMessageType } from '../../PredefinedConfig/Common/AdaptableMessageType';
 import { IRowNode } from '@ag-grid-community/core';
@@ -72,7 +72,7 @@ export declare class AlertInternalApi extends ApiBase {
      * Retrieves all Predicate Defs that match given Scope
      * @param scope the Scope to check
      */
-    getAlertPredicateDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    getAlertPredicateDefsForScope(scope: ColumnScope): AdaptablePredicateDef[];
     /**
      * Returns a description of an Alert Definition
      * @param alertDefinition Alert Definition to use