@adaptabletools/adaptable 23.1.0-canary.2 → 24.0.0-canary.0

package/src/Api/EventApi.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableReadyInfo, AdaptableStateChangedInfo, AdaptableStateReloadedInfo, BeforeAdaptableStateChangeInfo, AlertFiredInfo, CalculatedColumnChangedInfo, CellChangedInfo, CellSelectionChangedInfo, ChartChangedInfo, ColumnFilterAppliedInfo, CommentChangedInfo, CustomToolbarConfiguredInfo, DashboardChangedInfo, DataImportedInfo, DataSetSelectedInfo, Fdc3MessageInfo, FlashingCellDisplayedInfo, GridFilterAppliedInfo, GridSortedInfo, LayoutChangedInfo, LiveDataChangedInfo, RowChangedInfo, RowFormSubmittedInfo, RowSelectionChangedInfo, ReportScheduleRanInfo, SystemStatusMessageDisplayedInfo, TeamSharingEntityChangedInfo, ThemeChangedInfo, ThemeSelectedInfo } from '../types';
+import { AdaptableReadyInfo, AdaptableStateChangedInfo, AdaptableStateReloadedInfo, BeforeAdaptableStateChangeInfo, AlertFiredInfo, CalculatedColumnChangedInfo, CellChangedInfo, CellSelectionChangedInfo, ChartChangedInfo, ColumnFilterAppliedInfo, ColumnFilterChangedInfo, CommentChangedInfo, NoteChangedInfo, CustomToolbarConfiguredInfo, DashboardChangedInfo, DataImportedInfo, DataSetSelectedInfo, Fdc3MessageInfo, FlashingCellDisplayedInfo, GridFilterAppliedInfo, GridSortedInfo, LayoutChangedInfo, LiveDataChangedInfo, RowChangedInfo, RowFormSubmittedInfo, RowSelectionChangedInfo, ReportScheduleRanInfo, SystemStatusMessageDisplayedInfo, TeamSharingEntityChangedInfo, ThemeChangedInfo, ThemeSelectedInfo } from '../types';
 /**
  * Responsible for publishing the many Events that AdapTable fires
  */
@@ -42,7 +42,22 @@ export interface EventApi {
      */
     off(eventName: 'ReportScheduleRan', callback: (reportScheduleRanInfo: ReportScheduleRanInfo) => void): void;
     /**
-     * Event fired whenever a Column Filter is Applied in AdapTable
+     * Event fired whenever a Column Filter changes in AdapTable — including
+     * incomplete editor drafts that are not yet applied.
+     * @param eventName ColumnFilterChanged
+     * @param callback ColumnFilterChangedInfo (`isApplied` / `isComplete` distinguish draft vs apply)
+     * @returns the unsubscribe function
+     */
+    on(eventName: 'ColumnFilterChanged', callback: (columnFilterChangedInfo: ColumnFilterChangedInfo) => void): VoidFunction;
+    /**
+     * Unsubscribe from ColumnFilterChanged
+     * @param eventName ColumnFilterChanged
+     * @param callback
+     */
+    off(eventName: 'ColumnFilterChanged', callback: (columnFilterChangedInfo: ColumnFilterChangedInfo) => void): void;
+    /**
+     * Event fired whenever a Column Filter is Applied in AdapTable (persisted;
+     * grid filtering may run). Prefer ColumnFilterChanged + `isApplied` for new code.
      * @param eventName ColumnFilterApplied
      * @param callback ColumnFilterApplied which provides details of the Column Filter that was applied
      * @returns the unsubscribe function
@@ -324,6 +339,19 @@ export interface EventApi {
      * @param callback
      */
     off(eventName: 'CommentChanged', callback: (commentChangedInfo: CommentChangedInfo) => void): void;
+    /**
+     * Event fired whenever a Note is added, edited or deleted in AdapTable
+     * @param eventName NoteChanged
+     * @param callback NoteChangedInfo which includes the action (Added / Edited / Deleted) and the Note
+     * @returns the unsubscribe function
+     */
+    on(eventName: 'NoteChanged', callback: (noteChangedInfo: NoteChangedInfo) => void): VoidFunction;
+    /**
+     * Unsubscribe from NoteChanged
+     * @param eventName NoteChanged
+     * @param callback
+     */
+    off(eventName: 'NoteChanged', callback: (noteChangedInfo: NoteChangedInfo) => void): void;
     /**
      * Fired when Adaptable is up and running - has no arguments.
      * @param eventName - AdaptableReady

package/src/Api/Events/CalculatedColumnChanged.d.ts

@@ -13,7 +13,8 @@ export interface CalculatedColumnChangedInfo extends BaseContext {
      */
     calculatedColumn: CalculatedColumn;
     /**
-     * AST for Current Calculated Column Expression
+     * AST for Current Calculated Column Expression.
+     * `null` when the expression is empty or not currently parsable (e.g. mid-edit).
      */
     calculatedColumnExpressionAST: any;
 }

