@adaptabletools/adaptable 20.3.0 → 21.0.0-canary.1

package/src/AdaptableState/FormatColumnState.d.ts

@@ -6,7 +6,7 @@ import { RowScope } from './Common/RowScope';
 import { SuspendableObject } from './Common/SuspendableObject';
 import { XOR } from '../Utilities/Extensions/TypeExtensions';
 import { TypeHint } from './Common/Types';
-import { AdaptableBooleanQuery } from '../types';
+import { AdaptableBooleanQuery, LayoutExtendedConfig } from '../types';
 import { AdaptableColumnPredicate } from './Common/AdaptablePredicate';
 /**
  * Adaptable State Section for Format Column Module
@@ -89,3 +89,10 @@ export type SystemFormatColumnPredicateIds = SystemFormatColumnPredicateId[];
  * List of System Predicates available for Format Columns
  */
 export type SystemFormatColumnPredicateId = 'Blanks' | 'NonBlanks' | 'Equals' | 'NotEquals' | 'GreaterThan' | 'LessThan' | 'Positive' | 'Negative' | 'Zero' | 'Between' | 'NotBetween' | 'Is' | 'IsNot' | 'Contains' | 'NotContains' | 'StartsWith' | 'EndsWith' | 'Regex' | 'Today' | 'Yesterday' | 'Tomorrow' | 'ThisWeek' | 'ThisMonth' | 'ThisQuarter' | 'ThisYear' | 'InPast' | 'InFuture' | 'Before' | 'After' | 'On' | 'NotOn' | 'NextWorkDay' | 'LastWorkDay' | 'WorkDay' | 'Holiday' | 'True' | 'False' | 'In' | 'NotIn';
+/**
+ * Config for api methods that get Format Columns
+ */
+export interface FormatColumnConfig extends LayoutExtendedConfig {
+    includeSuspended?: boolean;
+    target?: FormatColumnTarget;
+}

package/src/AdaptableState/InternalState.d.ts

