@adaptabletools/adaptable 18.0.0-canary.8 → 18.0.0

package/src/AdaptableOptions/CommentOptions.d.ts

@@ -1,28 +1,39 @@
-import { CommentThread, BaseContext, CellAddress } from '../../types';
+import { CommentThread, BaseContext, GridCell } from '../types';
 /**
  * Options for managing Comments and Comment Threads in AdapTable
  */
-export interface CommentsOptions<TData = any> {
+export interface CommentOptions<TData = any> {
     /**
-     * Whether a cell can be noted on
-     * TODO: check if it works
+     * Function to configure if a cell can contain Comments
      */
     isCellCommentable?: (commentableCellContext: CommentableCellContext) => boolean;
     /**
-     * Called to load initial comments
+     * Loads the Comment Threads
      */
     loadCommentThreads?(commentLoadContext: CommentLoadContext): Promise<CommentThread[]>;
     /**
-     * Called when comments change
+     * Persists the current Comment Threads
      * @param commentThreads
      */
-    persistCommentThreads?(commentThreads: CommentThread[]): void;
+    persistCommentThreads?(commentThreads: CommentThread[]): Promise<void>;
+    /**
+     * Format string for dates in Comments Popup
+     *
+     * @defaultValue 'dd-MM-yyyy HH:mm:ss'
+     */
+    dateFormat?: string;
 }
 /**
- * Context used when determining if a Comment can be added to a Cell
+ * Context used when determining if a cell can show Comments
  */
 export interface CommentableCellContext extends BaseContext {
-    address: CellAddress;
+    /**
+     * Grid Cell in AdapTable which has been clicked
+     */
+    gridCell: GridCell;
 }
+/**
+ * Context used when loading Comments
+ */
 export interface CommentLoadContext extends BaseContext {
 }

package/src/AdaptableOptions/ContextMenuOptions.d.ts

@@ -0,0 +1,94 @@
+import { AdaptableContextMenuItemName, AdaptableMenuItem, AgGridMenuItem, ContextMenuContext } from '../PredefinedConfig/Common/Menu';
+import { AdaptableIcon } from '../types';
+/**
+ * Options for managing menus in AdapTable – provided using 2 collections
+ */
+export interface ContextMenuOptions<TData = any> {
+    /**
+     * Customises Context Menu (default context menu items are available in provided context)
+     */
+    customContextMenu?: (menuContext: CustomContextMenuContext<TData>) => CustomContextMenuItem[];
+}
+/**
+ * Context info provided when building Custom Context Menus
+ */
+export interface CustomContextMenuContext<TData = any> extends ContextMenuContext<TData> {
+    /**
+     * Flat list of all available AdapTable Menu Items
+     */
+    defaultAdaptableMenuItems: AdaptableSystemContextMenuItem<AdaptableContextMenuItemName>[];
+    /**
+     * Flat list of all available AG Grid Menu Items
+     */
+    defaultAgGridMenuItems: AgGridMenuItem<AgGridContextMenuItemType>[];
+    /**
+     * Default structure of Adaptable Menu Items
+     */
+    defaultAdaptableMenuStructure: (AdaptableSystemContextMenuItem<AdaptableContextMenuItemName> | '-')[];
+    /**
+     * Default structure of AG Grid Menu Items
+     */
+    defaultAgGridMenuStructure: (AgGridMenuItem<AgGridContextMenuItemType> | {
+        menuType: 'Group';
+        label: string;
+        subMenuItems: AgGridMenuItem<AgGridContextMenuItemType>[];
+        disabled?: boolean;
+        icon?: AdaptableIcon;
+    })[];
+}
+/**
+ * Custom Context Menu Item
+ */
+export type CustomContextMenuItem = AgGridMenuItem<AgGridContextMenuItemType> | AdaptableSystemContextMenuItem<AdaptableContextMenuItemName> | UserContextMenuItem | '-' | {
+    menuType: 'Group';
+    label: string;
+    subMenuItems: CustomContextMenuItem[];
+    disabled?: boolean;
+    icon?: AdaptableIcon;
+};
+/**
+ * System Menu Item that is provided by AdapTable
+ */
+export interface AdaptableSystemContextMenuItem<MENU_TYPE_NAME extends AdaptableContextMenuItemName> extends AdaptableMenuItem<MENU_TYPE_NAME> {
+    /**
+     * Type of Menu - always 'Adaptable'
+     */
+    menuType: 'Adaptable';
+}
+/**
+ * Context Menu Item that is provided by User
+ */
+export interface UserContextMenuItem {
+    /**
+     * Type of Menu - always 'User'
+     */
+    menuType: 'User';
+    /**
+     * Text to appear in the Menu Item
+     */
+    label: string;
+    /**
+     * Function invoked when the Menu Item is clicked
+     */
+    onClick?: (menuContext: ContextMenuContext) => void;
+    /**
+     * Whether menu item is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Whether menu item is hidden
+     */
+    hidden?: boolean;
+    /**
+     * Optional icon to display
+     */
+    icon?: AdaptableIcon;
+    /**
+     * Array of Menu Items, enabling limitless levels of menus
+     */
+    subMenuItems?: CustomContextMenuItem[];
+}
+/**
+ * Defines AG Grid Context Menu Items
+ */
+export type AgGridContextMenuItemType = 'autoSizeAll' | 'expandAll' | 'contractAll' | 'copy' | 'copyWithHeaders' | 'copyWithGroupHeaders' | 'cut' | 'paste' | 'resetColumns' | 'export' | 'csvExport' | 'excelExport' | 'chartRange' | 'pivotChart' | 'separator';

package/src/AdaptableOptions/CustomSortOptions.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableScope } from '../../types';
+import { ColumnScope } from '../../types';
 import { AdaptableComparerFunction } from '../PredefinedConfig/Common/AdaptableComparerFunction';
 /**
  * Options for providing Custom Sorts comparers
@@ -16,7 +16,7 @@ export interface ColumnValuesComparer<TData = any> {
     /**
      * Column for which to compare values
      */