package/src/Api/Events/ColumnFilterApplied.d.ts

@@ -1,10 +1,24 @@
 import { BaseContext, ColumnFilter } from '../../types';
 /**
- * EventInfo returned by the  Column Filter Applied event
+ * EventInfo returned by the ColumnFilterApplied event.
+ *
+ * Fired when persisted Column Filters change (layout state updated; grid
+ * filtering may run). Incomplete editor drafts do **not** fire this event.
+ *
+ * For in-progress edits as well as applies, prefer
+ * {@link ColumnFilterChangedInfo | ColumnFilterChanged} and check `isApplied`.
+ * `ColumnFilterApplied` remains supported and is emitted alongside
+ * `ColumnFilterChanged` whenever `isApplied` is true.
  */
 export interface ColumnFilterAppliedInfo extends BaseContext {
     /**
      * Currently applied Column Filters
      */
     columnFilters: ColumnFilter[] | undefined;
+    /**
+     * AST for each applied Column Filter Expression, index-aligned with
+     * {@link columnFilters}. `null` when that filter has no Expression or the
+     * Expression is not currently parsable.
+     */
+    columnFilterExpressionASTs: Array<any | null>;
 }

package/src/Api/Events/ColumnFilterChanged.d.ts

@@ -0,0 +1,49 @@
+import { BaseContext, ColumnFilter } from '../../types';
+/**
+ * EventInfo returned by the ColumnFilterChanged event.
+ *
+ * Fires for every column-filter editor or state change — including incomplete
+ * drafts (e.g. operator chosen, value not yet valid) that are not persisted.
+ *
+ * Prefer this over {@link ColumnFilterAppliedInfo | ColumnFilterApplied} when
+ * you need to observe in-progress edits. Use `isApplied` to ignore drafts.
+ */
+export interface ColumnFilterChangedInfo extends BaseContext {
+    /**
+     * Column whose filter changed.
+     * Undefined for bulk actions (e.g. clear/suspend all).
+     */
+    columnId?: string;
+    /**
+     * True when persisted Column Filters were updated (layout state) and grid
+     * filtering may change. False when only an in-progress editor draft changed
+     * (incomplete expression, or manual-apply pending Apply).
+     *
+     * When true, {@link ColumnFilterAppliedInfo | ColumnFilterApplied} is also
+     * emitted for backward compatibility.
+     */
+    isApplied: boolean;
+    /**
+     * Whether the filter expression for this change is fully specified.
+     *
+     * - When `isApplied` is false: the editor draft is valid (not e.g. an
+     *   operator with a missing value). False for incomplete drafts.
+     * - When `isApplied` is true: a complete Expression was written or remains
+     *   for the column. False when the column filter was cleared/deactivated.
+     *
+     * These flags diverge for clear/deactivate (`isComplete: false`,
+     * `isApplied: true`), incomplete drafts (`false`/`false`), manual-apply
+     * pending Apply (`true`/`false`), and the usual complete apply (`true`/`true`).
+     */
+    isComplete: boolean;
+    /**
+     * Expression for `columnId` after this change when available.
+     * May be omitted for incomplete drafts with nothing persistable yet.
+     */
+    expression?: string;
+    /**
+     * Currently persisted Column Filters after this change.
+     * Unchanged when `isApplied` is false.
+     */
+    columnFilters: ColumnFilter[];
+}

package/src/Api/Events/LayoutChanged.d.ts