@@ -93,7 +93,7 @@ export interface InternalState extends IPushPullState, OpenFinState {
      * Keeps session-relevant information for Layout
      */
     Layout: {
-        ShowLayoutNotAssociatedObjects: boolean;
+        showLayoutNonExtendedObjects: boolean;
     };
     /**
      * Equivalent of `UserInterfaceOptions.disableDeleteConfirmation`

package/src/AdaptableState/LayoutState.d.ts

@@ -36,9 +36,9 @@ export interface LayoutBase extends AdaptableObject {
      */
     Name: string;
     /**
-     * Set of widths for some (or all) Columns
+     * Controls size (width or flex & min/max) for Columns
      */
-    ColumnWidths?: ColumnNumberMap;
+    ColumnSizing?: ColumnSizingMap;
     /**
      * Defines which Row Groups are expanded / collapsed
      */
@@ -79,6 +79,10 @@ export interface LayoutBase extends AdaptableObject {
      * Position of the Grand Total Row in the Layout
      */
     GrandTotalRow?: 'top' | 'bottom' | 'pinnedTop' | 'pinnedBottom' | boolean;
+    /**
+     * Display Row Grouped Columns as 'single' or 'multi' column
+     */
+    RowGroupDisplayType?: 'single' | 'multi';
 }
 /**
  * Defines a Table-based Layout
@@ -104,10 +108,6 @@ export interface TableLayout extends LayoutBase {
      * Columns which are row-grouped when the Layout is applied
      */
     RowGroupedColumns?: string[];
-    /**
-     * Display Row Grouped Columns as 'single' or 'multi' column
-     */
-    RowGroupDisplayType?: 'single' | 'multi';
     /**
      * Pivot Columns - must NOT be provided
      */
@@ -227,6 +227,12 @@ export type ColumnGroupValuesWithExceptionKeys = {
      */
     ExceptionGroupKeys?: any[];
 };
+/**
+ * Defines a map of Columns with Sizing information
+ */
+export type ColumnSizingMap = {
+    [columnId: string]: ColumnSizingDefinition;
+};
 /**
  * Defines a map of Columns with a String value
  */
@@ -251,6 +257,20 @@ export type ColumnBooleanFalseMap = {
 export type ColumnDirectionMap = {
     [columnId: string]: 'left' | 'right';
 };
+/**
+ * State & behaviour for sizing a column (must set `width` or `flex` property, but not both); all other props optional
+ */
+export type ColumnSizingDefinition = ({
+    Width?: number;
+    Flex?: never;
+} | {
+    Flex?: number;
+    Width?: never;
+}) & {
+    Resizable?: boolean;
+    MinWidth?: number;
+    MaxWidth?: number;
+};
 /**
  * The OLD Layout - kept temporarily so we can check what we previously had
  */

package/src/AdaptableState/Selection/GridCell.d.ts

@@ -55,7 +55,39 @@ export interface GridCell<TData = any> {
     isRowGroupCell: boolean;
 }
 export interface GridCellWithCount extends GridCell {
+    /**
+     * How many times Cell appears in Data Source
+     */
     count: number;
+    /**
+     * How many times Cell appears in Visible Rows
+     */
+    visibleCount?: number;
+}
+export interface UniqueGridCell<TData = any> {
+    /**
+     * Raw value of Cell
+     */
+    rawValue: any;
+    /**
+     * Normalised value of Cell
+     */
+    normalisedValue: any;
+    /**
+     * Display value of Cell (e.g. if formatted)
+     */
+    displayValue: any;
+    /**
+     * Is Cell in a currently filtered Row
+     */
+    visible: boolean;
+    /**
+     * How many times Cell appears in Data Source
+     */
+    count: number;
+    /**
+     * How many times Cell appears in filtered Rows
+     */
     visibleCount: number;
 }
 /**

package/src/AdaptableState/StyledColumnState.d.ts

@@ -1,6 +1,6 @@
 import { BaseState } from './BaseState';
 import { SuspendableObject } from './Common/SuspendableObject';
-import { AdaptableCustomIcon, AdaptableSystemIcon, AdaptablePredicate, AdaptableStyle, AdaptableBooleanQuery } from '../types';
+import { AdaptablePredicate, AdaptableStyle, AdaptableBooleanQuery, AdaptableIcon } from '../types';
 import { TypeHint } from './Common/Types';
 import { RowScope } from './Common/RowScope';
 import { AgSparklineOptions } from 'ag-charts-types';
@@ -173,7 +173,7 @@ export interface BadgeStyleDefinition {
     /**
      * Icon to display in Badge
      */
-    Icon?: AdaptableSystemIcon | AdaptableCustomIcon;
+    Icon?: AdaptableIcon;
     /**
      * Position of Icon in the Badge - 'Start' or 'End'
      */

package/src/Api/AlertApi.d.ts

@@ -1,6 +1,6 @@
 import { AlertDefinition, AlertState } from '../AdaptableState/AlertState';
 import { AdaptableAlert } from '../AdaptableState/Common/AdaptableAlert';
-import { AdaptableMessageType, AlertProperties } from '../types';
+import { AdaptableMessageType, AlertProperties, LayoutExtendedConfig } from '../types';
 import { AdaptableObjectLookupCriteria } from '../AdaptableState/Common/AdaptableObject';
 /**
  * Provides run-time access to Alert function and associated State
@@ -19,27 +19,21 @@ export interface AlertApi {
      * Retrieves all Alert Definitions in Alert State
      * @returns alert definitions
      */
-    getAlertDefinitions(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): AlertDefinition[];
+    getAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      * Retrieves all Alert Definitions which are currently suspended
      */
-    getSuspendedAlertDefinitions(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): AlertDefinition[];
+    getSuspendedAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      * Retrieves all Alert Definitions which are currently active
      */
-    getActiveAlertDefinitions(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): AlertDefinition[];
+    getActiveAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      * Retrieves alert definition by the technical ID (from `AlertState`)
      * @param id alert definition id
      * @returns alert definition
      */
-    getAlertDefinitionById(id: AlertDefinition['Uuid']): AlertDefinition;
+    getAlertDefinitionById(id: AlertDefinition['Uuid'], config?: LayoutExtendedConfig): AlertDefinition;
     /**
      * Adds given Alert Definition to Adaptable State
      * @param alertDefinition AlertDefinition to add

package/src/Api/ColumnApi.d.ts

@@ -1,4 +1,5 @@
 import { AdaptableColumn, AdaptableColumnDataType, Layout } from '../../types';
+import { AdaptableColumnSummary } from '../AdaptableState/Common/AdaptableColumn';
 import { ColDef, ColGroupDef, Column } from 'ag-grid-enterprise';
 /**
  * Provides run-time access to AdapTable Column related features
@@ -13,7 +14,7 @@ export interface ColumnApi {
      */
     getUIAvailableColumns(): AdaptableColumn[];
     /**
-     * Returns all columns excluding Action, FreeText and Calculated Columns
+     * Returns all UI available columns excluding Action, FreeText and Calculated Columns
      */
     getNonSpecialColumns(): AdaptableColumn[];
     /**
@@ -174,6 +175,11 @@ export interface ColumnApi {
      * @param columnId ColumnId to check
      */
     isPivotResultColumn(columnId: string): boolean;
+    /**
+     * Checks if Column with given ColumnId is a Special (i.e. calculated, freetext or action) Column
+     * @param columnId ColumnId to check
+     */
+    isSpecialColumn(columnId: string): boolean;
     /**
      * Checks if Column with given ColumnId is a Calculated Column
      * @param columnId ColumnId to check
@@ -329,4 +335,14 @@ export interface ColumnApi {
      * @param columnType - Column Type to check for
      */
     hasColumnType(columnIdentifier: string | ColDef, columnType: string): boolean;
+    /**
+     * Gets summary info for a column including filters and unique values
+     * @param columnId Column to summarise
+     */
+    getColumnSummaryForColumnId(columnId: string): AdaptableColumnSummary;
+    /**
+     * Whether column is auto generated by AG Grid (for selection, grouping, pivoting etc)
+     * @param columnId column to check
+     */
+    isAgGridGeneratedColumn(columnId: string): boolean;
 }

package/src/Api/ColumnFilterApi.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableColumn, ColumnFilter, ColumnFilterPredicate } from '../types';
+import { AdaptableColumn, ColumnFilter, ColumnFilterPredicate, InFilterValue, InFilterValueInfo } from '../types';
 import { AdaptablePredicateDef, ColumnFilterDef } from '../AdaptableState/Common/AdaptablePredicate';
 /**
  * Provides run-time access to Filter section of Adaptable State.
@@ -122,9 +122,39 @@ export interface ColumnFilterApi {
      */
     columnFiltersToString(columnFilters: ColumnFilter[]): string;
     /**
-     * Sets the Column Filter for a given Column
+     * Sets the Column Filter for a given Column (clears any existing)
      * @param columnId - Column ID to set Column Filter for
      * @param predicate - Column Filter to set
      */
     setColumnFilterForColumn(columnId: string, predicate: ColumnFilterPredicate): void;
