@adaptabletools/adaptable 24.0.0-canary.8 → 24.0.0-canary.9

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[];
 }

package/src/AdaptableOptions/AdaptablePlugin.d.ts

@@ -13,37 +13,149 @@ type AdaptableReducerObject = {
     [key: string]: (...args: any[]) => any;
 };
 /**
- * Base class for all AdapTable Plugins
+ * Base class for an AdapTable plugin (OpenFin, ipushpull, interop.io, Master-Detail).
+ *
+ * Construct the plugin with its options and pass the instance in `AdaptableOptions.plugins`. The lifecycle methods run in the order they are declared.
  */
 export declare abstract class AdaptablePlugin {
+    /**
+     * Options the plugin was constructed with.
+     */
     options?: any;
+    /**
+     * Named callbacks the plugin registers for AdapTable to call.
+     */
     private values;
+    /**
+     * Id of this plugin. AdapTable uses it to find the plugin and its state.
+     */
     pluginId: string;
     constructor(options?: any);
+    /**
+     * Registers a named callback for AdapTable to call later via {@link AdaptablePlugin.getProperty}.
+     *
+     * @param name Callback name
+     * @param fn Function AdapTable will invoke
+     */
     registerProperty(name: string, fn: (...args: any) => any): void;
+    /**
+     * Returns a function that calls the callback registered under `name`.
+     *
+     * The returned function does nothing when no callback is registered.
+     *
+     * @param name Callback name passed to {@link AdaptablePlugin.registerProperty}
+     * @returns A function that invokes the registered callback
+     */
     getProperty(name: string): any;
+    /**
+     * Adds the plugin's reducers to AdapTable's store.
+     */
     rootReducer?: (rootReducer: AdaptableReducerObject) => AdaptableReducerObject;
+    /**
+     * Redux middleware the plugin adds to the store.
+     */
     reduxMiddleware?: (adaptable: IAdaptable) => Redux.Middleware;
+    /**
+     * Whether a callback was registered under `name`.
+     *
+     * @param name Callback name passed to {@link AdaptablePlugin.registerProperty}
+     * @returns `true` when that callback exists
+     */
     hasProperty(name: string): boolean;
+    /**
+     * Runs before AdapTable initialises. Change `adaptableOptions` or the AG Grid options here.
+     *
+     * @param adaptableOptions Options about to be used
+     * @param agGridOptions AG Grid options about to be used
+     */
     beforeInit(adaptableOptions: AdaptableOptions, agGridOptions: AgGridConfig): void;
+    /**
+     * Runs after AdapTable Options have been normalised.
+     *
+     * @param adaptable The AdapTable instance
+     * @param adaptableOptions Normalised options
+     */
     afterInitOptions(adaptable: IAdaptable, adaptableOptions: AdaptableOptions): void;
+    /**
+     * Runs after `adaptableApi` exists.
+     *
+     * @param adaptable The AdapTable instance
+     * @param api AdapTable API
+     */
     afterInitApi(adaptable: IAdaptable, api: AdaptableApi): void;
+    /**
+     * Runs after AdapTable's internal services exist.
+     *
+     * @param adaptable The AdapTable instance
+     */
     afterInitServices(adaptable: IAdaptable): void;
+    /**
+     * Runs after Initial State has been loaded into the store.
+     *
+     * @param adaptable The AdapTable instance
+     */
     afterInitialStateLoaded(adaptable: IAdaptable): void;
+    /**
+     * Runs after AdapTable modules have been created.
+     *
+     * @param adaptable The AdapTable instance
+     * @param strategies Modules, keyed by module name
+     */
     afterInitModules(adaptable: IAdaptable, strategies: Map<AdaptableModule, IModule>): void;
+    /**
+     * Runs after the AdapTable store exists.
+     *
+     * @param adaptable The AdapTable instance
+     */
     afterInitStore(adaptable: IAdaptable): void;
+    /**
+     * Runs at the end of initialisation, before `AdaptableReady`.
+     *
+     * @param ab The AdapTable instance
+     */
     afterInit(ab: IAdaptable): void;
+    /**
+     * Runs after each Layout is applied.
+     *
+     * @param adaptable The AdapTable instance
+     * @param layout Layout that was applied
+     */
     afterSetLayout(adaptable: IAdaptable, layout: Layout): void;
+    /**
+     * Runs synchronously before a store action is reduced.
+     *
+     * @param eventName Redux action type
+     * @param data Action and the state before it is applied
+     * @param adaptableStore AdapTable store
+     */
     onBeforeStoreEvent(eventName: string, data: {
         action: Redux.Action;
         state: AdaptableState;
     }, adaptableStore: IAdaptableStore): void;
+    /**
+     * Runs after a store action has been reduced.
+     *
+     * @param eventName Redux action type
+     * @param data Action, the state before it, and the state after it
+     * @param adaptableStore AdapTable store
+     */
     onStoreEvent(eventName: string, data: {
         action: Redux.Action;
         state: AdaptableState;
         newState: AdaptableState;
     }, adaptableStore: IAdaptableStore): void;
+    /**
+     * Runs when AdapTable fires `AdaptableReady`.
+     *
+     * @param adaptable The AdapTable instance
+     * @param adaptableOptions Options the instance was created with
+     */
     onAdaptableReady(adaptable: IAdaptable, adaptableOptions: AdaptableOptions): void;
+    /**
+     * Changes one AG Grid column property while AdapTable is building the column.
+     *
+     * Return the value to use, or `undefined` to leave the current value.
+     */
     interceptSetupColumnProperty?: <T extends keyof ColDef>(columnSetupInfo: ColumnSetupInfo, propertyName: T, currentValue: ColDef[T] | undefined, api: AdaptableApi) => ColDef[T] | undefined;
 }
 export {};