@@ -16,7 +16,25 @@ export interface LayoutChangedInfo extends BaseContext {
      * Current Layout State
      */
     newLayoutState: LayoutState;
+    /**
+     * Facets of the **current** Layout that changed.
+     *
+     * - `LAYOUT_SAVE`: diffs non-filter facets (e.g. `ColumnSorting`, `RowGrouping`)
+     * - Column Filter actions: `['ColumnFilter']`
+     * - Grid Filter actions: `['GridFilter']`
+     *
+     * Omitted for layout identity changes (`LAYOUT_SELECT`, `LAYOUT_ADD`, `LAYOUT_DELETE`, `LAYOUT_READY`).
+     */
+    changedAreas?: LayoutChangedArea[];
 }
+/**
+ * Facets of a Layout that can change while that Layout remains selected.
+ *
+ * Used by {@link LayoutChangedInfo.changedAreas} so listeners can react to specific
+ * grid/layout edits (e.g. sorting or column filters) without deep-diffing Layout State
+ * or enumerating every filter `actionName`.
+ */
+export type LayoutChangedArea = 'Columns' | 'ColumnPinning' | 'ColumnHeaders' | 'ColumnSorting' | 'RowGrouping' | 'Aggregations' | 'RowSummaries' | 'RowSelection' | 'ColumnFilter' | 'GridFilter' | 'Pivoting';
 /**
  * Trigger for Layout Changed Event
  */

package/src/Api/Events/NoteChanged.d.ts

@@ -0,0 +1,19 @@
+import { AdaptableNote } from '../../AdaptableState/NoteState';
+import { BaseContext } from '../../types';
+/**
+ * The action which triggered the NoteChanged event
+ */
+export type NoteChangedAction = 'Added' | 'Edited' | 'Deleted';
+/**
+ * EventInfo returned by the NoteChanged event
+ */
+export interface NoteChangedInfo extends BaseContext {
+    /**
+     * What caused Note State to change (i.e. Added, Edited, Deleted)
+     */
+    actionName: NoteChangedAction;
+    /**
+     * Note that has been added, edited or deleted
+     */
+    note: AdaptableNote;
+}

package/src/Api/ExportApi.d.ts

@@ -1,6 +1,5 @@
 import { AdaptableForm } from '../AdaptableState/Common/AdaptableForm';
 import { ExportState, Report, ReportFormatType, ReportNameType, ReportSchedule, SystemReportFormat, SystemReportName } from '../AdaptableState/ExportState';
-import { LayoutExtendedConfig } from '../types';
 import { CustomDestination, CustomExportParams, ExportConfig, ExportDestinationType, ExportFormContext, ExportResultData, SystemExportDestination } from '../AdaptableOptions/ExportOptions';
 import { AdaptableColumn } from '../types';
 /**
@@ -161,15 +160,15 @@ export interface ExportApi {
     /**
      * All scheduled reports (custom reports and system reports)
      */
-    getScheduledReports(config?: LayoutExtendedConfig): ReportSchedule[];
+    getScheduledReports(): ReportSchedule[];
     /**
      * All active scheduled reports (custom reports and system reports)
      */
-    getActiveScheduledReports(config?: LayoutExtendedConfig): ReportSchedule[];
+    getActiveScheduledReports(): ReportSchedule[];
     /**
      * Retrieves a scheduled report by its Uuid
      */
-    getScheduledReportById(reportScheduleId: ReportSchedule['Uuid'], config?: LayoutExtendedConfig): ReportSchedule | undefined;
+    getScheduledReportById(reportScheduleId: ReportSchedule['Uuid']): ReportSchedule | undefined;
     /**
      * Adds a scheduled report
      */

package/src/Api/ExpressionApi.d.ts

@@ -1,38 +1,34 @@
 import { AdaptableModule } from '../AdaptableState/Common/Types';
-import { AdaptableQuery } from '../AdaptableState/Common/AdaptableQuery';
+import type { ExpressionKind } from '../AdaptableState/Common/AdaptableQuery';
+import type { LegacyAdaptableQuery } from '../migration/legacyAdaptableQuery';
 import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
