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

package/src/AdaptableState/Common/AdaptableQuery.d.ts

@@ -19,9 +19,18 @@ export type ExpressionKind = 'scalar' | 'aggregated';
  * depends on the kind (Alert, Calculated Column).
  */
 export interface ResolvedExpression {
+    /**
+     * `scalar` when the expression runs per row. `aggregated` when it runs over a set of rows (a brace call such as `SUM{...}`).
+     */
     kind: ExpressionKind;
+    /**
+     * Expression text. Modules store this string; the kind is inferred from it.
+     */
     text: string;
 }
+/**
+ * Options for inferring whether an expression is scalar or aggregated.
+ */
 export interface InferExpressionKindOptions {
     /** Custom aggregation (brace-call) names registered by the host. */
     customAggregatedNames?: Iterable<string>;

package/src/AdaptableState/Common/AdaptableStyle.d.ts

@@ -1,5 +1,7 @@
 /**
- * Behaviour for aligning Cell contents
+ * Horizontal alignment of cell content.
+ *
+ * `'Left'` and `'Default'` both align left. `'Right'` aligns right. `'Center'` centres the content.
  */
 export type Alignment = 'Left' | 'Right' | 'Center' | 'Default';
 /**
@@ -63,17 +65,13 @@ export interface CellBoxStyle {
     BorderRadius?: number;
 }
 /**
- * Style object used in numerous AdapTable Modules.
+ * Colours, font and border for a cell, header or highlight.
  *
- * Composed of two reusable slices — `CellFontStyle` (text) and `CellBoxStyle`
- * (cell chrome) — plus a `ClassName` escape hatch. The shape is unchanged
- * from previous releases; the slices exist so that Styled Columns can opt-in
- * to a single slice (`Font` or `Cell`) without having to embed a full
- * `AdaptableStyle`.
+ * Text properties (`ForeColor`, `FontWeight`, `FontStyle`, `TextDecoration`, `FontSize`, `Alignment`) and box properties (`BackColor`, `BorderColor`, `BorderRadius`) are applied together. `ClassName` adds a CSS class and does not turn the other properties off. A Styled Column can take just the text slice (`Font`) or just the box slice (`Cell`).
  */
 export interface AdaptableStyle extends CellFontStyle, CellBoxStyle {
     /**
-     * Existing CSS Class; use instead of setting other object properties
+     * CSS class added to the cell. Colour, font and border properties on this object are still applied.
      */
     ClassName?: string;
 }

package/src/AdaptableState/Common/AggregationColumns.d.ts

@@ -3,9 +3,16 @@
  */
 import { PivotTotalPosition } from '../LayoutState';
 import type { AdaptableColumn } from './AdaptableColumn';
+/**
+ * How a column is aggregated in a layout.
+ *
+ * A string is an aggregation name: `'sum'`, `'avg'`, `'min'`, `'max'`, `'count'`, `'first'`, `'last'`, or `'only'` (the shared value when every row in the group has it, otherwise blank). `true` uses the column's `defaultAggFunc`, or `'sum'` when the column has none. A weighted average is `{ type: 'weightedAverage', weightedColumnId }`.
+ */
 export type AggregationColumnValue = string | true | WeightedAverageAggregation;
 /**
- * Defines an Aggregated Column in a Table Layout
+ * Aggregations shown in the group rows of a table layout.
+ *
+ * Each entry is a column id and an {@link AggregationColumnValue}.
  */
 export type TableAggregationColumns = {
     /**
@@ -13,12 +20,14 @@ export type TableAggregationColumns = {
      */
     ColumnId: string;
     /**
-     * The type of Aggregation
+     * Aggregation to apply. A name, `true` for the column default (or `'sum'`), or a weighted average. See {@link AggregationColumnValue}.
      */
     AggFunc: AggregationColumnValue;
 }[];
 /**
- * Defines an Aggregated Column in a Pivot Layout
+ * Aggregations shown in a pivot layout.
+ *
+ * Each entry is a column id, an {@link AggregationColumnValue}, and an optional per-column total position.
  */
 export type PivotAggregationColumns = {
     /**
@@ -40,15 +49,15 @@ export type PivotAggregationColumns = {
 export declare const WEIGHTED_AVERAGE_AGG_FN_NAME = "weightedAvg";
 export declare const ONLY_AGG_FN_NAME = "only";
 /**
- * Defines a Weighted Average Agg
+ * A weighted average of this column, weighted by another numeric column.
  */
 export interface WeightedAverageAggregation {
     /**
-     * Type is always 'weightedAverage'
+     * Always `'weightedAverage'`.
      */
     type: 'weightedAverage';
     /**
-     * Column which is weighted
+     * Column id whose values weight this average. That column is numeric.
      */
     weightedColumnId: string;
 }

package/src/AdaptableState/Common/ButtonStyle.d.ts

@@ -1,5 +1,7 @@
 /**
- * Defines the look and feel of an Adaptable Button
+ * Appearance of an AdapTable button.
+ *
+ * `variant` is `'text'`, `'outlined'` (the default) or `'raised'`. `tone` is the colour: `'neutral'` (the default), `'success'`, `'error'`, `'warning'`, `'info'`, `'accent'` or `'none'`. `className` adds a CSS class.
  */
 export interface ButtonStyle {
     /**

package/src/AdaptableState/Common/CellDataChangedInfo.d.ts

@@ -9,11 +9,15 @@ export interface CellDataChangedInfo<TData = any> {
      */
     changedAt: number;
     /**
-     * Value in the Cell before the edit
+     * Value before the change.
+     *
+     * Absent when `trigger` is `live`.
      */
     oldValue: any;
     /**
-     * New value for the cell
+     * Value after the change.
+     *
+     * Absent when `trigger` is `live`.
      */
     newValue: any;
     /**

package/src/AdaptableState/Common/CellHighlightInfo.d.ts

@@ -1,6 +1,8 @@
 import { AdaptableStyle } from '../../../types';
 /**
- * Defines how a given Cell in AdapTable should be highlighted
+ * A highlight on one cell.
+ *
+ * `columnId` and `primaryKeyValue` locate the cell. `highlightStyle` is the colours and font. `timeout` is how many milliseconds the highlight lasts; omit it and the highlight stays until it is cleared.
  */
 export interface CellHighlightInfo {
     /**
@@ -12,7 +14,7 @@ export interface CellHighlightInfo {
      */
     primaryKeyValue?: any;
     /**
-     * Time after which Cell should be unhighlighted
+     * Milliseconds before the highlight is removed. Omit it and the highlight stays until it is cleared.
      */
     timeout?: number;
     /**

package/src/AdaptableState/Common/CellSummary.d.ts

@@ -5,16 +5,49 @@ import { SelectedCellInfo } from '../Selection/SelectedCellInfo';
  * Defines the Summary operations which AdapTable provides for Selected Numeric Cells
  */
 export interface CellSummmaryInfo {
+    /**
+     * Sum of the selected numeric values. `undefined` when the selection is not numeric.
+     */
     Sum: number | undefined;
+    /**
+     * Mean of the selected numeric values. `undefined` when the selection is not numeric.
+     */
     Average: number | undefined;
+    /**
+     * Median of the selected numeric values. `undefined` when the selection is not numeric.
+     */
     Median: number | undefined;
+    /**
+     * Most frequent selected value. `undefined` when there is no single mode.
+     */
     Mode: number | undefined;
+    /**
+     * How many distinct values are selected.
+     */
     Distinct: number | undefined;
+    /**
+     * Largest selected numeric value. `undefined` when the selection is not numeric.
+     */
     Max: number | undefined;
+    /**
+     * Smallest selected numeric value. `undefined` when the selection is not numeric.
+     */
     Min: number | undefined;
+    /**
+     * How many cells are selected.
+     */
     Count: number | undefined;
+    /**
+     * The single selected value, when every selected cell has the same value. `undefined` when the values differ.
+     */
     Only: string | undefined;
+    /**
+     * Standard deviation of the selected numeric values. `undefined` when the selection is not numeric.
+     */
     Std_Deviation: number | undefined;
+    /**
+     * Result of each custom Cell Summary operation, keyed by `operationName`.
+     */
     [key: string]: any;
 }
 /**

package/src/AdaptableState/Common/ColumnFilter.d.ts

@@ -1,6 +1,8 @@
 import { SuspendableObject } from '../../types';
 /**
- * Defines an AdaptableQL Filter applied on a Column
+ * A filter on one column in a layout.
+ *
+ * `Expression` is a boolean AdapTableQL expression and is what hides rows. `PreferredFilter` is only the operator shown in the filter UI before an expression exists; it does not hide rows. Setting `Expression` clears `PreferredFilter`. `IsSuspended: true` turns the filter off.
  */
 export interface ColumnFilter extends SuspendableObject {
     /**

package/src/AdaptableState/Common/ColumnHighlightInfo.d.ts

@@ -1,6 +1,8 @@
 import { AdaptableStyle } from '../../../types';
 /**
- * Defines how a given Column in AdapTable should be highlighted
+ * A highlight on every cell in one column.
+ *
+ * `columnId` is the column. `highlightStyle` is the colours and font. `timeout` is milliseconds; omit it and the highlight stays until it is cleared.
  */
 export interface ColumnHighlightInfo {
     /**
@@ -8,7 +10,7 @@ export interface ColumnHighlightInfo {
      */
     columnId: string;
     /**
-     * Time after which Column should be unhighlighted
+     * Milliseconds before the highlight is removed. Omit it and the highlight stays until it is cleared.
      */
     timeout?: number;
     /**

package/src/AdaptableState/Common/ColumnScope.d.ts

@@ -1,22 +1,53 @@
+/**
+ * AdapTable column data types a scope can name.
+ *
+ * `'text'`, `'number'`, `'boolean'`, `'date'`, `'textArray'` and `'numberArray'`. Object, tuple and unknown columns are not scope data types; name those columns with `ColumnIds`.
+ */
 export type ScopeDataType = 'text' | 'number' | 'boolean' | 'date' | 'textArray' | 'numberArray';
 /**
  * Scope data type for modules that only apply to numeric columns (e.g. Shortcut, Plus/Minus).
  */
 export type NumberScopeDataType = 'number';
+/**
+ * Every column. The only valid value is `{ All: true }`.
+ */
 export type ScopeAll = {
+    /**
+     * Must be `true`. `{ All: true }` matches every column.
+     */
     All: true;
 };
+/**
+ * Columns whose AdapTable data type is in the list.
+ */
 export type ScopeDataTypes<Type = ScopeDataType> = {
+    /**
+     * Data types to match, for example `['number']` or `['text', 'textArray']`.
+     */
     DataTypes: Type[];
 };
+/**
+ * Columns named by id.
+ */
 export type ScopeColumnIds = {
+    /**
+     * Column ids to match. These are AG Grid `colId` values.
+     */
     ColumnIds: string[];
 };
+/**
+ * Columns that have one of these AG Grid column types (`colDef.type`).
+ */
 export type ScopeColumnTypes = {
+    /**
+     * AG Grid column type names, the strings set on `colDef.type`.
+     */
     ColumnTypes: string[];
 };
 /**
- * Defines where a given Object / Module is active
+ * Which columns an object applies to.
+ *
+ * Set exactly one of `All`, `DataTypes`, `ColumnIds` or `ColumnTypes`. `{ All: true }` is every column. `DataTypes` matches AdapTable data types. `ColumnIds` matches column ids. `ColumnTypes` matches AG Grid column types.
  */
 export type ColumnScope<Type = ScopeDataType> = ScopeAll | ScopeDataTypes<Type> | ScopeColumnIds | ScopeColumnTypes;
 export declare const isScopeColumnIds: (scope: ColumnScope) => scope is ScopeColumnIds;

package/src/AdaptableState/Common/ColumnSetupInfo.d.ts

@@ -1,8 +1,25 @@
 import { ColDef, Column } from 'ag-grid-enterprise';
 import { AdaptableColumn } from './AdaptableColumn';
+/**
+ * A column while AdapTable is attaching it to the grid.
+ *
+ * `col` and `colDef` are the AG Grid column. `colId` is its id. `abColumn` is the AdapTable column once one exists.
+ */
 export type ColumnSetupInfo = {
+    /**
+     * AG Grid column.
+     */
     col: Column;
+    /**
+     * AG Grid column definition.
+     */
     colDef: ColDef;
+    /**
+     * Column id.
+     */
     colId: string;
+    /**
+     * AdapTable column, once it has been created.
+     */
     abColumn?: AdaptableColumn;
 };

package/src/AdaptableState/Common/ColumnSort.d.ts

@@ -1,5 +1,7 @@
 /**
- * Defines how a Column is sorted
+ * One column in a layout sort.
+ *
+ * On `Layout.ColumnSorts`, the array order is the sort priority: the first entry is the primary sort. `SortOrder` is `'Asc'` or `'Desc'`.
  */
 export interface ColumnSort {
     /**

package/src/AdaptableState/Common/CompactCalculatedColumnEditorInfo.d.ts

@@ -3,5 +3,8 @@
  * (Standard / Cumulative / Quantile / Window; live updates; not persisted).
  */
 export interface CompactCalculatedColumnEditorInfo {
+    /**
+     * `ColumnId` of the Calculated Column whose expression is open in the compact editor.
+     */
     calculatedColumnId: string;
 }

package/src/AdaptableState/Common/DataChangedScope.d.ts

@@ -1,5 +1,7 @@
 /**
- * Defines where a Data Change should be monitored
+ * Which columns a data-change watch covers.
+ *
+ * `wholeRow: true` watches every column in the row. `columnIds` watches those column ids. Used when AdapTable decides which edits a rule should see.
  */
 export interface DataChangedScope {
     /**

package/src/AdaptableState/Common/DataUpdateConfig.d.ts

@@ -1,5 +1,7 @@
 /**
- * Object used to configure GridApi row management methods
+ * How a Grid API row update runs.
+ *
+ * `runAsync` runs the update asynchronously. `flushAsync` waits for queued async updates to finish. `addIndex` is the row index for added rows. `callback` runs when the batch finishes.
  */
 export interface DataUpdateConfig {
     /**

package/src/AdaptableState/Common/Entitlement.d.ts

@@ -1,6 +1,8 @@
 import { AdaptableModule } from './Types';
 /**
- * Defines a Permission in AdapTable - Module and Access Level
+ * Access granted to one AdapTable module.
+ *
+ * `Full` shows the module and allows its objects to be added, edited and deleted. `ReadOnly` shows the module and blocks those changes. `Hidden` does not show the module. A module with no entitlement uses that module's default, which is `Full` unless the module sets its own.
  */
 export interface Entitlement {
     /**
@@ -13,6 +15,6 @@ export interface Entitlement {
     accessLevel: AccessLevel;
 }
 /**
- * Whether an Entitlement is `ReadOnly`, `Hidden` or `Full`
+ * `'Full'` can change the module's objects. `'ReadOnly'` can see them and cannot change them. `'Hidden'` does not show the module.
  */
 export type AccessLevel = 'ReadOnly' | 'Hidden' | 'Full';

package/src/AdaptableState/Common/Enums.d.ts

@@ -1,21 +1,36 @@
+/**
+ * Arithmetic operation used by a Shortcut: add, subtract, multiply or divide the cell value by `ShortcutValue`.
+ */
 export declare enum MathOperation {
     Add = "Add",
     Subtract = "Subtract",
     Multiply = "Multiply",
     Divide = "Divide"
 }
+/**
+ * Sort direction. `'Asc'` is ascending and `'Desc'` is descending.
+ */
 export declare enum SortOrder {
     Asc = "Asc",
     Desc = "Desc"
 }
+/**
+ * Font weight for an `AdaptableStyle`. `'Normal'` or `'Bold'`.
+ */
 export declare enum FontWeight {
     Normal = "Normal",
     Bold = "Bold"
 }
+/**
+ * Font style for an `AdaptableStyle`. `'Normal'` or `'Italic'`.
+ */
 export declare enum FontStyle {
     Normal = "Normal",
     Italic = "Italic"
 }
+/**
+ * Font size for an `AdaptableStyle`: `'XSmall'`, `'Small'`, `'Medium'`, `'Large'` or `'XLarge'`.
+ */
 export declare enum FontSize {
     XSmall = "XSmall",
     Small = "Small",
@@ -23,12 +38,18 @@ export declare enum FontSize {
     Large = "Large",
     XLarge = "XLarge"
 }
+/**
+ * CSS colour variable for a status: error, warning, success or info.
+ */
 export declare enum StatusColour {
     Error = "var(--ab-color-destructive)",
     Warn = "var(--ab-color-warn)",
     Success = "var(--ab-color-success)",
     Info = "var(--ab-color-info)"
 }
+/**
+ * Cell Summary operation calculated for the current selection: sum, average, median, mode, distinct count, max, min, count, only, standard deviation, or weighted average.
+ */
 export declare enum SummaryOperation {
     Sum = "Sum",
     Max = "Max",

package/src/AdaptableState/Common/ExtendedLayout.d.ts

@@ -41,7 +41,9 @@ export type LayoutExtensionObject = AlertDefinition | CustomSort | FlashingCellD
  */
 export type LayoutExtensionModule = 'Alert' | 'CustomSort' | 'FlashingCell' | 'FormatColumn' | 'PlusMinus' | 'Shortcut' | 'StyledColumn';
 /**
- * Lists the Adaptable Objects (by Name) which are extended into a Layout
+ * Objects that apply only in one layout.
+ *
+ * An Alert, Custom Sort, Flashing Cell, Format Column, Plus Minus nudge, Shortcut or Styled Column applies in every layout until its `Name` is listed here. Once listed, it applies only in the layouts that name it. `LayoutName` is the layout's `Name`. Each array is object names, not column ids.
  */
 export interface LayoutExtension {
     /**

package/src/AdaptableState/Common/Fdc3Context.d.ts

@@ -1,6 +1,15 @@
 import { StandardContextType } from '@finos/fdc3';
+/**
+ * Label and icon used for one standard FDC3 context type.
+ */
 interface ContextConfig {
+    /**
+     * Text shown for this context type.
+     */
     label: string;
+    /**
+     * AdapTable icon name shown for this context type.
+     */
     icon: string;
 }
 export declare const ContextConfiguration: Record<StandardContextType, ContextConfig>;

package/src/AdaptableState/Common/Fdc3Intent.d.ts

@@ -1,5 +1,11 @@
 import { StandardIntent } from '@finos/fdc3';
+/**
+ * Icon used for one standard FDC3 intent.
+ */
 interface IntentConfig {
+    /**
+     * AdapTable icon name shown for this intent.
+     */
     icon: string;
 }
 export declare const Fdc3IntentConfiguration: Record<StandardIntent, IntentConfig>;

package/src/AdaptableState/Common/GridFilter.d.ts

@@ -1,6 +1,8 @@
 import { SuspendableObject } from '../../types';
 /**
- * Defines a Grid Filter (essentially a Boolean Expression)
+ * A boolean AdapTableQL expression applied to every row in a layout.
+ *
+ * Rows that do not match `Expression` are hidden. An empty expression, or `IsSuspended: true`, shows every row. This is separate from each column's `ColumnFilter`.
  */
 export interface GridFilter extends SuspendableObject {
     /**

package/src/AdaptableState/Common/MenuItem.d.ts

@@ -3,6 +3,9 @@ import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupP
 import { AdaptableMenuItem, AdaptableContextMenuItemName, AdaptableColumnMenuItemName } from './Menu';
 import { AdaptableModule } from './Types';
 import { AdaptableIcon, AdaptableSystemIconName } from './AdaptableIcon';
+/**
+ * A shipped menu item that dispatches a Redux action when it is clicked.
+ */
 export declare class MenuItemDoReduxAction<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName> implements AdaptableMenuItem<MENU_TYPE_NAME> {
     constructor(name: MENU_TYPE_NAME, label: string, module: AdaptableModule, reduxAction: Redux.Action, icon: AdaptableSystemIconName | AdaptableIcon, isVisible: boolean);
     name: MENU_TYPE_NAME;
@@ -12,6 +15,9 @@ export declare class MenuItemDoReduxAction<MENU_TYPE_NAME extends AdaptableColum
     isVisible: boolean;
     icon: AdaptableIcon;
 }
+/**
+ * A shipped menu item that runs a function when it is clicked.
+ */
 export declare class MenuItemDoClickFunction<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName> implements AdaptableMenuItem<MENU_TYPE_NAME> {
     constructor(name: MENU_TYPE_NAME, label: string, module: AdaptableModule, clickFunction: () => void, icon: AdaptableSystemIconName | AdaptableIcon, isVisible: boolean);
     name: MENU_TYPE_NAME;
@@ -21,6 +27,9 @@ export declare class MenuItemDoClickFunction<MENU_TYPE_NAME extends AdaptableCol
     isVisible: boolean;
     icon: AdaptableIcon;
 }
+/**
+ * A shipped menu item that opens a popup when it is clicked.
+ */
 export declare class MenuItemShowPopup<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName> implements AdaptableMenuItem<MENU_TYPE_NAME> {
     constructor(name: MENU_TYPE_NAME, label: string, module: AdaptableModule, componentName: string, icon: AdaptableSystemIconName | AdaptableIcon, isVisible: boolean, popupParams?: ModuleParams);
     name: MENU_TYPE_NAME;

package/src/AdaptableState/Common/RowHighlightInfo.d.ts

@@ -1,6 +1,8 @@
 import { AdaptableStyle } from '../../../types';
 /**
- * Define how to highlight a Row
+ * A highlight on one row.
+ *
+ * `primaryKeyValue` is the row. `highlightStyle` is the colours and font. `timeout` is milliseconds; omit it and the highlight stays until it is cleared.
  */
 export interface RowHighlightInfo {
     /**
@@ -8,7 +10,7 @@ export interface RowHighlightInfo {
      */
     primaryKeyValue: any;
     /**
-     * Timeout after which Row should be unhighlighted
+     * Milliseconds before the highlight is removed. Omit it and the highlight stays until it is cleared.
      */
     timeout?: number;
     /**

package/src/AdaptableState/Common/RowScope.d.ts

@@ -1,5 +1,7 @@
 /**
- * Defines which types of Rows to exclude when rendering Format Columns, Action Columns and Badges
+ * Row kinds to skip.
+ *
+ * Each flag, when true, skips that kind. A flag left unset includes that kind. When the whole `RowScope` is omitted, the feature decides: a Format Column includes every kind.
  */
 export interface RowScope {
     /**

package/src/AdaptableState/Common/RowSummary.d.ts

@@ -3,22 +3,32 @@ import { SuspendableObject } from './SuspendableObject';
 export declare const ROW_SUMMARY_ROW_ID = "__ROW_SUMMARY_ROW_ID";
 export declare const WEIGHTED_AVERAGE_AGGREGATED_FUNCTION = "WEIGHTED_AVERAGE";
 export declare const summarySupportedExpressions: readonly ["MIN", "MAX", "SUM", "PRODUCT", "AVG", "COUNT", "MEDIAN", "MODE", "DISTINCT", "ONLY", "STD_DEVIATION", "WEIGHTED_AVERAGE"];
+/**
+ * Built-in summary names: `MIN`, `MAX`, `SUM`, `PRODUCT`, `AVG`, `COUNT`, `MEDIAN`, `MODE`, `DISTINCT`, `ONLY`, `STD_DEVIATION`, `WEIGHTED_AVERAGE`.
+ */
 export type SystemSummarySupportedExpression = (typeof summarySupportedExpressions)[number];
+/**
+ * Summary written into a row-summary cell. One of {@link SystemSummarySupportedExpression}.
+ *
+ * `WEIGHTED_AVERAGE` uses the weighted column from that column's layout aggregation when the aggregation is a weighted average.
+ */
 export type SummarySupportedExpression = TypeHint<string, SystemSummarySupportedExpression>;
 /**
- * Position of Row Summary - 'Top' or 'Bottom'
+ * Which edge a row summary is pinned to. `'Top'` or `'Bottom'`. When omitted, the summary is pinned to the bottom.
  */
 export type RowSummaryPosition = 'Top' | 'Bottom';
 /**
- * Defines a Row Summary used in a Layout
+ * A pinned row of column summaries in a table layout.
+ *
+ * `ColumnsMap` is required: each key is a column id and each value is a summary name such as `'SUM'` or `'AVG'`. `Position` is `'Top'` or `'Bottom'`; omit it to pin the row to the bottom. `IncludeOnlyFilteredRows` defaults to true, so the summary uses the rows that pass the current filter. Suspend with `IsSuspended`. Requires AG Grid `PinnedRowModule`.
  */
 export interface RowSummary extends SuspendableObject {
     /**
-     * Where Row Summary appears - 'Top' or 'Bottom'
+     * `'Top'` pins the summary above the rows. `'Bottom'` pins it below them. When omitted, the summary is pinned to the bottom.
      */
     Position?: RowSummaryPosition;
     /**
-     * Map of Columns with Summary Expressions
+     * Column id to summary name. Each value is a {@link SummarySupportedExpression}, for example `'SUM'` or `'AVG'`.
      */
     ColumnsMap: Record<string, SummarySupportedExpression>;
     /**

package/src/AdaptableState/Common/RowsHighlightInfo.d.ts

@@ -1,14 +1,16 @@
 import { AdaptableStyle } from '../../../types';
 /**
- * Defines how to highlight a set of Rows
+ * One highlight applied to several rows.
+ *
+ * `primaryKeyValues` are the rows. `highlightStyle` is the colours and font. `timeout` is milliseconds; omit it and the highlight stays until it is cleared.
  */
 export interface RowsHighlightInfo {
     /**
-     * Primary key valuse for the rows to be highlighted
+     * Primary key values of the rows to highlight.
      */
     primaryKeyValues: any[];
     /**
-     * Timeout after which the highlight is removed
+     * Milliseconds before the highlight is removed. Omit it and the highlight stays until it is cleared.
      */
     timeout?: number;
     /**

package/src/AdaptableState/Common/Schedule.d.ts

@@ -1,9 +1,11 @@
 /**
- * Defines when an action will run — either once or recurring
+ * When a scheduled alert or export runs.
+ *
+ * `IsOneOff: true` runs once at `RunAt` (an ISO date-time). `IsOneOff: false` repeats on `CronExpression`, a 5-field cron (minute, hour, day of month, month, day of week). Weekdays in that cron are 0–6 with Sunday as 0; `1-5` is Monday to Friday.
  */
 export interface Schedule {
     /**
-     * If true, the schedule runs once (using RunAt)
+     * `true` runs once, at `RunAt`. `false` repeats on `CronExpression`.
      */
     IsOneOff: boolean;
     /**
@@ -15,5 +17,11 @@ export interface Schedule {
      */
     CronExpression?: string;
 }
+/**
+ * Day names used when a cron expression is built from selected weekdays. Sunday is cron day 0.
+ */
 export type Weekdays = Weekday[];
+/**
+ * A weekday name. Sunday is cron day 0 and Saturday is cron day 6.
+ */
 export type Weekday = 'Sunday' | 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday';

package/src/AdaptableState/Common/SpecialColumnSettings.d.ts

@@ -1,6 +1,8 @@
 import { AdaptableColumnDataType } from './AdaptableColumn';
 /**
- * Base Settings for both Calculated and FreeText Columns
+ * Column behaviour for a Calculated Column or a Free Text Column.
+ *
+ * `DataType` is required and is the type AdapTable uses for filters and expressions. `Filterable`, `Resizable`, `Groupable`, `Sortable`, `Pivotable` and `Aggregatable` each default to false. `SuppressMenu` and `SuppressMovable` default to false, so the header menu is shown and the column can be dragged.
  */
 export interface SpecialColumnSettings {
     /**