package/src/AdaptableOptions/AlertOptions.d.ts

@@ -11,7 +11,6 @@ export interface AlertOptions<TData = any> {
      * How many alerts held in State at any one time; when limit is breached, oldest alert will be removed
      *
      * @defaultValue  20
-     * @noCodeItem
      */
     maxAlertsInStore?: number;
     /**
@@ -58,7 +57,6 @@ export interface AlertOptions<TData = any> {
      * Shows Alert if Primary Key column in Adaptable Options is not present or incorrect
      *
      * @defaultValue false
-     * @noCodeItem
      * @uiLabel Show Missing Primary Key Warning
      */
     showMissingPrimaryKeyAlert?: boolean;

package/src/AdaptableOptions/ChartingOptions.d.ts

@@ -1,13 +1,14 @@
 import { ExternalChartDefinition } from '../AdaptableState/ChartingState';
 import { BaseContext } from '../types';
 /**
- * Options for managing AG Grid's Charts
+ * How charts are saved and where they open.
+ *
+ * AG Grid chart definitions the user saves are stored in Charting state. These options decide whether that happens automatically, and which element a chart is drawn into.
  */
 export interface ChartingOptions {
     /**
      * Behaviour for saving Charts: auto, manual (via popup) or none
      * @defaultValue 'none'
-     * @noCodeItem
      */
     saveChartBehaviour?: SaveChartBehaviour;
     /**
@@ -18,16 +19,21 @@ export interface ChartingOptions {
      */
     restoreChartsOnReady?: boolean | 'all' | string[];
     /**
-     * Locations to display saved Charts
+     * Elements a saved chart can be drawn into, offered by name when the user opens a chart.
+     *
+     * Omit this to open charts only in AG Grid's own window.
      */
     chartContainers?: ChartContainer[];
     /**
-     * Name of AG Grid Chart Container
+     * Name shown for AG Grid's own chart window in the container list.
+     *
      * @defaultValue 'AG Grid Window'
      */
     agGridContainerName?: string;
     /**
-     * Set of properties for managing behaviour of external (i.e non AG Grid) charts
+     * Show, hide, delete and preview for charts that are not AG Grid charts.
+     *
+     * Required when the chart is drawn by the application. AdapTable calls these instead of opening an AG Grid chart.
      *
      * @defaultValue {}
      */

package/src/AdaptableOptions/ColumnMenuOptions.d.ts

@@ -30,10 +30,25 @@ export interface CustomColumnMenuContext<TData = any> extends ColumnMenuContext<
      * Default structure of AG Grid Menu Items
      */
     defaultAgGridMenuStructure: (AgGridMenuItem<AgGridColumnMenuItemType> | {
+        /**
+         * Always `Group`. The item is a submenu of AG Grid column-menu entries.
+         */
         menuType: 'Group';
+        /**
+         * Text of the submenu.
+         */
         label: string;
+        /**
+         * AG Grid column-menu entries shown when the submenu opens.
+         */
         subMenuItems: AgGridMenuItem<AgGridColumnMenuItemType>[];
+        /**
+         * When `true`, the submenu cannot be opened.
+         */
         disabled?: boolean;
+        /**
+         * Icon drawn next to the submenu label.
+         */
         icon?: AdaptableIcon;
     })[];
 }
@@ -45,10 +60,25 @@ export type CustomColumnMenuItem = AgGridMenuItem<AgGridColumnMenuItemType> | Ad
  * Defines a Grouped Menu Item in the Column Menu
  */
 export type CustomGroupColumnMenuItem = {
+    /**
+     * Always `Group`. The item is a submenu, not a clickable command.
+     */
     menuType: 'Group';
+    /**
+     * Text of the submenu.
+     */
     label: string;
+    /**
+     * Items shown when the submenu opens.
+     */
     subMenuItems: CustomColumnMenuItem[];
+    /**
+     * When `true`, the submenu cannot be opened.
+     */
     disabled?: boolean;
+    /**
+     * Icon drawn next to the submenu label.
+     */
     icon?: AdaptableIcon;
 };
 /**

package/src/AdaptableOptions/ColumnOptions.d.ts

@@ -28,14 +28,12 @@ export interface ColumnOptions {
      * Log warning to console if AdapTable cannot find a column
      *
      * @defaultValue true
-     * @noCodeItem
      */
     showMissingColumnsWarning?: boolean;
     /**
      * Appends the name of the Column Group to a Column's Friendly Name
      *
      * @defaultValue false
-     * @noCodeItem
      */
     addColumnGroupToColumnFriendlyName?: boolean;
 }