+import type { IRowNode } from 'ag-grid-enterprise';
+import { AggregatedExpressionEvaluationValue, EvaluateAggregatedExpressionRequest, EvaluateStandardExpressionRequest, ExpressionEvaluationResult, FilterDataSetRequest, FilterRowNodesRequest } from '../aql/ExpressionEvaluation';
 /**
  * Functions related to Expressions in AdapTableQL (the Adaptable Query Language)
  */
 export interface ExpressionApi {
     /**
-     * Whether the given BooleanExpression is valid
+     * Whether the given Expression is valid as a boolean predicate (Alert / Format Column /
+     * Grid Filter / etc.). Root `QUERY("x")` is accepted only when the named query's
+     * declared ReturnType is boolean (or absent).
      * @param expression query to Check
      * @param module module specific query
      * @param validationErrorMessage optional validation error message; if provided, the error will be logged
      */
-    isValidBooleanExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
+    isValidScalarExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     /**
-     * Whether the given ObservableExpression is valid
-     * @param expression - ObservableExpression to check
-     * @param module - module specific query
-     * @param validationErrorMessage - optional validation error message; if provided, the error will be logged
-     */
-    isValidObservableExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
-    /**
-     * Whether the given AggregatedBooleanExpression is valid
-     * @param expression -  AggregatedBooleanExpression to check
-     * @param module - module specific query
-     * @param validationErrorMessage - optional validation error message; if provided, the error will be logged
+     * Whether the given Expression is a valid value-producing scalar expression
+     * (any return type — used by Calculated Column and non-boolean Named Queries).
      */
-    isValidAggregatedBooleanExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
+    isValidValueExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     /**
-     * Whether the given AggregatedScalarExpression is valid
-     * @param expression -  AggregatedScalarExpression to check
+     * Whether the given AggregatedExpression is valid
+     * @param expression - AggregatedExpression to check
      * @param module - module specific query
      * @param validationErrorMessage - optional validation error message; if provided, the error will be logged
      */
-    isValidAggregatedScalarExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
+    isValidAggregatedExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     /**
      * Returns all Columns referenced in an Expression
      * @param expression - expression to check
@@ -43,22 +39,111 @@ export interface ExpressionApi {
      */
     isColumnQueryable(abColumn: AdaptableColumn): boolean;
     /**
-     * Runs the AST that AdapTableQL creates for an Expression - useful when evaluating remotely
-     * @param expression expression to be run
+     * AST for remote / SSRM evaluation. Emits a normalized contract-v2 tree
+     * when `expressionOptions.supportedAstContractVersions` includes `2`;
+     * otherwise the raw parse tree (v1).
      */
     getASTForExpression(expression: string): any;
     /**
-     * Returns Expression string of given AdaptableQuery: can be Boolean, AggregatedBoolean, Scalar, AggregatedScalar or Observable
-     * @param query - the AdaptableQuery
+     * Infers the kind of an Expression from its text: `aggregated` when it contains an
+     * aggregation (e.g. `SUM{[col]}`), `scalar` otherwise — observable reads such as
+     * `CHANGE_COUNT{[col], WITHIN(5m)}` are scalar. Empty or unparseable text yields `scalar`.
+     * @param expression - the AdaptableQL Expression
+     * @param module - module whose custom functions are taken into account (default `'Expression'`)
+     */
+    getExpressionKind(expression: string, module?: AdaptableModule): ExpressionKind;
+    /**
+     * Returns the Expression string of a `Rule` / `Expression` property (pre-v25: `Query`).
+     *
+     * Since v25 these properties are plain strings and this method simply returns its argument;
+     * it still unwraps the pre-v25 object shape (`{ Expression }` / `{ AggregatedExpression }` /
+     * …) for callers that hold un-migrated objects.
+     *
+     * @deprecated `Rule` / `Expression` are strings; use them directly
+     * @param query - the Expression string (or pre-v25 wrapper object)
+     */
+    getAdaptableQueryExpression(query: string | Partial<LegacyAdaptableQuery> | undefined | null): string | undefined;
+    /**
+     * Returns the Expression string with column friendly names (instead of Column IDs)
+     * @param query - the Expression string (or pre-v25 wrapper object)
      */
-    getAdaptableQueryExpression(query: Partial<AdaptableQuery>): string | undefined;
+    getAdaptableQueryExpressionWithColumnFriendlyNames(query: string | Partial<LegacyAdaptableQuery> | undefined | null): string | undefined;
     /**
-     * Returns Expression string of given AdaptableQuery with column friendly names (instead of Column IDs)
-     * @param query - the AdaptableQuery
+     * Evaluates a Standard Expression against a row.
+     * Requires a row target (`rowNode`, `primaryKeyValue`, or `data`) on the request.
+     * Never throws — returns a result envelope with `success` / `errorMessage`.
+     *
+     * The Expression decides the return value: a condition such as `[price] > 100`
+     * yields `true` / `false`; `[price] * 1.19` yields a number.
+     *
+     * Direct API evaluation ignores `expressionOptions.evaluateAdaptableQLExternally`
+     * (that option only skips evaluation inside AdapTable features).
+     * @param request Expression + exactly one row target (`rowNode` / `primaryKeyValue` / `data`)
      */
-    getAdaptableQueryExpressionWithColumnFriendlyNames(query: Partial<AdaptableQuery>): string | undefined;
+    evaluateStandardExpression(request: EvaluateStandardExpressionRequest): ExpressionEvaluationResult<unknown>;
+    /**
+     * Evaluates an Aggregation Expression (e.g. `SUM{[price]}`,
+     * `MAX{[price], GROUP_BY([make])}`, `RANK{OVER([price])}`, `SUM{[price]} > 1000`)
+     * and returns a materialized snapshot: the global value, per-group values
+     * (for `GROUP_BY`) and a per-row projection (`getValueForRow`).
+     *
+     * When the Expression is a condition, `matches` is whether at least one
+     * aggregation group satisfies it.
+     *
+     * Default target is all loaded grid rows. Pass `dataSet` to aggregate a
+     * caller-supplied array, or `rowScope` / `rowFilter` to narrow the grid
+     * set. The snapshot does not update on data changes — re-evaluate when needed.
+     *
+     * Under the server-side row model only currently loaded rows are aggregated;
+     * inspect `rowCount` to detect partial data.
+     * @param request Expression + optional module / dataSet / rowScope / rowFilter
+     */
+    evaluateAggregatedExpression(request: EvaluateAggregatedExpressionRequest): ExpressionEvaluationResult<AggregatedExpressionEvaluationValue>;
+    /**
+     * Returns the grid rows matching a boolean Expression, scoped by `rowScope`
+     * and optionally pre-narrowed by `rowFilter`. Validation runs once; a
+     * per-row evaluation error fails the whole call. Matching `IRowNode`s are
+     * returned in source order.
+     * @param request Expression + optional rowScope / rowFilter / cellValueOverride / module
+     */
+    filterRowNodes(request: FilterRowNodesRequest): ExpressionEvaluationResult<IRowNode[]>;
+    /**
+     * Returns the subset of `dataSet` matching a boolean Expression, in original
+     * order and with the same object references. Validation runs once; a
+     * per-row evaluation error fails the whole call.
+     * @param request Expression + the array to filter
+     */
+    filterDataSet(request: FilterDataSetRequest): ExpressionEvaluationResult<Record<string, unknown>[]>;
+    /**
+     * Convert a leftover (pre-v24) AdaptableQL string to the v24 greenfield
+     * syntax. Unparseable input is returned unchanged with `error` set.
+     *
+     * v24 introduced brace aggregations (`SUM{[price]}`), named operands
+     * (`CUMULATIVE([d])`, `WITHIN(5m)`), and dropped wrappers such as
+     * `CUMUL(...)` and `TIMEFRAME(...)`. Persisted state is rewritten on
+     * load by VersionUpgrade24 when `autoMigrateState` is on. Use this for
+     * a single programmatic / external-config string that has not gone
+     * through that upgrade. The runtime does not accept leftover spellings.
+     *
+     * `expressionKind` is the stored module kind. Required for dual-name
+     * paren calls (`SUM([x])` scalar vs aggregation). Omit only when the
+     * leftover is shape-proven (`GROUP_BY` / `CUMUL` / `TIMEFRAME` / …).
+     */
+    migratePreV24Expression(expression: string, options?: {
+        expressionKind?: 'boolean' | 'scalar' | 'aggregatedScalar' | 'aggregatedBoolean';
+    }): {
+        expression: string;
+        changed: boolean;
+        error?: string;
+    };
     /**
      * Whether Expressions are evaluated using Case Sensitivity
      */
     useCaseSensitivity(): boolean;
+    /**
+     * Whether date comparisons use the full timestamp (exact instant) rather than
+     * the calendar day for the given column — governs the `IN` operator on date
+     * columns and the date Column Filter's distinct-value tree granularity.
+     */
+    shouldEvaluateDatesUsingTime(column: string | AdaptableColumn): boolean;
 }

