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

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

@@ -7,7 +7,9 @@ import { ColumnFilter } from './ColumnFilter';
  */
 export type AdaptableColumnDataType = 'text' | 'number' | 'boolean' | 'date' | 'object' | 'textArray' | 'numberArray' | 'tupleArray' | 'objectArray' | 'groupColumn' | 'unknown';
 /**
- * Column Types recognised by AdapTable; to be set in GridOptions
+ * Column types AdapTable assigns.
+ *
+ * `'calculatedColumn'`, `'freeTextColumn'`, `'actionColumn'` and `'fdc3Column'` mark columns AdapTable created. `'hiddenColumn'` is kept out of the grid. The `pivot*Total` names mark pivot total columns.
  */
 export type AdaptableColumnTypeName = 'hiddenColumn' | 'calculatedColumn' | 'freeTextColumn' | 'actionColumn' | 'fdc3Column' | 'pivotAnyTotal' | 'pivotGrandTotal' | 'pivotColumnTotal' | 'pivotAggregationTotal';
 export declare const HIDDEN_COLUMN_TYPE: AdaptableColumnTypeName;
@@ -212,19 +214,54 @@ export interface AdaptableColumn<TData = any> extends AdaptableColumnBase {
 /**
  * Key properties of a Column (used in Layout Editor)
  */
+/**
+ * What a column allows, as shown in the Layout editor.
+ *
+ * Each flag is read from the column. `true` means that action is available.
+ */
 export interface AdaptableColumnProperties {
+    /**
+     * Whether the column can be sorted.
+     */
     sortable: boolean;
+    /**
+     * Whether the column can be filtered.
+     */
     filterable: boolean;
+    /**
+     * Whether the column can be dragged to a new position.
+     */
     moveable: boolean;
+    /**
+     * Whether the column can be row-grouped.
+     */
     groupable: boolean;
+    /**
+     * Whether the column can be used as a pivot column.
+     */
     pivotable: boolean;
+    /**
+     * Whether the column can show an aggregation.
+     */
     aggregatable: boolean;
 }
 /**
  * Summary of a Column including filters and all unique values
  */
+/**
+ * One column as shown in Column Info: the column, its Column Filter, and the distinct values currently in the grid.
+ */
 export interface AdaptableColumnSummary {
+    /**
+     * Column this summary describes.
+     */
     column: AdaptableColumn;
+    /**
+     * Column Filter on this column in the current Layout. Absent when the column is not filtered.
+     */
     columnFilter: ColumnFilter;
+    /**
+     * Distinct cell values in this column, each with how many rows have that value.
+     */
     uniqueGridCells: UniqueGridCell[];
 }

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

@@ -1,6 +1,8 @@
 import { ColumnFilter } from '../../types';
 /**
- * Current Filters in AdapTable
+ * Filters currently applied.
+ *
+ * `gridFilter` is the Grid Filter expression, absent when there is none. `columnFilters` are the Column Filters in the current layout.
  */
 export interface AdaptableFilterState {
     /**

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

@@ -2,7 +2,9 @@ import { Identifiable } from './AdaptableObject';
 import { CellDataChangedInfo } from '../../types';
 import { FlashingCellDefinition } from '../../../types';
 /**
- * Defines an Alert fired by AdapTable
+ * A cell or row that has just flashed.
+ *
+ * `flashingCellDefinition` is the rule. `cellDataChangedInfo` is the change that triggered it, when there is one. `direction` is `up`, `down` or `neutral`. `flashTarget` is what flashed (cell or row).
  */
 export interface AdaptableFlashingCell extends Identifiable {
     /**

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

@@ -270,8 +270,17 @@ export type AdaptableFormFieldType = 'text' | 'textarea' | 'select' | 'radio' |
 /**
  * A single option used by a `select` or `radio` field.
  */
+/**
+ * One choice in a `select` or `radio` form field.
+ */
 export interface AdaptableFormFieldOption {
+    /**
+     * Value written into the form data when this choice is selected.
+     */
     value: any;
+    /**
+     * Text shown for this choice.
+     */
     label: string;
 }
 /**

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

@@ -1,17 +1,43 @@
 /**
- * Object containing formatting information for Numeric and Date Columns
+ * How a Format Column displays a value.
+ *
+ * Set `Formatter` to `'NumberFormatter'`, `'DateFormatter'` or `'StringFormatter'`, and put that formatter's options in `Options`. On a Format Column, `DisplayFormat` may instead be a numeric preset name such as `'Percentage'` or `'Dollar'`.
  */
 export type AdaptableFormat = {
+    /**
+     * Numeric formatter. Use with {@link NumberFormatterOptions}, or a numeric preset name on `DisplayFormat` instead of this object.
+     */
     Formatter: 'NumberFormatter';
+    /**
+     * Fraction digits, separators, prefix, suffix and the other numeric options.
+     */
     Options: NumberFormatterOptions;
 } | {
+    /**
+     * Date formatter.
+     */
     Formatter: 'DateFormatter';
+    /**
+     * Date pattern (`Pattern`) used to render the value.
+     */
     Options: DateFormatterOptions;
 } | {
+    /**
+     * String formatter. Transforms the cell text (case, prefix, suffix).
+     */
     Formatter: 'StringFormatter';
+    /**
+     * String formatting options.
+     */
     Options: StringFormatterOptions;
 };
+/**
+ * Formatter options shared by number, date and string formats.
+ */
 export interface BaseFormatterOptions {
+    /**
+     * Ids of `formatColumnOptions.customDisplayFormatters` to run before the built-in formatter. They run in the order those formatters are listed in options.
+     */
     CustomDisplayFormats?: string[];
 }
 /**

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

@@ -1,7 +1,9 @@
 import * as React from 'react';
 import { TypeHint } from './Types';
 /**
- * Defines an icon to be used in AdapTable (e.g. in Dashboard Header, Buttons, Menu, etc.)
+ * An icon shown in the Dashboard, a button, a menu or a tool panel.
+ *
+ * A system icon sets `name` (an AdapTable icon, or one registered in `userInterfaceOptions.customIcons`). A custom icon sets `src` to an image URL. An element icon sets `element` to a DOM node or an HTML string. `size` on a system icon is pixels and defaults to 17.
  */
 export type AdaptableIcon = AdaptableSystemIcon | AdaptableCustomIcon | AdaptableElementIcon;
 /**
@@ -11,7 +13,7 @@ export interface AdaptableSystemIcon extends AdaptableBaseIcon {
     /**
      * The name of the icon to use (referencing the AdapTable Icon Library)
      *
-     * The icon can be a adaptable icon or a custom one defined in `interfaceOptions.customIcons`
+     * The icon can be an AdapTable icon or a custom one defined in `userInterfaceOptions.customIcons`
      */
     name: TypeHint<string, AdaptableSystemIconName>;
     /**

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

@@ -14,7 +14,9 @@ export interface Identifiable {
     Uuid?: TypeUuid;
 }
 /**
- * Base interface which all other Adaptable State-related objects extend
+ * Fields shared by objects stored in Adaptable State.
+ *
+ * `Uuid` identifies the object. `Source` is `'InitialState'` when the object came from Initial State, and `'User'` when it was created at runtime. `IsReadOnly` blocks edits even when the module entitlement is `Full`. `IsSuspended`, on objects that have it, turns the object off without deleting it.
  */
 export interface AdaptableObject extends Identifiable {
     /**
@@ -61,7 +63,13 @@ export interface AdaptableObjectLookupCriteria {
      */
     ids?: AdaptableObject['Uuid'][];
 }
+/**
+ * An Adaptable object that names the columns it applies to.
+ */
 export interface AdaptableObjectWithScope extends AdaptableObject {
+    /**
+     * Columns this object applies to. Exactly one of `All`, `DataTypes`, `ColumnIds` or `ColumnTypes`.
+     */
     Scope: ColumnScope;
 }
 /**

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 {
     /**