-    scope: AdaptableScope;
+    scope: ColumnScope;
     /**
      * Comparer function to use
      */

package/src/AdaptableOptions/DataImportOptions.d.ts

@@ -5,7 +5,7 @@ import { IRowNode } from '@ag-grid-community/core';
  */
 export interface DataImportOptions<T = Record<string, any>> {
     /**
-     * File extensions that the Data Import function accepts
+     * Custom File Handlers to use for Data Import
      */
     fileHandlers?: DataImportFileHandler<T>[];
     /**
@@ -60,7 +60,7 @@ export interface DataImportFileHandler<T = Record<string, any>> {
      */
     fileExtension?: string;
     /**
-     * Function which handles the File
+     * Async function which handles the import returning a Data Record
      */
     handleFile: (file: File) => Promise<T[]>;
 }

package/src/AdaptableOptions/FormatColumnOptions.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableScope } from '../PredefinedConfig/Common/AdaptableScope';
+import { ColumnScope } from '../PredefinedConfig/Common/ColumnScope';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { BaseContext } from '../../types';
 import { IRowNode } from '@ag-grid-community/core';
@@ -30,7 +30,7 @@ export interface CustomDisplayFormatter {
     /**
      * Where Custom Display Format can be applied
      */
-    scope: AdaptableScope;
+    scope: ColumnScope;
 }
 /**
  * Context used in handler of CustomDisplayFormatter

package/src/AdaptableOptions/GroupingOptions.d.ts

@@ -1,20 +1,7 @@
-import { AdaptableColumn, BaseContext } from '../../types';
-import { KeyCreatorParams } from '@ag-grid-community/core';
 /**
  * Options for managing Row and Column Groups in AdapTable
  */
 export interface GroupingOptions<TData = any> {
-    /**
-     * Show aggregated totals row at top of Grid when row grouping
-     *
-     * @defaultValue false
-     * @gridInfoItem
-     */
-    showGroupingTotalsAsHeader?: boolean;
-    /**
-    * Value to use for 'Balanced Groups' (string columns only)
-    */
-    balancedGroupsKey?: string | ((context: BalancedGroupsKeyContext<TData>) => string);
     /**
      * Places ungrouped columns at pre-grouping indexed position
      * @defaultValue false
@@ -30,16 +17,3 @@ export interface GroupingOptions<TData = any> {
      */
     autoOrderGroupedColumns?: boolean;
 }
-/**
- * Context used when setting a value for Balanced Row Groups
- */
-export interface BalancedGroupsKeyContext<TData = any> extends BaseContext {
-    /**
-     * AdapTable Column being grouped
-     */
-    adaptableColumn: AdaptableColumn<TData>;
-    /**
-     * AG Grid's Key Creator Params
-     */
-    params: KeyCreatorParams<TData>;
-}

