@adaptabletools/adaptable 24.0.0-canary.0 → 24.0.0-canary.10

package/index.d.ts

@@ -1,4 +1,4 @@
-import Adaptable, { AdaptableWizardView } from './src/agGrid';
+import Adaptable from './src/agGrid';
 import { AdaptableAgGrid } from './src/agGrid/AdaptableAgGrid';
 import { AdaptableNumberEditor, AdaptableReactNumberEditor } from './src/agGrid/editors/AdaptableNumberEditor';
 import { AdaptablePercentageEditor, AdaptableReactPercentageEditor } from './src/agGrid/editors/AdaptablePercentageEditor';
@@ -10,7 +10,6 @@ export * from './src/types';
 export default Adaptable;
 export { Adaptable };
 export declare const _AdaptableAgGrid: typeof AdaptableAgGrid;
-export declare const AdaptableNoCodeWizard: typeof import("./src/agGrid/Adaptable").AdaptableNoCodeWizard;
 export declare const _AdaptableLogger: typeof import("./src/types").AdaptableLogger;
 export declare const AdaptableQL: {
     ScalarFunctions: import("./vendor/aql/index.js").ScalarFunctionName[];
@@ -59,4 +58,4 @@ export declare const AdaptableColumnType: {
      */
     PivotAggregationTotal: import("./src/types").AdaptableColumnTypeName;
 };
-export { iconToString as getIconSVG, AdaptableReactPercentageEditor, AdaptableReactNumberEditor, AdaptableReactDateEditor, AdaptablePercentageEditor, AdaptableNumberEditor, AdaptableDateEditor, AdaptableWizardView, AdaptableUpgradeHelper, type UpgradeConfig, };
+export { iconToString as getIconSVG, AdaptableReactPercentageEditor, AdaptableReactNumberEditor, AdaptableReactDateEditor, AdaptablePercentageEditor, AdaptableNumberEditor, AdaptableDateEditor, AdaptableUpgradeHelper, type UpgradeConfig, };

package/index.js

@@ -1,4 +1,4 @@
-import Adaptable, { AdaptableNoCodeWizard as ABWizard, AdaptableWizardView, AdaptableLogger as ABLogger, } from './src/agGrid';
+import Adaptable, { AdaptableLogger as ABLogger } from './src/agGrid';
 import { AdaptableAgGrid } from './src/agGrid/AdaptableAgGrid';
 import { aggregationCallableNames as aggregatedScalarExpressionFunctionNames, scalarFunctionNames as scalarExpressionFunctionNames, } from "./vendor/aql/index.js";
 import { AdaptableNumberEditor, AdaptableReactNumberEditor, } from './src/agGrid/editors/AdaptableNumberEditor';
@@ -12,7 +12,6 @@ export * from './src/types';
 export default Adaptable;
 export { Adaptable };
 export const _AdaptableAgGrid = AdaptableAgGrid;
-export const AdaptableNoCodeWizard = ABWizard;
 export const _AdaptableLogger = ABLogger;
 export const AdaptableQL = {
     ScalarFunctions: scalarExpressionFunctionNames,
@@ -31,4 +30,4 @@ export const AdaptableColumnType = {
     PivotColumnTotal: PIVOT_COLUMN_TOTAL_COLUMN_TYPE,
     PivotAggregationTotal: PIVOT_AGGREGATION_TOTAL_COLUMN_TYPE,
 };
-export { iconToString as getIconSVG, AdaptableReactPercentageEditor, AdaptableReactNumberEditor, AdaptableReactDateEditor, AdaptablePercentageEditor, AdaptableNumberEditor, AdaptableDateEditor, AdaptableWizardView, AdaptableUpgradeHelper, };
+export { iconToString as getIconSVG, AdaptableReactPercentageEditor, AdaptableReactNumberEditor, AdaptableReactDateEditor, AdaptablePercentageEditor, AdaptableNumberEditor, AdaptableDateEditor, AdaptableUpgradeHelper, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "24.0.0-canary.0",
+  "version": "24.0.0-canary.10",
   "description": "Powerful AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",
@@ -43,12 +43,12 @@
   "typings": "index.d.ts",
   "dependencies": {
     "@base-ui/react": "1.7.0",
-    "@codemirror/autocomplete": "^6.20.3",
-    "@codemirror/commands": "^6.11.0",
-    "@codemirror/language": "^6.12.4",
-    "@codemirror/lint": "^6.9.7",
-    "@codemirror/state": "^6.7.1",
-    "@codemirror/view": "^6.43.9",
+    "@codemirror/autocomplete": "6.20.3",
+    "@codemirror/commands": "6.11.1",
+    "@codemirror/language": "6.12.4",
+    "@codemirror/lint": "6.9.7",
+    "@codemirror/state": "6.7.6",
+    "@codemirror/view": "6.43.13",
     "@finos/fdc3": "2.1.0",
     "@infinite-table/infinite-react": "8.0.3",
     "@tanstack/react-virtual": "^3.13.22",
@@ -59,6 +59,7 @@
     "normalize.css": "^8.0.1",
     "re-resizable": "6.10.3",
     "react": "^18.0.0 || ^19.0.0",
+    "react-colorful": "^5.8.1",
     "react-day-picker": "^9.14.0",
     "react-dom": "^18.0.0 || ^19.0.0",
     "react-redux": "9.2.0",

package/src/AdaptableInterfaces/IAdaptable.d.ts

@@ -9,7 +9,7 @@ import { SelectedCellInfo } from '../AdaptableState/Selection/SelectedCellInfo';
 import { AdaptableTheme } from '../AdaptableState/ThemeState';
 import { IAdaptableStore } from '../Redux/Store/Interface/IAdaptableStore';
 import { IModuleCollection } from '../Strategy/Interface/IModule';
-import { AdaptableMenuItem, AdaptableOptions, AdaptablePlugin, AdaptableState, ChartDefinition, InFilterValueResult, SelectedRowInfo } from '../types';
+import { AdaptableMenuItem, AdaptableOptions, AdaptablePersistentState, AdaptablePlugin, ChartDefinition, InFilterValueResult, SelectedRowInfo } from '../types';
 import { ICalculatedColumnExpressionService } from '../Utilities/Services/Interface/ICalculatedColumnExpressionService';
 import { IDataService } from '../Utilities/Services/Interface/IDataService';
 import { CommentsService } from '../Utilities/Services/CommentsService';
@@ -326,17 +326,17 @@ export interface IAdaptable {
     canExportToExcel(): boolean;
     canExportToCsv(): boolean;
     silentUpdateCurrentLayoutModel(layoutModel?: TableLayoutModel | PivotLayoutModel): void;
-    normalizeAdaptableState(state: AdaptableState, options: NormalizeAdaptableStateOptions): AdaptableState;
+    normalizeAdaptableState(state: Partial<AdaptablePersistentState>, options: NormalizeAdaptableStateOptions): Partial<AdaptablePersistentState>;
     /**
      * Runs the startup upgrade chain when `stateOptions.autoMigrateState` is on.
      * A no-op when migration is disabled or the state is already current.
      */
-    migrateLoadedAdaptableState(state: AdaptableState): AdaptableState;
+    migrateLoadedAdaptableState<T extends Partial<AdaptablePersistentState>>(state: T): T;
     /**
      * `loadStore` hook used at startup and when the state key changes:
      * migrate (when enabled), then normalise.
      */
-    buildPostLoadHook(gridOptions: NormalizeAdaptableStateOptions): (state: AdaptableState) => AdaptableState;
+    buildPostLoadHook(gridOptions: NormalizeAdaptableStateOptions): (state: Partial<AdaptablePersistentState>) => Partial<AdaptablePersistentState>;
     refreshLayout(): void;
 }
 export type NormalizeAdaptableStateOptions = Pick<GridOptions, 'rowModelType' | 'treeData' | 'columnDefs' | 'autoGroupColumnDef' | 'defaultColDef' | 'pivotMode'>;

package/src/AdaptableOptions/ActionColumnOptions.d.ts

@@ -121,6 +121,9 @@ export type ActionColumnControl<TData = any, CTX = ActionColumnContext<TData>> =
  * A standard clickable button.
  */
 export interface ButtonControl<TData = any, CTX = ActionColumnContext<TData>> extends BaseControl<TData, CTX> {
+    /**
+     * Discriminator. Set to `'button'`.
+     */
     type: 'button';
     /**
      * Handler invoked when the button is clicked. May return a `Promise`, in which
@@ -140,6 +143,9 @@ export interface ButtonControl<TData = any, CTX = ActionColumnContext<TData>> ex
  * A built-in Row command (opens the relevant Row Form).
  */
 export interface CommandControl<TData = any, CTX = ActionColumnContext<TData>> extends BaseControl<TData, CTX> {
+    /**
+     * Discriminator. Set to `'command'`.
+     */
     type: 'command';
     /**
      * The built-in command to run: `'create'`, `'clone'`, `'edit'` or `'delete'`.
@@ -154,6 +160,9 @@ export interface CommandControl<TData = any, CTX = ActionColumnContext<TData>> e
  * Shared properties for {@link ToggleControl}.
  */
 export interface ToggleControlBase<TData = any, CTX = ActionColumnContext<TData>> extends BaseControl<TData, CTX> {
+    /**
+     * Discriminator. Set to `'toggle'`.
+     */
     type: 'toggle';
     /**
      * How the toggle is rendered:
@@ -197,6 +206,9 @@ export type ToggleControl<TData = any, CTX = ActionColumnContext<TData>> = Toggl
  * A hyperlink (external URL, `mailto:`, internal drill-through, etc.).
  */
 export interface LinkControl<TData = any, CTX = ActionColumnContext<TData>> extends BaseControl<TData, CTX> {
+    /**
+     * Discriminator. Set to `'link'`.
+     */
     type: 'link';
     /**
      * The link target - static string or a function of the context.
@@ -212,6 +224,9 @@ export interface LinkControl<TData = any, CTX = ActionColumnContext<TData>> exte
  * A dropdown that fires `onChange` when a value is selected (e.g. to set a status).
  */
 export interface SelectControl<TData = any, CTX = ActionColumnContext<TData>> extends BaseControl<TData, CTX> {
+    /**
+     * Discriminator. Set to `'select'`.
+     */
     type: 'select';
     /**
      * The options to choose from - a static array or a function of the context.
@@ -236,6 +251,9 @@ export interface SelectControl<TData = any, CTX = ActionColumnContext<TData>> ex
  * dropdown menus and split buttons (a primary action plus a chevron of extras).
  */
 export interface MenuControl<TData = any, CTX = ActionColumnContext<TData>> extends BaseControl<TData, CTX> {
+    /**
+     * Discriminator. Set to `'menu'`.
+     */
     type: 'menu';
     /**
      * `'dropdown'` (default) shows a single trigger; `'split'` renders `primary`
@@ -257,6 +275,9 @@ export interface MenuControl<TData = any, CTX = ActionColumnContext<TData>> exte
  * row, reusing the full Adaptable Form engine (fields, validation, layout).
  */
 export interface FormControl<TData = any, CTX = ActionColumnContext<TData>> extends BaseControl<TData, CTX> {
+    /**
+     * Discriminator. Set to `'form'`.
+     */
     type: 'form';
     /**
      * The Form to display. Its `onSubmit` receives the entered `formData` and the
@@ -272,6 +293,9 @@ export interface FormControl<TData = any, CTX = ActionColumnContext<TData>> exte
  * Escape hatch: render bespoke framework content (React / Angular / Vue) in the cell.
  */
 export interface CustomControl<TData = any, CTX = ActionColumnContext<TData>> extends BaseControl<TData, CTX> {
+    /**
+     * Discriminator. Set to `'custom'`.
+     */
     type: 'custom';
     /**
      * React render function returning a node for the cell, with full row context injected.

package/src/AdaptableOptions/AdaptableOptions.d.ts

@@ -36,229 +36,257 @@ import { ContextMenuOptions } from './ContextMenuOptions';
 import { FilterOptions } from './FilterOptions';
 import { RowFormOptions } from './RowFormOptions';
 /**
- * Large group of options enabling developers to set up AdapTable at design time to fit precise requirements
+ * Design-time configuration for one AdapTable instance.
+ *
+ * These options are fixed by the application. Objects the user can change and that are persisted (Layouts, Alerts, Format Columns, Calculated Columns and the other module objects) belong in {@link initialState}, not here.
+ *
+ * `primaryKey` and `initialState` are required. Every `*Options` property is optional: omit it to keep that module's defaults.
  */
 export interface AdaptableOptions<TData = any, TContext = Record<string, any>> {
     /**
-     * Identifier for this instance of AdapTable
+     * Identifies this grid when more than one AdapTable is on the page.
+     *
+     * Also the default key under which state is stored, unless {@link adaptableStateKey} is set. A generated id (`adaptable_id_` plus a random number) is used when this is omitted, so state will not survive a reload.
      *
      * @defaultValue 'adaptable_id_${random_number}'
-     * @noCodeItem
      */
     adaptableId?: string;
     /**
-     * Identifier used as localStorage persistence key for AdaptableState
+     * Key under which this grid's state is stored, instead of {@link adaptableId}.
+     *
+     * Set it when several grids should share one state, or when the storage key should change without changing `adaptableId`. {@link initialState} is applied only when nothing is already stored under this key.
      *
      * @defaultValue `adaptableId` value
      */
     adaptableStateKey?: string;
     /**
-     * Will autogenerate a Primary Key; only use as a last resort if no unique column is available, as limits some Adaptable functionalities
+     * Invents a primary key when the data has no unique column.
+     *
+     * Use it only as a last resort. Notes, comments, data-change history and row identity then cannot follow a real business key, and some of those features are limited.
      *
      * @defaultValue false
      */
     autogeneratePrimaryKey?: boolean;
     /**
-     * Commercial license key. If the license is not provided or is expired, various visual information notes will be displayed and some functionality may be limited.
+     * Commercial licence key.
+     *
+     * Without a current licence, AdapTable shows licence notices and limits some functionality.
      */
     licenseKey?: string;
     /**
-     * Application-specific context object - is included by AdapTable in all callbacks and Events
+     * Values from the host application, passed into every callback and event as `adaptableContext`.
+     *
+     * Use it for things the grid should see but not store, such as the current user, permissions or a service. It is not persisted.
      *
      * @defaultValue {}
      */
     adaptableContext?: TContext;
     /**
-     * Initial State set at design-time and shipped with AdapTable for first use; must include at least one Layout
+     * Objects shipped with the grid for its first run: at least one Layout, plus any Alerts, Format Columns, Calculated Columns and other module objects.
+     *
+     * Applied only when no state is already stored for this grid. After that, the stored state is used and later edits to `initialState` are ignored until that stored state is cleared or the state key changes.
      *
      * @defaultValue undefined
      */
     initialState: InitialState;
     /**
-     * Name of Column in AdapTable guaranteed to contain unique values
+     * Column whose values uniquely identify a row. Required.
+     *
+     * AdapTable uses it to find a row for edits, notes, comments, alerts, history and row forms. The values must be unique.
      *
      * @defaultValue n/a (Mandatory)
      */
     primaryKey: string;
     /**
-     * Name of current AdapTable user
+     * Name of the person using this grid.
+     *
+     * Stamped on Notes and Comments when the author is not supplied, and shown where Team Sharing records who shared an object.
      *
      * @defaultValue 'anonymous'
      */
     userName?: string;
     /**
-     * Options for managing Action Columns
+     * Action Columns: columns of buttons, menus, toggles and other controls that run an action on the row.
+     *
+     * The columns themselves are supplied here. They are not part of Initial State.
      */
     actionColumnOptions?: ActionColumnOptions<TData>;
     /**
-     * Options for managing Alerts in AdapTable
+     * How fired alerts behave: how many are kept, how long a cell or row stays highlighted, and the text shown when an alert fires.
      *
-     * @noCodeContainer
+     * The Alert Definitions themselves (the rules) belong in Initial State.
      */
     alertOptions?: AlertOptions<TData>;
     /**
-     * Options for managing Holidays and Working Days
+     * Which days are working days. Weekend days and holidays are excluded from working-day expression functions.
      */
     calendarOptions?: CalendarOptions;
     /**
-     * Options for adding custom Cell Summaries
+     * Extra summary operations for the selected cells, beyond the ones AdapTable ships (sum, average and the rest), and how the result is formatted.
      */
     cellSummaryOptions?: CellSummaryOptions<TData>;
     /**
-     * Options for managing AG Grid's Charting
-     * @noCodeContainer
+     * Saving and reopening AG Grid charts, which containers they open in, and external (non-AG Grid) charts.
+     *
+     * Chart definitions the user saves are stored in state. These options control that behaviour.
      */
     chartingOptions?: ChartingOptions;
     /**
-     * Options related to Columns
-     * @noCodeContainer
+     * Column captions and friendly names, column types used by Column Scope, and whether a missing column is logged.
      */
     columnOptions?: ColumnOptions;
     /**
-     * Options for managing AdapTable Column Menu
-     *
+     * Replaces or extends the menu opened from a column header. The callback receives AdapTable's default items.
      */
     columnMenuOptions?: ColumnMenuOptions<TData>;
     /**
-     * Options for managing collaborative Comments
+     * Comments on cells: which cells can be commented, and how threads are loaded and saved.
+     *
+     * Comments are not part of AdapTable State. The application loads and persists them through these callbacks.
      */
     commentOptions?: CommentOptions<TData>;
     /**
-     * Options for managing Calculated Columns (e.g. Formula Trace)
+     * Calculated Columns whose values come from an AdapTableQL expression: formula trace, and how often aggregated columns recompute after row changes.
+     *
+     * The column definitions belong in Initial State.
      */
     calculatedColumnOptions?: CalculatedColumnOptions;
     /**
-     * Options for setting the 'Div' elements in which AdapTable, AG Grid, popups are placed
+     * DOM elements that host the grid, the AG Grid instance, the Settings Panel, alerts, system status and the transposed view.
+     *
+     * Set these when AdapTable is not mounted into the default divs.
      */
     containerOptions?: ContainerOptions;
     /**
-     * Options for managing AdapTable Context Menu
-     *
+     * Replaces or extends the right-click menu. The callback receives AdapTable's default items.
      */
     contextMenuOptions?: ContextMenuOptions<TData>;
     /**
-     * Options for using Custom Sort
+     * Comparer functions for a Custom Sort, used when the sort order is not a simple list of values.
+     *
+     * The Custom Sort objects (the ordered values) belong in Initial State.
      */
     customSortOptions?: CustomSortOptions;
     /**
-     * Options for managing the Dashboard in AdapTable
+     * The Dashboard above the grid: whether it can float, custom toolbars and buttons, and where the module buttons sit.
      *
-     * @noCodeContainer
+     * Which toolbars are on each tab is stored in Dashboard state.
      */
     dashboardOptions?: DashboardOptions;
     /**
-     * Options to manage Data Change History Module which provides an overview of all data changes
-     *
-     * @noCodeContainer
+     * The log of cell value changes: whether it starts active, which changes are recorded, and the undo button.
      */
     dataChangeHistoryOptions?: DataChangeHistoryOptions<TData>;
     /**
-     * Options for managing the Data Import function
+     * The import wizard: how a file or pasted text becomes rows, how those rows are validated, and how they are written into the grid.
      */
     dataImportOptions?: DataImportOptions;
     /**
-     * Options to manage Data Sets
+     * Named sets of rows the user can switch between. Each set supplies its own data.
      */
     dataSetOptions?: DataSetOptions<TData>;
     /**
-     * Options related to Editing in AdapTable including Server Validation
-     *
+     * Cell editing: which cells can be edited, server-side validation, the values offered in a dropdown editor, Plus Minus nudges and Smart Edit.
      */
     editOptions?: EditOptions<TData>;
     /**
-     * Options for managing Entitlements
+     * Which modules a user may see or change. `Full`, `ReadOnly` or `Hidden`, per module or as a default.
      *
+     * A module that defaults to hidden (such as State) stays hidden until `moduleEntitlements` allows it.
      */
     entitlementOptions?: EntitlementOptions;
     /**
-     * Options for managing Exporting and Reports in AdapTable
+     * Reports: which system reports, formats and destinations are offered, custom destinations, and whether a column is included.
      *
+     * Report definitions the user creates are stored in Export state.
      */
     exportOptions?: ExportOptions<TData>;
     /**
-     * Options for managing AdapTableQL Expressions
-     * @noCodeContainer
+     * AdapTableQL: custom functions, which columns and fields an expression may use, case sensitivity, and how the expression editor is presented.
+     *
+     * Expressions saved on objects (a filter, an alert rule, a calculated column) live on those objects. These options change how every expression is evaluated and edited.
      */
     expressionOptions?: ExpressionOptions<TData>;
     /**
-     * Options for managing FDC3 in AdapTable
+     * FDC3: which intents and contexts this grid raises, listens for and broadcasts, and how a row's columns map onto an FDC3 context.
      */
     fdc3Options?: Fdc3Options;
     /**
-     * Options for managing Flashing Cells - primarily default values
+     * Defaults for a flashing cell when a Flashing Cell definition does not set them: up, down and neutral styles, whether the cell or the row flashes, and for how long.
      *
+     * The definitions themselves belong in Initial State.
      */
     flashingCellOptions?: FlashingCellOptions;
     /**
-     * Options for providing Custom Display Formats
+     * Display formatters beyond the ones AdapTable ships, used by Format Columns.
+     *
+     * The Format Column objects (which column, which style and format) belong in Initial State.
      */
     formatColumnOptions?: FormatColumnOptions;
     /**
-     * Filtering Options - both Column Filters and the Grid Filter
+     * Column Filters and the Grid Filter: whether AdapTable's filters are used instead of AG Grid's, the quick filter bar, and the default operator for each data type.
+     *
+     * The filters the user creates are stored in the Layout.
      */
     filterOptions?: FilterOptions<TData>;
     /**
-     * Options related to Layouts
+     * How Layouts are created and shown: a layout built from the AG Grid column definitions, defaults for a new Table or Pivot Layout, and whether layout extensions are offered in the UI.
      *
-     * @noCodeContainer
+     * The Layout objects belong in Initial State. A grid needs at least one.
      */
     layoutOptions?: LayoutOptions<TData>;
     /**
-     * Options for managing personal Notes
+     * Notes on cells: which cells can hold a note, the note type applied on creation, and how the timestamp is formatted.
+     *
+     * The notes themselves are stored in Note state.
      */
     noteOptions?: NoteOptions;
     /**
-     * Options for managing Notifications in AdapTable
-     *
-     * @noCodeContainer
+     * Toasts: where they appear, how long they stay, and how many system status messages are kept.
      */
     notificationsOptions?: NotificationsOptions;
     /**
-     * Options for managing Search related functions in AdapTable
-     *
-     * @noCodeContainer
+     * Quick Search: which cells are searched, whether matching rows are filtered, and whether the search is case sensitive.
      */
     quickSearchOptions?: QuickSearchOptions<TData>;
     /**
-     * Options for managing Row Forms
+     * Create, clone and edit forms for a row: which columns appear, how the primary key of a new row is set, and whether AdapTable writes the result into the grid.
      */
     rowFormOptions?: RowFormOptions<TData>;
     /**
-     * Setting panel options
-     *
-     * @noCodeContainer
+     * The Settings Panel: its title and icon, which modules appear and in which groups, and whether it opens as a modal or a movable window.
      */
     settingsPanelOptions?: SettingsPanelOptions;
     /**
-     * Options for managing Wizards (and other action popups such as Bulk Update,
-     * Smart Edit and Cell Summary) — controls their `popupType`, initial
-     * `position` and `size` independently of the Settings Panel.
+     * Wizards and the other action popups (Bulk Update, Smart Edit, Cell Summary): modal or window, and the window's position and size.
      *
-     * @noCodeContainer
+     * Independent of the Settings Panel. Ignored when `containerOptions.modalContainer` places every popup in one element.
      */
     wizardOptions?: WizardOptions;
     /**
-     * Options related to state hydration / dehydration - allows users to intercept state persistence and state loading and change default behaviour of saving to local storage
+     * Where state is loaded from and saved to. The default is `localStorage`.
+     *
+     * Replace `loadState` and `persistState` to keep state on a server. `saveState` and `applyState` change the object just before it is stored or applied.
      */
     stateOptions?: StateOptions;
     /**
-     * Options for managing 'Team Sharing' which allows users to create Adaptable Objects and share with colleagues
+     * Sharing Adaptable Objects with other users. The application loads and saves the shared objects; AdapTable does not ship a server.
      *
+     * Turn it on with `enableTeamSharing`, then provide `loadSharedEntities` and `persistSharedEntities`.
      */
     teamSharingOptions?: TeamSharingOptions;
     /**
-     * Options related to managing the Tool Panel elements in AdapTable
-     *
-     * @noCodeContainer
+     * The tool panel beside the grid: custom panels, custom buttons, and whether the panel dropdown is shown.
      */
     toolPanelOptions?: ToolPanelOptions;
     /**
-     * Options for managing the User Interface elements of AdapTable, i.e. Action Columns, Color Palette etc.
-     *
+     * Shared UI: the application icon, custom icons, editable and read-only cell styles, the colour picker, date inputs, the loading screen, and the names shown for modules.
      */
     userInterfaceOptions?: UserInterfaceOptions<TData>;
     /**
-     * Used for managing the AdapTable Plugins
+     * Plugins constructed by the application and handed to AdapTable: OpenFin, ipushpull, interop.io and Master-Detail.
+     *
+     * Each plugin is created with its own options. This array registers them.
      */
     plugins?: AdaptablePlugin[];
 }