package/src/Api/FlashingCellApi.d.ts

@@ -1,9 +1,6 @@
 import { AdaptableFlashingCell } from '../AdaptableState/Common/AdaptableFlashingCell';
-import { AdaptablePredicateDef } from '../AdaptableState/Common/AdaptablePredicate';
-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
  */
@@ -16,13 +13,13 @@ export interface FlashingCellApi {
     /**
      * Retrieves all Flashing Cell Definitions in Flashing Cell State
      */
-    getFlashingCellDefinitions(config?: LayoutExtendedConfig): FlashingCellDefinition[];
+    getFlashingCellDefinitions(): 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'], config?: LayoutExtendedConfig): FlashingCellDefinition;
+    getFlashingCellDefinitionById(id: FlashingCellDefinition['Uuid']): FlashingCellDefinition;
     /**
      * Retrieves a Flashing Cell Definition by its Name
      * @param name Name of the Flashing Cell Definition
@@ -33,12 +30,12 @@ export interface FlashingCellApi {
      * Retrieves all active (non-suspended) cell Definitions in Flashing Cell State
      * @returns flashing cell definitions
      */
-    getActiveFlashingCellDefinitions(config?: LayoutExtendedConfig): FlashingCellDefinition[];
+    getActiveFlashingCellDefinitions(): FlashingCellDefinition[];
     /**
      * Retrieves all suspended Cell Definitions in Flashing Cell State
      * @returns flashing cell definitions
      */
-    getSuspendedFlashingCellDefinitions(config?: LayoutExtendedConfig): FlashingCellDefinition[];
+    getSuspendedFlashingCellDefinitions(): FlashingCellDefinition[];
     /**
      * Returns `FlashTarget` of the given Flashing Cell Definition
      * @param flashingCellDefinition Flashing Cell Definition to check
@@ -102,11 +99,6 @@ export interface FlashingCellApi {
      * Activates all suspended Flashing Cell Definition
      */
     unSuspendAllFlashingCellDefinition(): void;
-    /**
-     * Retrieves all Predicate Defs that match given Scope
-     * @param scope the Scope to check
-     */
-    getFlashingCellPredicateDefsForScope(scope: ColumnScope): AdaptablePredicateDef[];
     /**
      * Clears all Cells and Rows which have been flashed (primarily used if duration is 'Always')
      */

package/src/Api/FormatColumnApi.d.ts

@@ -12,13 +12,13 @@ export interface FormatColumnApi {
      * Retrieves all Format Columns in Adaptable State
      * @returns format columns
      */
-    getFormatColumns(config?: FormatColumnConfig): FormatColumn[];
+    getFormatColumns(): FormatColumn[];
     /**
      * Retrieves Format Column by the technical ID (from `FormatColumnState`)
      * @param id Format Column id
      * @returns format column
      */
-    getFormatColumnByUuId(id: FormatColumn['Uuid'], config?: FormatColumnConfig): FormatColumn;
+    getFormatColumnByUuId(id: FormatColumn['Uuid']): FormatColumn;
     /**
      * Retrieves a Format Column by its Name
      * @param name Name of the Format Column
@@ -29,7 +29,7 @@ export interface FormatColumnApi {
      * Retrieves all active (not-suspended) Format Columns in Adaptable State
      * @returns format columns
      */
-    getActiveFormatColumns(config?: FormatColumnConfig): FormatColumn[];
+    getActiveFormatColumns(): FormatColumn[];
     /**
      * Retrieves the first Format Column's Adaptable Format for a given Column
      * @param column Column to check
@@ -39,7 +39,7 @@ export interface FormatColumnApi {
      * Retrieves all suspended Format Columns in Adaptable State
      * @returns format columns
      */
-    getSuspendedFormatColumns(config?: FormatColumnConfig): FormatColumn[];
+    getSuspendedFormatColumns(): FormatColumn[];
     /**
      * Adds a Format Column to Format Column State
      * @param formatColumn Format Column to Add

package/src/Api/GridApi.d.ts

@@ -60,6 +60,17 @@ export interface GridApi {
      * @param columnId the Column to read the values from
      */
     getVisibleColumnData(columnId: string): any[];
+    /**
+     * Retrieves the distinct raw values currently in a Column, sorted.
+     *
+     * Useful when building dropdown options (e.g. Action Column `select`, Forms)
+     * from values that already exist in the Grid.
+     *
+     * Returns an empty array if the Column is unknown.
+     *
+     * @param columnId the Column to read the values from
+     */
+    getDistinctColumnValues(columnId: string): any[];
     /**
      * Loads data into grid and fire a `RowChanged.trigger='Load'` event
      * @param data data to load

package/src/Api/GridFilterApi.d.ts

@@ -39,8 +39,8 @@ export interface GridFilterApi {
      */
     clearGridFilter(): void;
     /**
-     * Opens the AdapTableQL UI Components (Expression Editor & Query Builder)
-     * @param expression current Grid Filter expression
+     * Opens the Grid Filter Settings Panel (Expression Editor & Query Builder).
+     * @param expression unused — kept for API compatibility; editor uses the current Grid Filter
      */
     openUIEditorForGridFilter(expression?: string): void;
     /**

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

@@ -31,7 +31,6 @@ import { TeamSharingApi } from '../TeamSharingApi';
 import { ColumnApi } from '../ColumnApi';
 import { ApplicationApi } from '../ApplicationApi';
 import { ColumnScopeApi } from '../ColumnScopeApi';
-import { PredicateApi } from '../PredicateApi';
 import { DataChangeHistoryApi } from '../DataChangeHistoryApi';
 import { FlashingCellApi } from '../FlashingCellApi';
 import { ChartingApi } from '../ChartingApi';
@@ -50,7 +49,6 @@ export declare class AdaptableApiImpl implements AdaptableApi {
     applicationApi: ApplicationApi;
     alertApi: AlertApi;
     flashingCellApi: FlashingCellApi;
-    predicateApi: PredicateApi;
     bulkUpdateApi: BulkUpdateApi;
     calendarApi: CalendarApi;
     calculatedColumnApi: CalculatedColumnApi;

package/src/Api/Implementation/AdaptableApiImpl.js

@@ -1,6 +1,5 @@
 import { AlertApiImpl } from './AlertApiImpl';
 import { StatusBarApiImpl } from './StatusBarApiImpl';
-import { PredicateApiImpl } from './PredicateApiImpl';
 import { PluginsApiImpl } from './PluginsApiImpl';
 import { BulkUpdateApiImpl } from './BulkUpdateApiImpl';
 import { CalculatedColumnApiImpl } from './CalculatedColumnApiImpl';
@@ -55,7 +54,6 @@ export class AdaptableApiImpl {
     applicationApi;
     alertApi;
     flashingCellApi;
-    predicateApi;
     bulkUpdateApi;
     calendarApi;
     calculatedColumnApi;
@@ -108,7 +106,6 @@ export class AdaptableApiImpl {
         this.applicationApi = new ApplicationApiImpl(adaptable);
         this.alertApi = new AlertApiImpl(adaptable);
         this.flashingCellApi = new FlashingCellApiImpl(adaptable);
-        this.predicateApi = new PredicateApiImpl(adaptable);
         this.pluginsApi = new PluginsApiImpl(adaptable);
         this.bulkUpdateApi = new BulkUpdateApiImpl(adaptable);
         this.calendarApi = new CalendarApiImpl(adaptable);
@@ -163,6 +160,8 @@ export class AdaptableApiImpl {
         this.destroyed = true;
         this.eventApi.destroy();
         this.exportApi.internalApi.destroy();
+        this.expressionApi.internalApi.destroy();
+        this.alertApi?.internalApi?.destroy();
         this.internalApi = null;
         this.adaptable = null;
         this.optionsApi = null;
@@ -191,7 +190,6 @@ export class AdaptableApiImpl {
         this.layoutApi = null;
         this.pluginsApi = null;
         this.plusMinusApi = null;
-        this.predicateApi = null;
         this.expressionApi = null;
         this.quickSearchApi = null;
         this.columnScopeApi = null;