package/src/AdaptableOptions/NoteOptions.d.ts

@@ -1,16 +1,25 @@
-import { BaseContext, CellAddress } from '../../types';
+import { BaseContext, GridCell } from '../../types';
 /**
  * Options for managing AdapTable Notes
  */
 export interface NoteOptions<TData = any> {
     /**
-     * Whether a cell can be noted on
+     * Whether a cell can contain Notes
      */
     isCellNotable?: (context: NotableCellContext) => boolean;
+    /**
+     * Format string for formatting in the Notes Popup
+     *
+     * @defaultValue 'dd-MM-yyyy HH:mm:ss'
+     */
+    dateFormat?: string;
 }
 /**
  * Context used when determining if a Note can be added to a Cell
  */
 export interface NotableCellContext extends BaseContext {
-    address: CellAddress;
+    /**
+     * Grid Cell in AdapTable which has been clicked
+     */
+    gridCell: GridCell;
 }

package/src/AdaptableOptions/PredicateOptions.d.ts

@@ -1,4 +1,4 @@
-import { AdaptablePredicateDef, AdaptableScope, BaseContext, PredicateModuleScope, SystemAlertPredicateId, SystemAlertPredicateIds, SystemBadgeStylePredicateId, SystemBadgeStylePredicateIds, SystemFilterPredicateId, SystemFilterPredicateIds, SystemFlashingCellPredicateId, SystemFlashingCellPredicateIds, SystemFormatColumnPredicateId, SystemFormatColumnPredicateIds } from '../types';
+import { AdaptablePredicateDef, ColumnScope, BaseContext, PredicateModuleScope, SystemAlertPredicateId, SystemAlertPredicateIds, SystemBadgeStylePredicateId, SystemBadgeStylePredicateIds, SystemFilterPredicateId, SystemFilterPredicateIds, SystemFlashingCellPredicateId, SystemFlashingCellPredicateIds, SystemFormatColumnPredicateId, SystemFormatColumnPredicateIds } from '../types';
 /**
  * Options for managing Adaptable Predicates using AdaptableQL
  */
@@ -51,5 +51,5 @@ export interface SystemPredicatesContext<PREDICATE_TYPE = string> extends BaseCo
     /**
      * Current Scope where Predicates are being used
      */
-    columnScope: AdaptableScope;
+    columnScope: ColumnScope;
 }

package/src/AdaptableOptions/QuickSearchOptions.d.ts

@@ -33,7 +33,7 @@ export interface QuickSearchOptions<TData = any> {
      */
     filterResultsAfterQuickSearch?: boolean;
     /**
-     * Include Aggregrated Columns in Grouped Rows when Quick Searching (highlight only)
+     * Include Aggregrated Columns in Group Rows when Quick Searching (highlight only)
      *
      * @defaultValue false
      * @gridInfoItem

package/src/AdaptableOptions/StateOptions.d.ts

@@ -33,6 +33,12 @@ export interface StateOptions {
      * @defaultValue 400
      */
     debounceStateDelay?: number;
+    /**
+     * Automatically migrate State from previous AdapTable version to current one
+     *
+     * @defaultValue true
+     */
+    autoMigrateState?: boolean;
 }
 /**
  * State Function Config object passed into all State Options functions (except 'applyState')

package/src/AdaptableOptions/UserInterfaceOptions.d.ts

@@ -1,6 +1,6 @@
 import { AdaptableIcon } from '../PredefinedConfig/Common/AdaptableIcon';
 import { DateInputOptions } from './DateInputOptions';
-import { AdaptableScope } from '../PredefinedConfig/Common/AdaptableScope';
+import { ColumnScope } from '../PredefinedConfig/Common/ColumnScope';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableObjectTag } from '../PredefinedConfig/Common/AdaptableObject';
 import { AdaptableStyle } from '../PredefinedConfig/Common/AdaptableStyle';
@@ -136,7 +136,7 @@ export interface BasePermittedValues {
     /**
      * Scope where Values will appear (Mandatory property)
      */