+    /**
+     * Adds the Blanks Predicate if any value is null, undefined or an empty string
+     * @param columnDistinctValues list to check for empty values
+     */
+    addBlanksToInFilterValues(columnDistinctValues: InFilterValueInfo[]): InFilterValueInfo[];
+    /**
+     * Refresh(reload) the filter values for a given Column (for `IN` Filter).
+     *
+     * @param columnId - the ID of the Column for which to refresh filter values.
+     * @return a Promise that resolves to the list of filter values, each represented as an object with `value` and `label` properties.
+     */
+    refreshFilterValues(columnId: string): Promise<InFilterValue[]>;
+    /**
+     * Refreshes (reloads) the filter values for ALL Columns (for `IN` Filter).
+     *
+     * @returns A Promise that resolves to a map where:
+     *          - keys are column IDs (string)
+     *          - values are arrays of filter values for the corresponding column
+     *            Each filter value contains a `value` and display `label` property
+     */
+    refreshAllFilterValues(): Promise<Record<string, InFilterValue[]>>;
+    /**
+     * Reset(clear cache) the filter values for a given Column (for `IN` Filter).
+     * @param columnId - the ID of the Column for which to reset filter values.
+     */
+    resetFilterValues(columnId: string): void;
+    /**
+     * Reset(clear cache) the filter values for ALL Columns (for `IN` Filter).
+     */
+    resetAllFilterValues(): void;
 }

package/src/Api/CustomSortApi.d.ts

@@ -1,5 +1,6 @@
 import { ColumnValuesComparer } from '../AdaptableOptions/CustomSortOptions';
 import { CustomSortState, CustomSort } from '../AdaptableState/CustomSortState';
+import { LayoutExtendedConfig } from '../types';
 /**
  *  Provides run-time access to the Custom Sort function
  */