package/src/AdaptableOptions/CommentOptions.d.ts

@@ -1,6 +1,8 @@
 import { CommentThread, BaseContext, GridCell } from '../types';
 /**
- * Options for managing Comments and Comment Threads in AdapTable
+ * Comments on cells. A thread is the list of comments for one cell.
+ *
+ * Comments are not stored in AdapTable State. The application loads them with {@link loadCommentThreads} and saves them with {@link persistCommentThreads}.
  */
 export interface CommentOptions<TData = any> {
     /**
@@ -8,12 +10,18 @@ export interface CommentOptions<TData = any> {
      */
     isCellCommentable?: (commentableCellContext: CommentableCellContext) => boolean;
     /**
-     * Loads the Comment Threads
+     * Loads every comment thread when the grid starts.
+     *
+     * @param commentLoadContext The grid the comments belong to
+     * @returns The threads to show. An empty list when there are none
      */
     loadCommentThreads?(commentLoadContext: CommentLoadContext): Promise<CommentThread[]>;
     /**
-     * Persists the current Comment Threads
-     * @param commentThreads
+     * Saves the threads after a comment is added, edited or deleted.
+     *
+     * Called with the full set, not only the thread that changed.
+     *
+     * @param commentThreads Every thread, including the one that just changed
      */
     persistCommentThreads?(commentThreads: CommentThread[]): Promise<void>;
     /**