-    scope: AdaptableScope;
+    scope: ColumnScope;
 }
 /**
  * Permitted/possible values, when column values can be selected (e.g. sort, bulk-update)

package/src/Api/AdaptableApi.d.ts

@@ -29,7 +29,7 @@ import { ExpressionApi } from './ExpressionApi';
 import { TeamSharingApi } from './TeamSharingApi';
 import { ColumnApi } from './ColumnApi';
 import { ApplicationApi } from './ApplicationApi';
-import { ScopeApi } from './ScopeApi';
+import { ColumnScopeApi } from './ColumnScopeApi';
 import { PredicateApi } from './PredicateApi';
 import { DataChangeHistoryApi } from './DataChangeHistoryApi';
 import { FlashingCellApi } from './FlashingCellApi';
@@ -40,13 +40,15 @@ import { StyledColumnApi } from './StyledColumnApi';
 import { OptionsApi } from './OptionsApi';
 import { ActionColumnApi } from './ActionColumnApi';
 import { ActionRowApi } from './ActionRowApi';
-import { NotesApi } from './NotesApi';
+import { NoteApi } from './NoteApi';
 import { Fdc3Api } from './Fdc3Api';
 import { DataImportApi } from './DataImportApi';
 import { GridFilterApi } from './GridFilterApi';
 import { NamedQueryApi } from './NamedQueryApi';
 import { ColumnFilterApi } from './ColumnFilterApi';
 import { CommentApi } from './CommentApi';
+import { ColumnMenuApi } from './ColumnMenuApi';
+import { ContextMenuApi } from './ContextMenuApi';
 /**
  *
  * The `AdaptableApi` provides developers with run-time access to AdapTable.
@@ -193,7 +195,7 @@ export interface AdaptableApi {
     /**
      * Manages the `Scope` object - used widely to determine where objects are applied
      */
-    scopeApi: ScopeApi;
+    columnScopeApi: ColumnScopeApi;
     /**
      * Provides access to the Shortcut Module
      */
@@ -231,11 +233,19 @@ export interface AdaptableApi {
      */
     userInterfaceApi: UserInterfaceApi;
     /**
-     * Provides access to the Notes Module
+     * Provides access to the Note Module
      */
-    notesApi: NotesApi;
+    noteApi: NoteApi;
     /**
-     * Provides access to the Comments Module
+     * Provides access to Column Menu
+     */
+    columnMenuApi: ColumnMenuApi;
+    /**
+     * Provides access to Context Menu
+     */
+    contextMenuApi: ContextMenuApi;
+    /**
+     * Provides access to the Comment Module
      */
     commentApi: CommentApi;
     /**

package/src/Api/ColumnApi.d.ts

@@ -262,4 +262,17 @@ export interface ColumnApi {
      * Opens Settings Panel with Column Info section selected and visible
      */
     openColumnInfoSettingsPanel(): void;
+    /**
+     * Returns available columns types defined under columnOptions.columnTypes
+     */
+    getColumnTypes(): string[];
+    /**
+     * Returns all columns of a given columnType
+     * @param columnType the columnType to filter by
+     */
+    getColumnsByColumnType(columnType: string): AdaptableColumn[];
+    /**
+     * Returns all columns currently Row Grouped
+     */
+    getRowGroupedColumns(): AdaptableColumn[];
 }

package/src/Api/ColumnMenuApi.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Provides run-time access to Column Menu
+ */
+export interface ColumnMenuApi {
+    /**
+     * Show the Column Menu
+     */
+    showColumnMenu(columnKey: string): void;
+    /**
+     * Hide the Column Menu
+     */
+    hideColumnMenu(columnKey: string): void;
+}

package/src/Api/{ScopeApi.d.ts → ColumnScopeApi.d.ts}

@@ -1,115 +1,125 @@
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
-import { AdaptableScope, ScopeDataType } from '../PredefinedConfig/Common/AdaptableScope';
+import { ColumnScope, ScopeDataType } from '../PredefinedConfig/Common/ColumnScope';
 import { CellColorRange } from '../PredefinedConfig/StyledColumnState';
 /**
- * Provides access to a suite of functions related to the `Scope` object
+ * Provides access to a suite of functions related to the `Column Scope` object
  */