@@ -11,15 +12,13 @@ export interface CustomSortApi {
     /**
      * Retrieves all Custom Sorts in Adaptable State
      */
-    getCustomSorts(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): CustomSort[];
+    getCustomSorts(config?: LayoutExtendedConfig): CustomSort[];
     /**
      * Retrieves Custom Sort by the technical ID (from `CustomSortState`)
      * @param id Custom Sort technical id
      * @returns Custom Sort
      */
-    getCustomSortById(id: CustomSort['Uuid']): CustomSort;
+    getCustomSortById(id: CustomSort['Uuid'], config?: LayoutExtendedConfig): CustomSort;
     /**
      * Retrieves all Custom Sorts in Adaptable State that are currently applied
      * @returns Custom Sorts
@@ -33,16 +32,12 @@ export interface CustomSortApi {
      * Retrieves all Custom Sorts that are active (not-suspended) in Adaptable State
      * @returns Custom Sorts
      */
-    getActiveCustomSorts(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): CustomSort[];
+    getActiveCustomSorts(config?: LayoutExtendedConfig): CustomSort[];
     /**
      * Retrieves all Custom Sorts that are suspended in Adaptable State
      * @returns Custom Sorts
      */
-    getSuspendedCustomSorts(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): CustomSort[];
+    getSuspendedCustomSorts(config?: LayoutExtendedConfig): CustomSort[];
     /**
      * Retrieves Custom Sort from Adaptable State for Column with given ColumnId
      * @param columnId Id of Column to retrieve Custom Sort for

package/src/Api/FlashingCellApi.d.ts

@@ -3,6 +3,7 @@ import { AdaptablePredicateDef } from '../AdaptableState/Common/AdaptablePredica
 import { ColumnScope } from '../AdaptableState/Common/ColumnScope';
 import { FlashingCellDefinition, FlashingCellState } from '../AdaptableState/FlashingCellState';
 import { AdaptableObjectLookupCriteria } from '../AdaptableState/Common/AdaptableObject';
+import { LayoutExtendedConfig } from '../types';
 /**
  * Provides run-time access to Flashing Cell functionality and associated State
  */
@@ -15,25 +16,23 @@ export interface FlashingCellApi {
     /**
      * Retrieves all Flashing Cell Definitions in Flashing Cell State
      */
-    getFlashingCellDefinitions(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): FlashingCellDefinition[];
+    getFlashingCellDefinitions(config?: LayoutExtendedConfig): FlashingCellDefinition[];
     /**
      * Retrieves Flashing Cell Definition by the technical ID (from `FlashingCellState`)
      * @param id Flashing Cell Definition Id
      * @returns Flashing Cell Definition
      */
-    getFlashingCellDefinitionById(id: FlashingCellDefinition['Uuid']): FlashingCellDefinition;
+    getFlashingCellDefinitionById(id: FlashingCellDefinition['Uuid'], config?: LayoutExtendedConfig): FlashingCellDefinition;
     /**
      * Retrieves all active (non-suspended) cell Definitions in Flashing Cell State
      * @returns flashing cell definitions
      */
-    getActiveFlashingCellDefinitions(): FlashingCellDefinition[];
+    getActiveFlashingCellDefinitions(config?: LayoutExtendedConfig): FlashingCellDefinition[];
     /**
      * Retrieves all suspended Cell Definitions in Flashing Cell State
      * @returns flashing cell definitions
      */
-    getSuspendedFlashingCellDefinitions(): FlashingCellDefinition[];
+    getSuspendedFlashingCellDefinitions(config?: LayoutExtendedConfig): FlashingCellDefinition[];
     /**
      * Returns `FlashTarget` of the given Flashing Cell Definition
      * @param flashingCellDefinition Flashing Cell Definition to check
@@ -61,6 +60,11 @@ export interface FlashingCellApi {
      * @param flashingCellDefinition Flashing Cell Definition to Add
      */
     addFlashingCellDefinition(flashingCellDefinition: FlashingCellDefinition): FlashingCellDefinition;
+    /**
+     * Deletes a Flashing Cell
+     * @param flashingCellDefinition flashing cell to delete
+     */
+    deleteFlashingCellDefinition(flashingCellDefinition: FlashingCellDefinition): void;
     /**
      * Sets a collection of Flashing Cell Definitions into State
      * @param flashingCellDefinitions Flashing Cell Definitions to Add to State

package/src/Api/FormatColumnApi.d.ts

@@ -1,5 +1,5 @@
 import { FormatColumn, FormatColumnState } from '../AdaptableState/FormatColumnState';
-import { AdaptableColumn, AdaptableFormat, AdaptableObjectLookupCriteria } from '../types';
+import { AdaptableColumn, AdaptableFormat, AdaptableObjectLookupCriteria, FormatColumnConfig } from '../types';
 /**
  * Provides run-time access to the Format Column Module and associated state
  */
@@ -12,34 +12,28 @@ export interface FormatColumnApi {
      * Retrieves all Format Columns in Adaptable State
      * @returns format columns
      */
-    getFormatColumns(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): FormatColumn[];
+    getFormatColumns(config?: FormatColumnConfig): FormatColumn[];
     /**
      * Retrieves Format Column by the technical ID (from `FormatColumnState`)
      * @param id Format Column id
      * @returns format column
      */
-    getFormatColumnByUuId(id: FormatColumn['Uuid']): FormatColumn;
+    getFormatColumnByUuId(id: FormatColumn['Uuid'], config?: FormatColumnConfig): FormatColumn;
     /**
      * Retrieves all active (not-suspended) Format Columns in Adaptable State
      * @returns format columns
      */
-    getActiveFormatColumns(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): FormatColumn[];
+    getActiveFormatColumns(config?: FormatColumnConfig): FormatColumn[];
     /**
      * Retrieves the first Format Column's Adaptable Format for a given Column
      * @param column Column to check
      */
-    getDisplayFormatForColumn(column: AdaptableColumn): AdaptableFormat | undefined;
+    getDisplayFormatForColumn(column: AdaptableColumn, config?: FormatColumnConfig): AdaptableFormat | undefined;
     /**
      * Retrieves all suspended Format Columns in Adaptable State
      * @returns format columns
      */
-    getSuspendedFormatColumns(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): FormatColumn[];
+    getSuspendedFormatColumns(config?: FormatColumnConfig): FormatColumn[];
     /**
      * Adds a Format Column to Format Column State
      * @param formatColumn Format Column to Add
@@ -96,17 +90,13 @@ export interface FormatColumnApi {
      * @param column The Column for which to retrieve the Format Column
      * @returns format column
      */
-    getFormatColumnsForColumn(column: AdaptableColumn, config?: {
-        includeSuspended?: boolean;
-    }): FormatColumn[];
+    getFormatColumnsForColumn(column: AdaptableColumn, config?: FormatColumnConfig): FormatColumn[];
     /**
      * Gets all FormatColumns which are defined for the column with the given columnId
      * @param columnId ColumnId for which to retrieve the Format Column
      * @returns format column
      */
-    getFormatColumnsForColumnId(columnId: string, config?: {
-        includeSuspended?: boolean;
-    }): FormatColumn[];
+    getFormatColumnsForColumnId(columnId: string, config?: FormatColumnConfig): FormatColumn[];
     /**
      * Checks if a Format Column contains a Custom Display Formatter
      * @param formatColumn Format Column

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

@@ -1,4 +1,4 @@
-import { ApiBase, LayoutAssociatedObjectLoadConfig } from './ApiBase';
+import { ApiBase } from './ApiBase';
 import { AlertApi } from '../AlertApi';
 import { AlertDefinition, AlertProperties, AlertState } from '../../AdaptableState/AlertState';
 import { AdaptableAlert } from '../../AdaptableState/Common/AdaptableAlert';
@@ -6,19 +6,16 @@ import { AdaptableMessageType } from '../../AdaptableState/Common/AdaptableMessa
 import { AdaptableObjectLookupCriteria } from '../../AdaptableState/Common/AdaptableObject';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { AlertInternalApi } from '../Internal/AlertInternalApi';
+import { LayoutExtendedConfig } from '../../AdaptableState/Common/ExtendedLayout';
 export declare class AlertApiImpl extends ApiBase implements AlertApi {
     internalApi: AlertInternalApi;
     constructor(_adaptable: IAdaptable);
     getAlertState(): AlertState;
-    getAlertDefinitions(config?: LayoutAssociatedObjectLoadConfig): AlertDefinition[];
-    getSuspendedAlertDefinitions(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): AlertDefinition[];
-    getActiveAlertDefinitions(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): AlertDefinition[];
+    getAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
+    getSuspendedAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
+    getActiveAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
     deleteAlertDefinition(alertDefinition: AlertDefinition): void;
-    getAlertDefinitionById(id: AlertDefinition['Uuid']): AlertDefinition;
+    getAlertDefinitionById(id: AlertDefinition['Uuid'], config?: LayoutExtendedConfig): AlertDefinition;
     addAlertDefinition(alertDefinition: AlertDefinition): AlertDefinition;
     displayAdaptableAlert(alertToShow: AdaptableAlert): Promise<void>;
     displayAdaptableAlertNotification(alert: AdaptableAlert): void;

package/src/Api/Implementation/AlertApiImpl.js

@@ -16,7 +16,7 @@ export class AlertApiImpl extends ApiBase {
         return this.getAdaptableState().Alert;
     }
     getAlertDefinitions(config) {
-        return (this.handleLayoutAssociatedObjects(this.getAlertState().AlertDefinitions, 'Alert', config) ??
+        return (this.handleLayoutExtensionObjects(this.getAlertState().AlertDefinitions, 'Alert', config) ??
             []);
     }
     getSuspendedAlertDefinitions(config) {
@@ -28,8 +28,8 @@ export class AlertApiImpl extends ApiBase {
     deleteAlertDefinition(alertDefinition) {
         this.dispatchAction(AlertRedux.AlertDefinitionDelete(alertDefinition));
     }
-    getAlertDefinitionById(id) {
-        return this.getAlertDefinitions().find((alert) => alert?.Uuid === id);
+    getAlertDefinitionById(id, config) {
+        return this.getAlertDefinitions(config).find((alert) => alert?.Uuid === id);
     }
     addAlertDefinition(alertDefinition) {
         this.addUidToAdaptableObject(alertDefinition);
@@ -189,9 +189,10 @@ export class AlertApiImpl extends ApiBase {
         });
     }
     findAlertDefinitions(criteria) {
-        return this.getAdaptableInternalApi().findAdaptableObjectsByLookupCriteria(criteria, this.getAlertDefinitions({
-            includeLayoutNotAssociatedObjects: true,
-        }));
+        const config = {
+            includeLayoutNotExtendedObjects: true,
+        };
+        return this.getAdaptableInternalApi().findAdaptableObjectsByLookupCriteria(criteria, this.getAlertDefinitions(config));
     }
     getRelevantColumnIdsForAlertDefinition(alertDefinition) {
         //  if there is an Expression defined, extract only the columns from there (in that case the Scope would be 'All' anyway)

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

@@ -8,7 +8,7 @@ import { AdaptableOptions } from '../../AdaptableOptions/AdaptableOptions';
 import { AdaptableApi } from '../AdaptableApi';
 import { GridApi as AgGridApi } from 'ag-grid-enterprise';
 import { ExportOptions } from '../../AdaptableOptions/ExportOptions';
-import { ActionColumnApi, ActionColumnOptions, AlertApi, AlertOptions, ApplicationApi, BulkUpdateApi, CalculatedColumnApi, CalendarApi, CalendarOptions, CellSummaryApi, CellSummaryOptions, ChartingApi, ChartingOptions, ColumnApi, FilterApi, ColumnOptions, CommentOptions, StateApi, 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, LayoutApi, LayoutAssociatedObject, LayoutOptions, 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, ColumnMenuOptions, ContextMenuOptions, FilterOptions, ColumnFilterApi, OptionsApi } from '../../types';
+import { ActionColumnApi, ActionColumnOptions, AlertApi, AlertOptions, ApplicationApi, BulkUpdateApi, CalculatedColumnApi, CalendarApi, CalendarOptions, CellSummaryApi, CellSummaryOptions, ChartingApi, ChartingOptions, ColumnApi, FilterApi, ColumnOptions, CommentOptions, StateApi, 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, LayoutApi, LayoutExtensionObject, LayoutOptions, 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, ColumnMenuOptions, ContextMenuOptions, FilterOptions, ColumnFilterApi, OptionsApi, LayoutExtensionModule, LayoutExtendedConfig } from '../../types';
 import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupProps';
 import { AdaptableInternalApi } from '../Internal/AdaptableInternalApi';
 import { AdaptableLogger } from '../../agGrid/AdaptableLogger';
@@ -39,10 +39,7 @@ export declare abstract class ApiBase {
      */
     protected checkItemExists(item: any, name: string, type: string): boolean;
     protected checkArrayExists(array: any): boolean;
-    protected handleLayoutAssociatedObjects<T extends LayoutAssociatedObject>(objectList: T[], module: AdaptableModule, config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-        associatedWithLayout?: string;
-    }): T[];
+    protected handleLayoutExtensionObjects<T extends LayoutExtensionObject>(objectList: T[], module: LayoutExtensionModule, config?: LayoutExtendedConfig): T[];
     /**
      * Base api Helper method that dispatches a *Redux Action* to the Store
      * @param action the Redux Action to be dispatched
@@ -143,10 +140,3 @@ export declare abstract class ApiBase {
     protected getOptionsApi(): OptionsApi;
     destroy(): void;
 }
-/**
- * Configuration for API methods which load `LayoutAssociatedObject`
- */
-export interface LayoutAssociatedObjectLoadConfig {
-    includeLayoutNotAssociatedObjects?: boolean;
-    associatedWithLayout?: string;
-}

package/src/Api/Implementation/ApiBase.js

@@ -52,14 +52,14 @@ export class ApiBase {
         }
         return true;
     }
-    handleLayoutAssociatedObjects(objectList = [], module, config) {
-        if (config?.includeLayoutNotAssociatedObjects) {
+    handleLayoutExtensionObjects(objectList = [], module, config) {
+        if (config?.includeLayoutNotExtendedObjects) {
             return objectList;
         }
-        const associatedLayout = config?.associatedWithLayout
-            ? this.getLayoutApi().getLayoutByName(config.associatedWithLayout)
+        const extendedLayout = config?.extendedLayoutName
+            ? this.getLayoutApi().getLayoutByName(config.extendedLayoutName)
             : this.getLayoutApi().getCurrentLayout();
-        return objectList.filter((objectItem) => this._adaptable.api.layoutApi.internalApi.isObjectAvailableInLayout(objectItem, module, associatedLayout));
+        return objectList.filter((objectItem) => this.getLayoutApi().internalApi.isObjectExtendedInLayout(objectItem, module, extendedLayout));
     }
     /**
      * Base api Helper method that dispatches a *Redux Action* to the Store

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

@@ -1,5 +1,5 @@
 import { ApiBase } from './ApiBase';
-import { AdaptableColumn, AdaptableColumnDataType } from '../../AdaptableState/Common/AdaptableColumn';
+import { AdaptableColumn, AdaptableColumnDataType, AdaptableColumnSummary } from '../../AdaptableState/Common/AdaptableColumn';
 import { Layout } from '../../types';
 import { ColumnApi } from '../ColumnApi';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
@@ -15,9 +15,9 @@ export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     internalApi: ColumnInternalApi;
     constructor(_adaptable: IAdaptable);
     getColumns(): AdaptableColumn[];
+    getUIAvailableColumns(): AdaptableColumn[];
     getSpecialColumns(): AdaptableColumn[];
     getNonSpecialColumns(): AdaptableColumn[];
-    getUIAvailableColumns(): AdaptableColumn[];
     getVisibleColumns(): AdaptableColumn[];
     selectColumn(columnId: string): void;
     selectColumns(columnIds: string[]): void;
@@ -34,6 +34,7 @@ export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     isAutoRowGroupColumn(columnId: string): boolean;
     isAutoRowGroupColumnForSingle(columnId: string): boolean;
     isAutoRowGroupColumnForMulti(columnId: string): boolean;
+    isSpecialColumn(columnId: string): boolean;
     isCalculatedColumn(columnId: string): boolean;
     isFreeTextColumn(columnId: string): boolean;
     isActionColumn(columnId: string): boolean;
@@ -85,4 +86,6 @@ export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     getAGGridColDefForColumnId(columnId: string): ColDef | ColGroupDef;
     getAGGridColumnForColumnId(columnId: string): Column;
     hasColumnType(columnIdentifier: string | ColDef, columnType: string): boolean;
+    getColumnSummaryForColumnId(columnId: string): AdaptableColumnSummary;
+    isAgGridGeneratedColumn(columnId: string): boolean;
 }