-export interface ScopeApi {
+export interface ColumnScopeApi {
     /**
      * True if Column is in given Scope
      * @param column Column to check
      * @param scope   The Scope to check
      */
-    isColumnInScope(column: AdaptableColumn | undefined, scope: AdaptableScope): boolean;
+    isColumnInScope(column: AdaptableColumn | undefined, scope: ColumnScope): boolean;
     /**
      * Returns list of all Columns in the given Scope
      * @param scope the Scope to check
      */
-    getColumnsForScope(scope: AdaptableScope): AdaptableColumn[];
+    getColumnsForScope(scope: ColumnScope): AdaptableColumn[];
     /**
      * True if Scope is empty
      * @param scope Scope to check
      */
-    scopeIsEmpty(scope: AdaptableScope): boolean;
+    scopeIsEmpty(scope: ColumnScope): boolean;
     /**
      * True if Scope is 'All'
      * @param scope Scope to check
      */
-    scopeIsAll(scope: AdaptableScope): boolean;
+    scopeIsAll(scope: ColumnScope): boolean;
     /**
      * True if Scope contains DataTypes
      * @param scope Scope to check
      */
-    scopeHasDataType(scope: AdaptableScope): boolean;
+    scopeHasDataType(scope: ColumnScope): boolean;
+    /**
+     * True if Scope contains ColumnTypes
+     * @param scope Scope to check
+     */
+    scopeHasColumnType(scope: ColumnScope): boolean;
     /**
      * True if the Scope is DataTypes and contains only Boolean
      * @param scope Scope to check
      */
-    scopeHasOnlyBooleanDataType(scope: AdaptableScope): boolean;
+    scopeHasOnlyBooleanDataType(scope: ColumnScope): boolean;
     /**
      * True if Scope contains just 1 ColumnId
      * @param scope Scope to check
      */
-    isSingleColumnScope(scope: AdaptableScope): boolean;
+    isSingleColumnScope(scope: ColumnScope): boolean;
     /**
      * Gets the only Column in given Scope
      * @param scope Scope to check
      */
-    getSingleColumnInScope(scope: AdaptableScope): string | undefined;
+    getSingleColumnInScope(scope: ColumnScope): string | undefined;
     /**
      * True if Scope contains just 1 numeric Column
      * @param scope Scope to check
      */
-    isSingleNumericColumnScope(scope: AdaptableScope): boolean;
+    isSingleNumericColumnScope(scope: ColumnScope): boolean;
     /**
      * True if Scope contains just 1 boolean Column
      * @param scope Scope to check
      */
-    isSingleBooleanColumnScope(scope: AdaptableScope): boolean;
+    isSingleBooleanColumnScope(scope: ColumnScope): boolean;
     /**
      * True if all selected columns are boolean
      * @param scope Scope to check
      */
-    areAllBooleanColumnsInScope(scope: AdaptableScope): boolean;
+    areAllBooleanColumnsInScope(scope: ColumnScope): boolean;
     /**
      * True if Scope contains ColumnIds
      * @param scope Scope to check
      */
-    scopeHasColumns(scope: AdaptableScope): boolean;
+    scopeHasColumns(scope: ColumnScope): boolean;
     /**
      * Gets string representation of the Scope
      * @param scope Scope to check
      */
-    getScopeToString(scope: AdaptableScope): string;
+    getScopeToString(scope: ColumnScope): string;
     /**
      * Whether PK column is included in Scope's column section
      * @param scope Scope to check
      */
-    isPrimaryKeyColumnInScopeColumns(scope: AdaptableScope): boolean;
+    isPrimaryKeyColumnInScopeColumns(scope: ColumnScope): boolean;
     /**
      * True if Column is in Scope's 'ColumnIds' section
      * @param column Column to check
      * @param scope Scope to check
      */
-    isColumnInScopeColumns(column: AdaptableColumn, scope: AdaptableScope): boolean;
+    isColumnInScopeColumns(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * Returns all the ColumnIds in the Scope
      * @param scope Scope to check
      */
-    getColumnIdsInScope(scope: AdaptableScope): string[] | undefined;
+    getColumnIdsInScope(scope: ColumnScope): string[] | undefined;
+    /**
+     * Returns all the ColumnTypes in the Scope
+     * @param scope Scope to check
+     */
+    getColumnTypesInScope(scope: ColumnScope): string[] | undefined;
     /**
      * Returns all the DataTypes in the Scope
      * @param scope Scope to check
      */
-    getDataTypesInScope(scope: AdaptableScope): ScopeDataType[] | undefined;
+    getDataTypesInScope(scope: ColumnScope): ScopeDataType[] | undefined;
     /**
      * True if Scope has Numeric DataType containing Column
      * @param column Column to check
      * @param scope Scope to check
      */
-    isColumnInNumericScope(column: AdaptableColumn, scope: AdaptableScope): boolean;
+    isColumnInNumericScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * True if Scope has String DataType containing Column
      * @param column Column to check
      * @param scope Scope to check
      */
-    isColumnInStringsScope(column: AdaptableColumn, scope: AdaptableScope): boolean;
+    isColumnInStringsScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * True if Scope has Data DataType which contains Column
      * @param column Column to check
      * @param scope Scope to check
      */
-    isColumnInDateScope(column: AdaptableColumn, scope: AdaptableScope): boolean;
+    isColumnInDateScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     /**
      * True if first scope is in second Scope
      *
@@ -125,15 +135,15 @@ export interface ScopeApi {
      * @param scopeA first Scope
      * @param scopeB second Scope
      */
-    isScopeInScope(scopeA: AdaptableScope, scopeB: AdaptableScope): boolean;
+    isScopeInScope(scopeA: ColumnScope, scopeB: ColumnScope): boolean;
     /**
      * Provides a description for the Scope
      * @param scope The Scope to check
      */
-    getScopeDescription(scope: AdaptableScope): string;
+    getScopeDescription(scope: ColumnScope): string;
     /**
      * Creates Cell Color Ranges (used in Format Column) for given Scope
      * @param scope Scope to use
      */
-    createCellColorRangesForScope(scope: AdaptableScope): CellColorRange[];
+    createCellColorRangesForScope(scope: ColumnScope): CellColorRange[];
 }

package/src/Api/CommentApi.d.ts

@@ -1,58 +1,56 @@
 import { CommentThread } from '../PredefinedConfig/CommentState';
-import { CellAddress } from '../PredefinedConfig/CellAddress';
-import { AdaptableComment } from '../types';
+import { AdaptableComment, CellAddress } from '../types';
 /**
- * Provides run-time access to Notes Module and related State
+ * Provides run-time access to Comment Module and related State
  */
 export interface CommentApi {
     /**
-     * Add comment to comment thread
+     * Add a Comment to a Comment Thread
      *
      * @param comment comment
-     * @param address where the comment should be added
+     * @param cellAddress cell where comment is added
      */
-    addComment(commentText: string, address: CellAddress): void;
+    addComment(commentText: string, cellAddress: CellAddress): void;
     /**
-     * Edit comment
+     * Edit a Comment
      *
      * @param comment Comment to edit
      * @param cellAddress Location of the comment, if not provided all comments will be traversed to find the comment
      */
     editComment(comment: AdaptableComment, cellAddress?: CellAddress): void;
     /**
-     * Delete a comment
+     * Delete a Comment
      * @param address Location of the comment, if not provided all comments will be traversed to find the comment
      */
     deleteComment(comment: AdaptableComment, cellAddress: CellAddress): void;
     /**
-     * Gets comments on a particular cell
-     * @param CellAddress
+     * Create a new Comment Thread
+     *
+     * @param commentThread
      */
-    getComments(cellAddress: CellAddress): AdaptableComment[];
+    addCommentThread(commentThread: CommentThread): void;
     /**
-     *  Delete all comments on a particular cell
+     *  Delete all Comments for a particular cell
      * @param cellAddress
      */
     deleteCommentThread(cellAddress: CellAddress): void;
     /**
-     * Returns cell comments at the given address
+     * Return the Comment Thread for a particular cell
      * @param cellAddress
      */
     getCommentThread(cellAddress: CellAddress): CommentThread | undefined;
     /**
-     * Returns all comment threads
+     * Return all Comment Threads in the grid
      */
-    getCommentThreads(): CommentThread[];
+    getGridComments(): CommentThread[];
     /**
-     * Called to add a new comment thread
+     * Sets the Comment Threads in the grid
      *
-     * @param commentThread
+     * @param commentThreads new cell comments
      */
-    addCommentThread(commentThread: CommentThread): void;
+    setGridComments(commentThreads: CommentThread[]): void;
     /**
-     * Called to set all cell comments
-     *
-     * @param commentThreads new cell comments
+     * Clear all Comment Threads in the grid
      */
-    loadCommentThreads(commentThreads: CommentThread[]): void;
+    clearGridComments(): void;
 }