@syncfusion/ej2-treegrid 28.2.6 → 29.1.37

package/src/treegrid/base/treegrid.d.ts

@@ -165,25 +165,26 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     freezeModule: Freeze;
     /**
-     * Gets or sets the number of frozen rows.
+     * Specifies the number of rows that should remain visible and fixed at the top of the TreeGrid during scrolling.
+     *
+     * This feature helps improve readability in data-heavy grids by keeping the header rows or key rows visible.
      *
      * @default 0
      */
     frozenRows: number;
     /**
-     * Gets or sets the number of frozen columns.
+     * Specifies the number of columns that should remain visible and fixed on the left side of the TreeGrid during horizontal scrolling.
+     *
+     * This feature ensures key columns, such as identifiers, stay visible while users scroll through data.
      *
      * @default 0
      */
     frozenColumns: number;
     /**
-     *  Defines the mode of clip. The available modes are,
-     * ```props
-     * * Clip :- Truncates the cell content when it overflows its area.
-     * * Ellipsis :- Displays ellipsis when the cell content overflows its area.
-     * * EllipsisWithTooltip :- Displays ellipsis when the cell content overflows its area,
-     * ```
-     * also it will display the tooltip while hover on ellipsis is applied.
+     * Defines the options for printing the TreeGrid.
+     * The available print modes are:
+     * * `AllPages`: Prints all pages of the TreeGrid.
+     * * `CurrentPage`: Prints only the current page of the TreeGrid.
      *
      * @default Syncfusion.EJ2.Grids.ClipMode.Ellipsis
      * @aspType Syncfusion.EJ2.Grids.ClipMode
@@ -259,7 +260,10 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     parentIdMapping: string;
     /**
-     * Specifies whether to load all the rows in collapsed state when the TreeGrid is rendered for the first time.
+     * Specifies whether to load all rows in a collapsed state when the TreeGrid is initially rendered.
+     *
+     * This setting is particularly useful when dealing with large datasets, as it helps enhance loading performance by
+     * reducing initial data rendering.
      *
      * @default false
      */
@@ -271,7 +275,10 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     expandStateMapping: string;
     /**
-     * If `allowRowDragAndDrop` is set to true, you can drag and drop treegrid rows at another treegrid.
+     * If `allowRowDragAndDrop` is set to true, row reordering functionality is enabled, allowing rows to be dragged
+     * and dropped within the TreeGrid or across TreeGrids.
+     *
+     * This feature enables users to reorganize data dynamically via drag-and-drop operations.
      *
      * @default false
      */
@@ -286,7 +293,7 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     dataSource: Object | DataManager;
     /**
-     * Defines the external [`Query`](https://ej2.syncfusion.com/documentation/data/api-query.html)
+     * Defines the external [Query](https://ej2.syncfusion.com/documentation/data/api-query.html)
      * that will be executed along with data processing.
      *
      * @default null
@@ -297,11 +304,10 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     cloneQuery: Query;
     /**
-     * Defines the print modes. The available print modes are
-     * ```props
-     * * AllPages :- Prints all pages of the TreeGrid.
-     * * CurrentPage :- Prints the current page of the TreeGrid.
-     * ```
+     * Defines the options for printing the TreeGrid.
+     * The available print modes are:
+     * * `AllPages`: Prints all pages of the TreeGrid.
+     * * `CurrentPage`: Prints only the current page of the TreeGrid.
      *
      * @default Syncfusion.EJ2.Grids.PrintMode.AllPages
      * @isEnumeration true
@@ -382,7 +388,7 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
     /**
      * If `showColumnMenu` set to true, then it will enable the column menu options in each columns.
      *
-     * > Check the [`Column menu`](../../treegrid/columns/#column-menu/) for its configuration.
+     * > Check the [Column menu](../../treegrid/columns/#column-menu/) for its configuration.
      *
      * @default false
      */
@@ -414,7 +420,7 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
     sortSettings: SortSettingsModel;
     /**
      * Configures the TreeGrid aggregate rows.
-     * > Check the [`Aggregates`](../../treegrid/aggregates/aggregates) for its configuration.
+     * > Check the [Aggregates](../../treegrid/aggregates/aggregates) for its configuration.
      *
      * @default []
      */
@@ -481,14 +487,13 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     toolbarTemplate: string | Function;
     /**
-     * Defines the mode of TreeGrid lines. The available modes are,
-     * ```props
-     * * Both :- Displays both horizontal and vertical TreeGrid lines.
-     * * None :- No TreeGrid lines are displayed.
-     * * Horizontal :- Displays the horizontal TreeGrid lines only.
-     * * Vertical :- Displays the vertical TreeGrid lines only.
-     * * Default :- Displays TreeGrid lines based on the theme.
-     * ```
+     * Defines how TreeGrid content lines are displayed, determining the visibility of vertical and horizontal lines.
+     *
+     * * `Both`: Displays both horizontal and vertical grid lines.
+     * * `None`: Hides both horizontal and vertical grid lines.
+     * * `Horizontal`: Displays only horizontal grid lines.
+     * * `Vertical`: Displays only vertical grid lines.
+     * * `Default`: Adjusts line visibility based on the theme.
      *
      * @default Syncfusion.EJ2.Grids.GridLine.Default
      * @isEnumeration true
@@ -538,7 +543,7 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      * or HTML element ID.
      * > * The row template must be a table row.
      *
-     * > Check the [`Row Template`](../../treegrid/row) customization.
+     * > Check the [Row Template](../../treegrid/row) customization.
      *
      * @aspType string
      */
@@ -563,7 +568,7 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
     rowHeight: number;
     /**
      * If `enableAltRow` is set to true, the TreeGrid will render with `e-altrow` CSS class to the alternative tr elements.
-     * > Check the [`AltRow`](../../treegrid/row/#styling-alternate-rows/) to customize the styles of alternative rows.
+     * > Check the [AltRow](../../treegrid/row/#styling-alternate-rows/) to customize the styles of alternative rows.
      *
      * @default true
      */
@@ -643,43 +648,77 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     enableVirtualization: boolean;
     /**
-     * If `enableColumnVirtualization` set to true, then the Tree Grid will render only the columns visible within the view-port
-     * and load subsequent columns on horizontal scrolling. This helps to load large dataset of columns in Tree Grid.
+     * Enables column virtualization in the TreeGrid. When set to `true`, only columns visible within the viewport are rendered.
+     * Additional columns are loaded as you horizontally scroll. This is beneficial for rendering large datasets efficiently.
      *
      * @default false
      */
     enableColumnVirtualization: boolean;
     /**
-     * Specifies whether to display or remove the untrusted HTML values in the TreeGrid component.
-     * If `enableHtmlSanitizer` is set to true, then it will sanitize any suspected untrusted strings and scripts before rendering them.
+     * Determines whether to sanitize untrusted HTML content in the TreeGrid. If `true`, potentially harmful HTML strings
+     * and scripts are sanitized before rendering to protect against XSS attacks.
      *
      * @default false
      */
     enableHtmlSanitizer: boolean;
     /**
-     * If `enableInfiniteScrolling` set to true, then the data will be loaded in TreeGrid when the scrollbar reaches the end.
-     * This helps to load large dataset in TreeGrid.
+     * Enables infinite scrolling in the TreeGrid. When set to `true`, additional data is loaded as the scrollbar
+     * reaches the end. Useful for handling large datasets.
      *
      * @default false
-
      */
     enableInfiniteScrolling: boolean;
     /**
-     * Configures the infinite scroll settings.
+     * Configures settings for infinite scrolling.
      *
      * @default { enableCache: false, maxBlocks: 5, initialBlocks: 5 }
-
      */
     infiniteScrollSettings: InfiniteScrollSettingsModel;
     /**
-     * `columnQueryMode`provides options to retrieves data from the data source.Their types are
-     * * `All`: It retrieves whole data source.
-     * * `Schema`: retrieves data for all the defined columns in TreeGrid from the data source.
-     * * `ExcludeHidden`: retrieves data only for visible columns of TreeGrid from the data Source.
+     * Specifies how data is retrieved from the data source for the TreeGrid.
+     * The available modes are:
+     * * `All`: Retrieve the entire data source.
+     * * `Schema`: Retrieve data only for defined columns.
+     * * `ExcludeHidden`: Retrieve data only for visible columns in the TreeGrid.
      *
      * @default All
      */
     columnQueryMode: ColumnQueryModeType;
+    /**
+     * If `allowSelection` is set to true, selection of (highlight row) TreeGrid records by clicking is allowed.
+     *
+     * @default true
+     */
+    allowSelection: boolean;
+    /**
+     * Specifies the index of the row to be selected upon initial rendering.
+     * Also retrieves the index of the currently selected row.
+     *
+     * @default -1
+     */
+    selectedRowIndex: number;
+    /**
+     * Configures the selection behavior.
+     *
+     * @default {mode: 'Row', cellSelectionMode: 'Flow', type: 'Single'}
+     */
+    selectionSettings: SelectionSettingsModel;
+    /**
+     * Enables exporting the TreeGrid to an Excel file if set to true.
+     *
+     * > Check the [ExcelExport](../../treegrid/excel-export/) documentation for more details.
+     *
+     * @default false
+     */
+    allowExcelExport: boolean;
+    /**
+     * Enables exporting the TreeGrid to a PDF file if set to true.
+     *
+     * > Check the [PdfExport](../../treegrid/pdf-export/) documentation for more details.
+     *
+     * @default false
+     */
+    allowPdfExport: boolean;
     /**
      * Triggers when the component is created.
      *
@@ -687,158 +726,161 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     created: EmitType<Object>;
     /**
-     * This event allows customization of TreeGrid properties before rendering.
+     * Allows customization of TreeGrid properties before rendering.
      *
      * @event load
      */
     load: EmitType<Object>;
     /**
-     * Triggers while expanding the TreeGrid record
+     * Triggers while a TreeGrid record is expanding.
      *
      * @event expanding
      */
     expanding: EmitType<RowExpandingEventArgs>;
     /**
-     * Triggers after the record is expanded
+     * Triggers after a TreeGrid record is expanded.
      *
      * @event expanded
      */
     expanded: EmitType<RowExpandedEventArgs>;
     /**
-     * Triggers while collapsing the TreeGrid record
+     * Triggers while a TreeGrid record is collapsing.
      *
      * @event collapsing
      */
     collapsing: EmitType<RowCollapsingEventArgs>;
     /**
-     * Triggers after the record is collapsed.
+     * Triggers after a TreeGrid record is collapsed.
      *
      * @event collapsed
      */
     collapsed: EmitType<RowCollapsedEventArgs>;
     /**
-     * Triggers when cell is saved.
+     * Triggers when a cell is being saved.
      *
      * @event cellSave
      */
     cellSave: EmitType<CellSaveArgs>;
     /**
-     * Triggers when cell is saved.
+     * Triggers after a cell is saved.
      *
      * @event cellSaved
      */
     cellSaved: EmitType<CellSaveArgs>;
     /**
-     * Triggers when TreeGrid actions such as sorting, filtering, paging etc., starts.
+     * Triggers when TreeGrid actions like sorting, filtering, paging, etc., start.
+     *
      * @event actionBegin
      */
     actionBegin: EmitType<PageEventArgs | FilterEventArgs | SortEventArgs | SearchEventArgs | AddEventArgs | SaveEventArgs | EditEventArgs | DeleteEventArgs>;
     /**
-     * Triggers when TreeGrid actions such as sorting, filtering, paging etc. are completed.
+     * Triggers when TreeGrid actions like sorting, filtering, paging, etc., are completed.
+     *
      * @event actionComplete
      */
     actionComplete: EmitType<PageEventArgs | FilterEventArgs | SortEventArgs | SearchEventArgs | AddEventArgs | SaveEventArgs | EditEventArgs | DeleteEventArgs>;
     /**
-     * Triggers before the record is to be edit.
+     * Triggers before a record is edited.
+     *
      * @event beginEdit
      */
     beginEdit: EmitType<BeginEditArgs>;
     /**
      * Triggers when records are added in batch mode.
+     *
      * @event batchAdd
      */
     batchAdd: EmitType<BatchAddArgs>;
     /**
      * Triggers when records are deleted in batch mode.
+     *
      * @event batchDelete
      */
     batchDelete: EmitType<BatchDeleteArgs>;
     /**
-     * Triggers before records are added in batch mode.
+     * Triggers before records are cancelled in batch mode.
+     *
      * @event batchCancel
      */
     batchCancel: EmitType<BatchCancelArgs>;
     /**
      * Triggers before records are added in batch mode.
+     *
      * @event beforeBatchAdd
      */
     beforeBatchAdd: EmitType<BeforeBatchAddArgs>;
     /**
      * Triggers before records are deleted in batch mode.
+     *
      * @event beforeBatchDelete
      */
     beforeBatchDelete: EmitType<BeforeBatchDeleteArgs>;
     /**
      * Triggers before records are saved in batch mode.
+     *
      * @event beforeBatchSave
      */
     beforeBatchSave: EmitType<BeforeBatchSaveArgs>;
     /**
-     * Triggers when the cell is being edited.
+     * Triggers when a cell is being edited.
+     *
      * @event cellEdit
      */
     cellEdit: EmitType<CellEditArgs>;
     /**
-     * Triggers when any TreeGrid action failed to achieve the desired results.
+     * Triggers when any TreeGrid action fails to achieve the desired results.
      *
      * @event actionFailure
      */
     actionFailure: EmitType<FailureEventArgs>;
     /**
-     * Triggers when data source is populated in the TreeGrid.
+     * Triggers when the data source is populated in the TreeGrid.
      *
      * @event dataBound
      */
     dataBound: EmitType<Object>;
     /**
-     * Triggers when the TreeGrid data is added, deleted and updated.
-     * Invoke the done method from the argument to start render after edit operation.
+     * Triggers when data in the TreeGrid is added, deleted, or updated.
+     * Invoke the done method from the argument to start rendering after an edit operation.
      *
      * @event dataSourceChanged
 
      */
     dataSourceChanged: EmitType<DataSourceChangedEventArgs>;
     /**
-     * Triggers when the TreeGrid actions such as Sorting, Paging etc., are done.
-     * In this event,the current view data and total record count should be assigned to the `dataSource` based on the action performed.
+     * Triggers when TreeGrid actions such as sorting, paging, etc., are completed.
+     * The current view data and total record count should be assigned to the dataSource based on the action performed.
      *
      * @event dataStateChange
 
      */
     dataStateChange: EmitType<DataStateChangeEventArgs>;
     /**
-     * Triggers when record is double clicked.
+     * Triggers when a record is double-clicked.
      *
      * @event recordDoubleClick
      */
     recordDoubleClick: EmitType<RecordDoubleClickEventArgs>;
     /**
      * Triggered every time a request is made to access row information, element, or data.
-     * This will be triggered before the row element is appended to the TreeGrid element.
+     * This event is triggered before the row element is appended to the TreeGrid element.
      *
      * @event rowDataBound
      */
     rowDataBound: EmitType<RowDataBoundEventArgs>;
     /**
-     * Triggers after detail row expands.
-     * > This event triggers at initial expand.
+     * Triggers after a detail row expands. This event triggers initially during the first expand.
      *
      * @event detailDataBound
      */
     detailDataBound: EmitType<DetailDataBoundEventArgs>;
     /**
      * Triggered every time a request is made to access cell information, element, or data.
-     * This will be triggered before the cell element is appended to the TreeGrid element.
+     * This event is triggered before the cell element is appended to the TreeGrid element.
      *
      * @event queryCellInfo
      */
     queryCellInfo: EmitType<QueryCellInfoEventArgs>;
-    /**
-     * If `allowSelection` is set to true, it allows selection of (highlight row) TreeGrid records by clicking it.
-     *
-     * @default true
-     */
-    allowSelection: boolean;
     /**
      * Triggers before row selection occurs.
      *
@@ -852,9 +894,9 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     rowSelected: EmitType<RowSelectEventArgs>;
     /**
-     * Triggers before deselecting the selected row.
+     * Triggers before the selected row is deselected.
      *
-     * @event rowSelected
+     * @event rowDeselecting
 
      */
     rowDeselecting: EmitType<RowDeselectEventArgs>;
@@ -865,7 +907,7 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     rowDeselected: EmitType<RowDeselectEventArgs>;
     /**
-     * Triggered for stacked header.
+     * Triggered for accessing header information.
      *
      * @event headerCellInfo
      */
@@ -877,14 +919,14 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     cellSelecting: EmitType<CellSelectingEventArgs>;
     /**
-     * Triggers before column menu opens.
+     * Triggers before the column menu opens.
      *
      * @event columnMenuOpen
 
      */
     columnMenuOpen: EmitType<ColumnMenuOpenEventArgs>;
     /**
-     * Triggers when click on column menu.
+     * Triggers when there is a click on the column menu.
      *
      * @event columnMenuClick
      */
@@ -896,284 +938,230 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     cellSelected: EmitType<CellSelectEventArgs>;
     /**
-     * Triggers before the selected cell is deselecting.
+     * Triggers before a selected cell is deselected.
      *
      * @event cellDeselecting
 
      */
     cellDeselecting: EmitType<CellDeselectEventArgs>;
     /**
-     * Triggers when a particular selected cell is deselected.
+     * Triggers when a selected cell is deselected.
      *
      * @event cellDeselected
 
      */
     cellDeselected: EmitType<CellDeselectEventArgs>;
     /**
-     * Triggers when column resize starts.
+     * Triggers when column resizing starts.
      *
      * @event resizeStart
 
      */
     resizeStart: EmitType<ResizeArgs>;
     /**
-     * Triggers on column resizing.
+     * Triggers during column resizing.
      *
      * @event resizing
-
      */
     resizing: EmitType<ResizeArgs>;
     /**
-     * Triggers when column resize ends.
+     * Triggers when column resizing ends.
      *
      * @event resizeStop
-
      */
     resizeStop: EmitType<ResizeArgs>;
     /**
-     * Triggers when column header element drag (move) starts.
+     * Triggers when column header dragging begins.
      *
      * @event columnDragStart
-
      */
     columnDragStart: EmitType<ColumnDragEventArgs>;
     /**
-     * Triggers when column header element is dragged (moved) continuously.
+     * Triggers continuously while the column header is being dragged.
      *
      * @event columnDrag
-
      */
     columnDrag: EmitType<ColumnDragEventArgs>;
     /**
-     * Triggers when a column header element is dropped on the target column.
+     * Triggers when a column header is dropped onto the target column.
      *
      * @event columnDrop
-
      */
     columnDrop: EmitType<ColumnDragEventArgs>;
     /**
-     * Triggers when the check box state change in checkbox column.
+     * Triggers when the state of a checkbox changes in a checkbox column.
      *
      * @event checkboxChange
-
      */
     checkboxChange: EmitType<CheckBoxChangeEventArgs>;
     /**
-     * Triggers after print action is completed.
+     * Triggers after the print action has been completed.
      *
      * @event printComplete
-
      */
     printComplete: EmitType<PrintEventArgs>;
     /**
-     * Triggers before the print action starts.
+     * Triggers before the print action begins.
      *
      * @event beforePrint
-
      */
     beforePrint: EmitType<PrintEventArgs>;
     /**
-     * Triggers when toolbar item is clicked.
+     * Triggers when a toolbar item is clicked.
      *
      * @event toolbarClick
      */
     toolbarClick: EmitType<ClickEventArgs>;
     /**
-     * Triggers before data is bound to Tree Grid.
+     * Triggers before data is bound to the TreeGrid.
      *
      * @event beforeDataBound
      */
     beforeDataBound: EmitType<BeforeDataBoundArgs>;
     /**
-     * Triggers before context menu opens.
+     * Triggers before the context menu opens.
      *
      * @event contextMenuOpen
-
      */
     contextMenuOpen: EmitType<BeforeOpenCloseMenuEventArgs>;
     /**
-     * Triggers when click on context menu.
+     * Triggers when an item in the context menu is clicked.
      *
      * @event contextMenuClick
      */
     contextMenuClick: EmitType<MenuEventArgs>;
     /**
-     * Triggers before TreeGrid copy action.
+     * Triggers before the TreeGrid copy action is initiated.
      *
      * @event beforeCopy
-
      */
     beforeCopy: EmitType<BeforeCopyEventArgs>;
     /**
-     * Triggers before TreeGrid paste action.
+     * Triggers before the TreeGrid paste action is initiated.
      *
      * @event beforePaste
-
      */
     beforePaste: EmitType<BeforePasteEventArgs>;
     /**
-     * Triggers when row elements are dragged (moved) continuously.
+     * Triggers continuously while row elements are being dragged.
      *
      * @event rowDrag
-
      */
     rowDrag: EmitType<RowDragEventArgs>;
     /**
-     * Triggers when row element’s drag(move) starts.
+     * Triggers when row element dragging starts.
      *
      * @event rowDragStart
-
      */
     rowDragStart: EmitType<RowDragEventArgs>;
     /**
-     * Triggers when row element’s before drag(move).
+     * Triggers just before the row element dragging begins.
      *
      * @event rowDragStartHelper
-
      */
     rowDragStartHelper: EmitType<RowDragEventArgs>;
     /**
-     * Triggers when row elements are dropped on the target row.
+     * Triggers when a row element is dropped onto the target row.
      *
      * @event rowDrop
-
      */
     rowDrop: EmitType<RowDragEventArgs>;
     /**
-     * The `selectedRowIndex` allows you to select a row at initial rendering.
-     * You can also get the currently selected row index.
-     *
-     * @default -1
-     */
-    selectedRowIndex: number;
-    /**
-     * Configures the selection settings.
-     *
-     * @default {mode: 'Row', cellSelectionMode: 'Flow', type: 'Single'}
-     */
-    selectionSettings: SelectionSettingsModel;
-    /**
-     * If `allowExcelExport` set to true, then it will allow the user to export treegrid to Excel file.
-     *
-     * > Check the [`ExcelExport`](../../treegrid/excel-export/) to configure exporting document.
-     *
-     * @default false
-     */
-    allowExcelExport: boolean;
-    /**
-     * If `allowPdfExport` set to true, then it will allow the user to export treegrid to Pdf file.
-     *
-     * > Check the [`Pdfexport`](../../treegrid/pdf-export/) to configure the exporting document.
-     *
-     * @default false
-     */
-    allowPdfExport: boolean;
-    /**
-     * Triggers before exporting each cell to PDF document.
-     * You can also customize the PDF cells.
+     * Triggers before each cell is exported to a PDF document, allowing customization of cells.
      *
      * @event pdfQueryCellInfo
-
      */
     pdfQueryCellInfo: EmitType<PdfQueryCellInfoEventArgs>;
     /**
-     * Triggers before exporting each header cell to PDF document.
-     * You can also customize the PDF cells.
+     * Triggers before each header cell is exported to a PDF document, allowing customization of cells.
      *
      * @event pdfHeaderQueryCellInfo
-
      */
     pdfHeaderQueryCellInfo: EmitType<PdfHeaderQueryCellInfoEventArgs>;
     /**
-     * Triggers before exporting each cell to Excel file.
-     * You can also customize the Excel cells.
+     * Triggers before each cell is exported to an Excel file, allowing customization of cells.
      *
      * @event excelQueryCellInfo
-
      */
     excelQueryCellInfo: EmitType<ExcelQueryCellInfoEventArgs>;
     /**
-     * Triggers before exporting each header cell to Excel file.
-     * You can also customize the Excel cells.
+     * Triggers before each header cell is exported to an Excel file, allowing customization of cells.
      *
      * @event excelHeaderQueryCellInfo
-
      */
     excelHeaderQueryCellInfo: EmitType<ExcelHeaderQueryCellInfoEventArgs>;
     /**
-     * Triggers before TreeGrid data is exported to Excel file.
+     * Triggers before TreeGrid data is exported to an Excel file.
      *
      * @event beforeExcelExport
      */
     beforeExcelExport: EmitType<Object>;
     /**
-     * Triggers after TreeGrid data is exported to Excel file.
+     * Triggers after TreeGrid data is exported to an Excel file.
      *
      * @event excelExportComplete
-
      */
     excelExportComplete: EmitType<ExcelExportCompleteArgs>;
     /**
-     * Triggers before TreeGrid data is exported to PDF document.
+     * Triggers before TreeGrid data is exported to a PDF document.
      *
      * @event beforePdfExport
      */
     beforePdfExport: EmitType<Object>;
     /**
-     * Triggers after TreeGrid data is exported to PDF document.
+     * Triggers after TreeGrid data is exported to a PDF document.
      *
      * @event pdfExportComplete
-
      */
     pdfExportComplete: EmitType<PdfExportCompleteArgs>;
     /**
-     * Export TreeGrid data to Excel file(.xlsx).
+     * Exports the TreeGrid data to an Excel file (.xlsx).
      *
-     * @param  {ExcelExportProperties | TreeGridExcelExportProperties} excelExportProperties - Defines the export properties of the Tree Grid.
-     * @param  {boolean} isMultipleExport - Define to enable multiple export.
-     * @param  {workbook} workbook - Defines the Workbook if multiple export is enabled.
-     * @param  {boolean} isBlob - If 'isBlob' set to true, then it will be returned as blob data.
-     * @returns {Promise<any>} - Returns promise object of export action
+     * @param {ExcelExportProperties | TreeGridExcelExportProperties} excelExportProperties - The properties used to configure the Excel export.
+     * @param {boolean} isMultipleExport - Indicates whether multiple exporting is enabled.
+     * @param {workbook} workbook - The workbook instance used for multiple exports.
+     * @param {boolean} isBlob - If set to true, the result will be returned as blob data.
+     * @returns {Promise<any>} - Returns a promise that resolves with the result of the export action.
      */
     excelExport(excelExportProperties?: ExcelExportProperties | TreeGridExcelExportProperties, isMultipleExport?: boolean, workbook?: any, isBlob?: boolean): Promise<any>;
     /**
-     * Export TreeGrid data to CSV file.
+     * Exports the TreeGrid data to a CSV file.
      *
-     * @param  {ExcelExportProperties} excelExportProperties - Defines the export properties of the TreeGrid.
-     * @param  {boolean} isMultipleExport - Define to enable multiple export.
-     * @param  {workbook} workbook - Defines the Workbook if multiple export is enabled.
-     * @param  {boolean} isBlob - If 'isBlob' set to true, then it will be returned as blob data.
-     * @returns {Promise<any>} - Returns promise object of export action
+     * @param {ExcelExportProperties} excelExportProperties - The properties used to configure the CSV export.
+     * @param {boolean} isMultipleExport - Indicates whether multiple exporting is enabled.
+     * @param {workbook} workbook - The workbook instance used for multiple exports.
+     * @param {boolean} isBlob - If set to true, the result will be returned as blob data.
+     * @returns {Promise<any>} - Returns a promise that resolves with the result of the export action.
      */
     csvExport(excelExportProperties?: ExcelExportProperties, isMultipleExport?: boolean, workbook?: any, isBlob?: boolean): Promise<any>;
     /**
-     * Export TreeGrid data to PDF document.
+     * Exports the TreeGrid data to a PDF document.
      *
-     * @param {PdfExportProperties | TreeGridPdfExportProperties} pdfExportProperties - Defines the export properties of the Tree Grid.
-     * @param {boolean} isMultipleExport - Define to enable multiple export.
-     * @param {Object} pdfDoc - Defined the Pdf Document if multiple export is enabled.
-     * @param {boolean} isBlob - If 'isBlob' set to true, then it will be returned as blob data.
-     * @returns {Promise<any>} - Returns promise object of export action
+     * @param {PdfExportProperties | TreeGridPdfExportProperties} pdfExportProperties - The properties used to configure the PDF export.
+     * @param {boolean} isMultipleExport - Indicates whether multiple exporting is enabled.
+     * @param {Object} pdfDoc - The PDF document instance used for multiple exports.
+     * @param {boolean} isBlob - If set to true, the result will be returned as blob data.
+     * @returns {Promise<any>} - Returns a promise that resolves with the result of the export action.
      */
     pdfExport(pdfExportProperties?: PdfExportProperties | TreeGridPdfExportProperties, isMultipleExport?: boolean, pdfDoc?: Object, isBlob?: boolean): Promise<Object>;
     /**
-     * Sends a post request to export tree grid to excel file in server side.
+     * Sends a POST request to export the TreeGrid to an Excel file on the server side.
      *
-     * @param  {string} url - Pass URL for server side excel export action.
+     * @param {string} url - The URL for the server-side Excel export action.
      * @returns {void}
      */
     serverExcelExport(url: string): void;
     /**
-     * Sends a post request to export tree grid to pdf file in server side.
+     * Sends a POST request to export the TreeGrid to a PDF document on the server side.
      *
-     * @param  {string} url - Pass URL for server-side pdf export action.
+     * @param {string} url - The URL for the server-side PDF export action.
      * @returns {void}
      */
     serverPdfExport(url: string): void;
     /**
-     * Sends a Post request to export Tree Grid to CSV file in server side.
+     * Sends a POST request to export the TreeGrid to a CSV file on the server side.
      *
-     * @param  {string} url - Pass URL for server-side csv export action.
+     * @param {string} url - The URL for the server-side CSV export action.
      * @returns {void}
      */
     serverCsvExport(url: string): void;
@@ -1214,62 +1202,57 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     protected preRender(): void;
     /**
-     * Sorts a column with the given options.
+     * Sorts a column with the specified options.
      *
-     * @param {string} columnName - Defines the column name to be sorted.
-     * @param {SortDirection} direction - Defines the direction of sorting field.
-     * @param {boolean} isMultiSort - Specifies whether the previous sorted columns are to be maintained.
+     * @param {string} columnName - The name of the column to be sorted.
+     * @param {SortDirection} direction - The direction of the sorting operation.
+     * @param {boolean} isMultiSort - Specifies whether previous sorted columns should be maintained during sorting.
      * @returns {void}
      */
     sortByColumn(columnName: string, direction: SortDirection, isMultiSort?: boolean): void;
     /**
-     * Clears all the sorted columns of the TreeGrid.
+     * Clears all the sorted columns in the TreeGrid.
      *
      * @returns {void}
      */
     clearSorting(): void;
     /**
-     * Remove sorted column by field name.
+     * Removes the sorted state from a column specified by the field name.
      *
-     * @param {string} field - Defines the column field name to remove sort.
+     * @param {string} field - The field name of the column from which the sort state should be removed.
      * @returns {void}
      * @hidden
      */
     removeSortColumn(field: string): void;
     /**
-     * Searches TreeGrid records using the given key.
-     * You can customize the default search option by using the
-     * [`searchSettings`](./#searchsettings/).
+     * Searches for TreeGrid records using a specified search string.
+     * Customize the search behavior through the [searchSettings](./#searchsettings/).
      *
-     * @param  {string} searchString - Defines the key.
+     * @param {string} searchString - The string used as the search key.
      * @returns {void}
      */
     search(searchString: string): void;
     /**
-     * Changes the column width to automatically fit its content to ensure that the width shows the content without wrapping/hiding.
-     * > * This method ignores the hidden columns.
-     * > * Uses the `autoFitColumns` method in the `dataBound` event to resize at initial rendering.
+     * Adjusts column widths to fit their content, ensuring content is displayed without wrapping or truncation.
+     * - Hidden columns are ignored by this method.
+     * - Use the `autoFitColumns` method during the `dataBound` event for initial rendering.
      *
-     * @param  {string |string[]} fieldNames - Defines the column names.
+     * @param {string | string[]} fieldNames - The name(s) of the column(s) to be auto-fitted.
      * @returns {void}
-     *
-     *
-     *
      */
     autoFitColumns(fieldNames?: string | string[]): void;
     /**
-     * Changes the TreeGrid column positions by field names.
+     * Reorders TreeGrid columns by specifying their field names.
      *
-     * @param  {string} fromFName - Defines the origin field name.
-     * @param  {string} toFName - Defines the destination field name.
+     * @param {string | string[]} fromFName - The field name(s) of the column(s) to be moved.
+     * @param {string} toFName - The destination field name to place the moved columns.
      * @returns {void}
      */
     reorderColumns(fromFName: string | string[], toFName: string): void;
     private TreeGridLocale;
     /**
-     * By default, prints all the pages of the TreeGrid and hides the pager.
-     * > You can customize print options using the
-     * [`printMode`](./#printmode).
+     * Prints all the pages of the TreeGrid and hides the pager by default.
+     * Customize print options using the [printMode](./#printmode).
      *
      * @returns {void}
      */
@@ -1279,16 +1262,19 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
     private findPreviousRowElement;
     private initProperties;
     /**
-     * Binding events to the element while component creation.
+     * Attaches event handlers to the necessary elements during the component's initialization.
      *
      * @hidden
      * @returns {void}
      */
     wireEvents(): void;
     /**
-     * To provide the array of modules needed for component rendering
+     * Provides a list of the modules that are required for rendering the TreeGrid component.
+     *
+     * This method is essential for ensuring that all dependent modules are loaded and available
+     * during the component's lifecycle, enabling full functionality.
      *
-     * @returns {ModuleDeclaration[]} - Returns TreeGrid modules collection
+     * @returns {ModuleDeclaration[]} - Returns an array of the required TreeGrid module declarations.
      * @hidden
      */
     requiredModules(): ModuleDeclaration[];
@@ -1368,6 +1354,7 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     private getGridToolbar;
     private getGridColumns;
+    private lastRowCellBorderUpdated;
     /**
      * Called internally if any of the property value changed.
      *
@@ -1378,14 +1365,19 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
     onPropertyChanged(newProp: TreeGridModel): void;
     private updateTreeColumnTextAlign;
     /**
-     * Destroys the component (detaches/removes all event handlers, attributes, classes, and empties the component element).
+     * Destroys the TreeGrid component by detaching event handlers,
+     * removing attributes and classes, and clearing the component's DOM elements.
+     *
+     * This method ensures that all resources used by the TreeGrid are properly released
+     * and the component is cleaned up from the DOM to prevent memory leaks.
      *
      * @method destroy
      * @returns {void}
      */
     destroy(): void;
     /**
-     * Update the TreeGrid model
+     * Updates the TreeGrid model and ensures that the underlying Grid's data model is in sync with TreeGrid.
+     * This method binds current data and settings to the TreeGrid.
      *
      * @method dataBind
      * @returns {void}
@@ -1393,7 +1385,10 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     dataBind(): void;
     /**
-     * Get the properties to be maintained in the persisted state.
+     * Retrieves the properties of the TreeGrid that should be retained and persisted between sessions.
+     *
+     * The method ensures that user preferences and important settings like paging, sorting, filtering,
+     * column configurations, etc., are preserved and can be restored when the component is re-initialized.
      *
      * @returns {string} - Returns persist properties details
      * @hidden
@@ -1403,41 +1398,53 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
     private ignoreInColumn;
     private mouseClickHandler;
     /**
-     * Returns TreeGrid rows
+     * Retrieves all the TreeGrid row elements.
+     *
+     * This method is useful for accessing the HTML representation of the rows for further manipulation or inspection.
      *
      * @returns {HTMLTableRowElement[]} - Returns row elements collection
      */
     getRows(): HTMLTableRowElement[];
     /**
-     * Gets the pager of the TreeGrid.
+     * Obtains the pager element of the TreeGrid.
+     *
+     * The pager enables navigation between pages when the TreeGrid displays paginated data.
      *
      * @returns {Element} - Returns pager element
      */
     getPager(): Element;
     /**
-     * Adds a new record to the TreeGrid. Without passing parameters, it adds empty rows.
-     * > `editSettings.allowEditing` should be true.
+     * Adds a new record to the TreeGrid at the specified position or default location.
+     *
+     * @param {Object} data - Object containing the data for the new record. If omitted, an empty row is added.
+     * @param {number} index - The index at which the new row should be added.
+     * @param {RowPosition} position - Specifies the position of the new row (e.g., before, after or child).
+     *
+     * > Requires `editSettings.allowAdding` to be true.
      *
-     * @param {Object} data - Defines the new add record data.
-     * @param {number} index - Defines the row index to be added.
-     * @param {RowPosition} position - Defines the new row position to be added.
      * @returns {void}
      */
     addRecord(data?: Object, index?: number, position?: RowPosition): void;
     /**
-     * Cancels edited state.
+     * Cancels the current edit operation on the TreeGrid.
+     *
+     * This method discards changes made to the row and exits the edit mode without saving.
      *
      * @returns {void}
      */
     closeEdit(): void;
     /**
-     * Saves the cell that is currently edited. It does not save the value to the DataSource.
+     * Saves the current cell value changes without committing to the data source.
+     *
+     * This operation persists the changes in the UI but not in the underlying data model.
      *
      * @returns {void}
      */
     saveCell(): void;
     /**
-     * To update the specified cell by given value without changing into edited state.
+     * Updates the value of a specific cell directly, bypassing the edit mode.
+     *
+     * This method provides a quick way to update the UI and data without user interaction.
      *
      * @param {number} rowIndex Defines the row index.
      * @param {string} field Defines the column field.
@@ -1446,210 +1453,278 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     updateCell(rowIndex: number, field: string, value: string | number | boolean | Date): void;
     /**
-     * To update the specified row by given values without changing into edited state.
+     * Updates a specific row with given values directly, skipping the edit state.
      *
-     * @param {number} index Defines the row index.
-     * @param {Object} data Defines the data object to be updated.
+     * This method allows for bulk updates of row data programmatically.
+     *
+     * @param {number} index - The index of the row to update.
+     * @param {Object} data - The data object containing updated field values.
      * @returns {void}
      */
     updateRow(index: number, data: Object): void;
     /**
-     * Delete a record with Given options. If fieldName and data is not given then TreeGrid will delete the selected record.
-     * > `editSettings.allowDeleting` should be true.
+     * Deletes a record based on specified criteria or the selected record if none specified.
      *
-     * @param {string} fieldName - Defines the primary key field, 'Name of the column'.
-     * @param {Object} data - Defines the JSON data of the record to be deleted.
+     * @param {string} fieldName - The name of the primary key field.
+     * @param {Object} data - The data object representing the record to delete.
      * @returns {void}
+     *
+     * > Requires `editSettings.allowDeleting` to be true.
      */
     deleteRecord(fieldName?: string, data?: Object): void;
     /**
-     * To edit any particular row by TR element.
+     * Initiates editing for a specific row using its HTML element.
+     *
+     * This allows for manual control of which row enters edit mode through the UI.
      *
-     * @param {HTMLTableRowElement} row - Defines the table row to be edited.
+     * @param {HTMLTableRowElement} row - The table row element to enter into edit mode.
      * @returns {void}
      */
     startEdit(row?: HTMLTableRowElement): void;
     /**
-     * To edit any particular cell using row index and cell index.
+     * Begins editing of a specific cell using row and field indices.
      *
-     * @param {number} rowIndex - Defines row index to edit a particular cell.
-     * @param {string} field - Defines the field name of the column to perform cell edit.
+     * Customers can programmatically specify which cell to edit without user input.
+     *
+     * @param {number} rowIndex - The index of the row containing the cell.
+     * @param {string} field - The field name of the cell to edit.
      * @returns {void}
      */
     editCell(rowIndex?: number, field?: string): void;
     /**
-     * Enables or disables ToolBar items.
+     * Enables or disables specified ToolBar items within the TreeGrid.
+     *
+     * This facilitates dynamic control of toolbar actions based on application logic.
      *
-     * @param {string[]} items - Defines the collection of itemID of ToolBar items.
-     * @param {boolean} isEnable - Defines the items to be enabled or disabled.
+     * @param {string[]} items - Array of ToolBar item IDs to enable or disable.
+     * @param {boolean} isEnable - Boolean flag to determine whether to enable (true) or disable (false) items.
      * @returns {void}
      */
     enableToolbarItems(items: string[], isEnable: boolean): void;
     /**
-     * If TreeGrid is in editable state, you can save a record by invoking endEdit.
+     * Commits the edits made to a record in edit mode, updating the data source.
+     *
+     * Use this method to finalize changes for rows in edit mode, ensuring persistence.
      *
      * @returns {void}
      */
     endEdit(): void;
     /**
-     * Column chooser can be displayed on screen by given position(X and Y axis).
+     * Displays the column chooser at a specified screen position.
      *
-     * @param {number} x - Defines the X axis.
-     * @param {number} y - Defines the Y axis.
+     * Useful for customizing the visibility of columns interactively via the UI.
+     *
+     * @param {number} x - The X-axis position of the column chooser.
+     * @param {number} y - The Y-axis position of the column chooser.
      * @returns {void}
      */
     openColumnChooser(x?: number, y?: number): void;
     /**
-     * Delete any visible row by TR element.
+     * Deletes a visible row from the TreeGrid using its HTML element.
+     *
+     * Apply this method when handling row deletions through DOM manipulations.
      *
-     * @param {HTMLTableRowElement} tr - Defines the table row element.
+     * @param {HTMLTableRowElement} tr - The table row element to remove.
      * @returns {void}
      */
     deleteRow(tr: HTMLTableRowElement): void;
     /**
-     * Get the names of the primary key columns of the TreeGrid.
+     * Retrieves the primary key field names used in the TreeGrid.
+     *
+     * This information is crucial for identifying and manipulating unique rows.
      *
-     * @returns {string[]} - Returns primary key collection
+     * @returns {string[]} - Returns an array of primary key field names.
      */
     getPrimaryKeyFieldNames(): string[];
     /**
-     * Updates particular cell value based on the given primary key value.
-     * > Primary key column must be specified using `columns.isPrimaryKey` property.
+     * Updates the value of a specific cell using its primary key for identification.
      *
-     * @param {string| number} key - Specifies the PrimaryKey value of dataSource.
-     * @param {string } field - Specifies the field name which you want to update.
-     * @param {string | number | boolean | Date} value - To update new value for the particular cell.
+     * Useful for targeted updates that leverage unique identifiers to ensure accuracy.
+     *
+     * @param {string| number} key - The primary key value of the row containing the cell.
+     * @param {string} field - The field name of the cell to update.
+     * @param {string | number | boolean | Date} value - The new value to assign to the specified cell.
      * @returns {void}
      */
     setCellValue(key: string | number, field: string, value: string | number | boolean | Date): void;
     /**
-     * Updates and refresh the particular row values based on the given primary key value.
-     * > Primary key column must be specified using `columns.isPrimaryKey` property.
+     * Updates the data for a specific row identified by its primary key and refreshes the display.
+     *
+     * Important for keeping the displayed data consistent with the source database or dataset.
      *
-     *  @param {string| number} key - Specifies the PrimaryKey value of dataSource.
-     *  @param {Object} rowData - To update new data for the particular row.
+     * @param {string| number} key - The primary key value of the row to update.
+     * @param {Object} rowData - The new data to apply to the row.
      * @returns {void}
      */
     setRowData(key: string | number, rowData?: ITreeData): void;
     /**
-     * Navigates to the specified target page.
+     * Navigates to a specified page number within the TreeGrid pagination.
+     *
+     * This can be used to programmatically change the page being viewed,
+     * allowing for scripted navigation through data.
      *
-     * @param  {number} pageNo - Defines the page number to navigate.
+     * @param {number} pageNo - The page number to navigate to. Must be within valid page range.
      * @returns {void}
      */
     goToPage(pageNo: number): void;
     /**
-     * Defines the text of external message.
+     * Updates the external message displayed within the pager component.
      *
-     * @param  {string} message - Defines the message to update.
+     * This is useful for showing custom messages or additional information
+     * related to the data set or pagination status.
+     *
+     * @param {string} message - The custom message to display in the pager.
      * @returns {void}
      */
     updateExternalMessage(message: string): void;
     /**
-     * Gets a cell by row and column index.
+     * Retrieves a cell element based on its row and column indices in the TreeGrid.
      *
-     * @param  {number} rowIndex - Specifies the row index.
-     * @param  {number} columnIndex - Specifies the column index.
-     * @returns {Element} - Returns cell element in grid content
+     * This method is helpful for accessing cell-level elements for custom
+     * operations or styling.
+     *
+     * @param {number} rowIndex - The index of the row containing the cell.
+     * @param {number} columnIndex - The index of the column containing the cell.
+     * @returns {Element} - Returns the HTML element of the specified cell.
      */
     getCellFromIndex(rowIndex: number, columnIndex: number): Element;
     /**
-     * Gets a Column by column name.
+     * Retrieves a column object by the column's field name.
+     *
+     * This is typically used for obtaining the details of a column for
+     * configuration or data manipulation purposes.
      *
-     * @param  {string} field - Specifies the column name.
-     * @returns {Column} - Returns tree grid column
+     * @param {string} field - The field name of the column.
+     * @returns {Column} - Returns the column object corresponding to the field.
      */
     getColumnByField(field: string): Column;
     /**
-     * Gets a column by UID.
+     * Fetches a column object using the column's unique identifier (UID).
+     *
+     * Useful in scenarios where columns do not have unique field names but
+     * are uniquely identifiable via UID.
      *
-     * @param  {string} uid - Specifies the column UID.
-     * @returns {Column} - Returns tree grid column
+     * @param {string} uid - The unique identifier for the column.
+     * @returns {Column} - Returns the column object for the given UID.
      */
     getColumnByUid(uid: string): Column;
     /**
-     * Gets the collection of column fields.
+     * Retrieves the names of all column fields in the TreeGrid.
      *
-     * @returns {string[]} - Returns column field name as collection
+     * This method provides a list of field names useful for dynamic operations
+     * or configuration where fields need to be enumerated or manipulated.
+     *
+     * @returns {string[]} - Returns an array of column field names.
      */
     getColumnFieldNames(): string[];
     /**
-     * Gets the footer div of the TreeGrid.
+     * Retrieves the footer content element of the TreeGrid, usually for styling or custom manipulation.
+     *
+     * This can be used to access the footer for adding custom functionality
+     * or styling purposes to enhance user interaction at the bottom of the grid.
      *
-     * @returns {Element} - Returns footer content div element
+     * @returns {Element} - Returns the footer content HTML element.
      */
     getFooterContent(): Element;
     /**
-     * Gets the footer table element of the TreeGrid.
+     * Acquires the footer table element of the TreeGrid for layout management.
+     *
+     * Useful for manipulating the table's structure or style beneath the grid content.
      *
-     * @returns {Element} - Returns footer content table element
+     * @returns {Element} - Returns the footer table HTML element.
      */
     getFooterContentTable(): Element;
     /**
-     * Shows a column by its column name.
+     * Shows one or more columns based on the specified column names.
      *
-     * @param  {string|string[]} keys - Defines a single or collection of column names.
-     * @param  {string} showBy - Defines the column key either as field name or header text.
+     * This is useful for dynamically adjusting the visibility of columns
+     * based on user actions or application logic.
+     *
+     * @param {string|string[]} keys - A single column name or an array of column names to show.
+     * @param {string} showBy - Key to determine visibility either as field name or header text.
      * @returns {void}
      */
     showColumns(keys: string | string[], showBy?: string): void;
     /**
-     * Hides a column by column name.
+     * Hides one or more columns based on the specified column names.
+     *
+     * Utilized to dynamically reduce the visibility of columns based on
+     * user roles or preferences.
      *
-     * @param  {string|string[]} keys - Defines a single or collection of column names.
-     * @param  {string} hideBy - Defines the column key either as field name or header text.
+     * @param {string|string[]} keys - A single column name or an array of column names to hide.
+     * @param {string} hideBy - Key to evaluate columns either as field name or header text.
      * @returns {void}
      */
     hideColumns(keys: string | string[], hideBy?: string): void;
     /**
-     * Gets a column header by column name.
+     * Retrieves a column header element based on the field name of the column.
+     *
+     * This method helps to directly manipulate headers, such as applying custom styles.
      *
-     * @param  {string} field - Specifies the column name.
-     * @returns {Element} - Returns column header element
+     * @param {string} field - The field name of the desired column.
+     * @returns {Element} - Returns the HTML element of the column header.
      */
     getColumnHeaderByField(field: string): Element;
     /**
-     * Gets a column header by column index.
+     * Acquires the column header element using the column's index.
      *
-     * @param  {number} index - Specifies the column index.
-     * @returns {Element} - Returns column header element
+     * Suitable for situations where direct column index is available
+     * and header access is needed for operations.
+     *
+     * @param {number} index - The index of the column.
+     * @returns {Element} - Returns the HTML element of the specified column header.
      */
     getColumnHeaderByIndex(index: number): Element;
     /**
-     * Gets a column header by UID.
+     * Retrieves a column header element utilizing the column's UID.
+     *
+     * Useful for precision access to header elements when UIDs are used
+     * uniquely to manage column identities.
      *
-     * @param {string} uid - Specifies the column uid.
-     * @returns {Element} - Returns column header element
+     * @param {string} uid - The UID of the column.
+     * @returns {Element} - Returns the HTML element of the column header.
      */
     getColumnHeaderByUid(uid: string): Element;
     /**
-     * Gets a column index by column name.
+     * Determines the column index by the specified field name.
      *
-     * @param  {string} field - Specifies the column name.
-     * @returns {number} - Returns column index
+     * Helpful in converting field names to indices for operations that require
+     * numeric input for array or collection indexing.
+     *
+     * @param {string} field - The field name of the column.
+     * @returns {number} - Returns the index of the column.
      */
     getColumnIndexByField(field: string): number;
     private getVirtualColIndexByUid;
     /**
-     * Gets a column index by UID.
+     * Determines the column index based on the unique identifier (UID).
+     *
+     * This can be crucial in scenarios that involve dynamic column management
+     * where UID provides an accurate reference.
      *
-     * @param  {string} uid - Specifies the column UID.
-     * @returns {number} - Returns column index
+     * @param {string} uid - The UID of the column.
+     * @returns {number} - Returns the column index.
      */
     getColumnIndexByUid(uid: string): number;
     /**
-     * Gets the columns from the TreeGrid.
+     * Fetches a collection of columns from the TreeGrid optionally refreshing the column model.
+     *
+     * Use this method to retrieve and optionally refresh the list of columns
+     * to ensure up-to-date configurations and settings.
      *
-     * @param {boolean} isRefresh - Defined whether to update DOM
-     * @returns {Column[]} - Returns treegrid columns collection
+     * @param {boolean} isRefresh - Determines whether to refresh the grid's column model.
+     * @returns {Column[]} - Returns an array of TreeGrid column objects.
      */
     getColumns(isRefresh?: boolean): Column[];
     private updateColumnModel;
     private updateColumnsWidth;
     /**
-     * Gets the content div of the TreeGrid.
+     * Retrieves the main content area of the TreeGrid.
      *
-     * @returns {Element} - Return tree grid content element
+     * This method allows access to the main content DIV, which can
+     * be used for layout adjustments or adding custom elements.
+     *
+     * @returns {Element} - Returns the TreeGrid content HTML element.
      */
     getContent(): Element;
     private mergePersistTreeGridData;
@@ -1659,124 +1734,177 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
     private isFrozenGrid;
     private updateTreeGridModel;
     /**
-     * Gets the content table of the TreeGrid.
+     * Retrieves the content table element of the TreeGrid.
+     *
+     * This table contains the main data display area, allowing for
+     * interaction and data manipulation directly within the TreeGrid.
      *
-     * @returns {Element} - Returns content table element
+     * @returns {Element} - Returns the HTML element representing the content table.
      */
     getContentTable(): Element;
     /**
-     * Gets all the TreeGrid's data rows.
+     * Obtains all data row elements from the TreeGrid, excluding summary rows.
      *
-     * @returns {Element[]} - Returns row elements
+     * Provides a way to access the visual representation of data for purposes
+     * like custom formatting or event binding.
+     *
+     * @returns {Element[]} - Returns an array of data row elements.
      */
     getDataRows(): Element[];
     /**
-     * Get current visible data of TreeGrid.
+     * Retrieves the current set of records that are visible in the TreeGrid view.
+     *
+     * This method excludes any summary rows to focus on the main data set
+     * currently being viewed by the user.
      *
-     * @returns {Object[]} - Returns current view records
+     * @returns {Object[]} - Returns an array of the current view records.
      * @isGenericType true
      */
     getCurrentViewRecords(): Object[];
     /**
-     * Gets the added, edited,and deleted data before bulk save to the DataSource in batch mode.
+     * Collects data changes (added, edited, and deleted) that have not been saved in batch mode.
+     *
+     * This allows you to view pending changes awaiting a commit to the data source.
      *
-     * @returns {Object} - Returns batch changes
+     * @returns {Object} - Returns an object detailing batch changes.
      */
     getBatchChanges(): Object;
     /**
-     * Gets the header div of the TreeGrid.
+     * Retrieves the header content element of the TreeGrid.
      *
-     * @returns {Element} - Returns Header content element
+     * Mainly used for interacting with the header section, which includes
+     * column headers and any applied header styling or events.
+     *
+     * @returns {Element} - Returns the HTML element for header content.
      */
     getHeaderContent(): Element;
     /**
-     * Gets the header table element of the TreeGrid.
+     * Retrieves the header table element of the TreeGrid.
+     *
+     * This method is useful for direct access to the table structure
+     * where column headers are defined.
      *
-     * @returns {Element} - Return header table element
+     * @returns {Element} - Returns the HTML element for the header table.
      */
     getHeaderTable(): Element;
     /**
-     * Gets a row by index.
+     * Fetches a specific row element based on its index in the TreeGrid.
      *
-     * @param  {number} index - Specifies the row index.
-     * @returns {Element} - Returns row element
+     * This provides a way to directly access and manipulate a row using its index.
+     *
+     * @param {number} index - The index of the desired row.
+     * @returns {Element} - Returns the HTML element of the specified row.
      */
     getRowByIndex(index: number): Element;
     /**
-     * Get a row information based on cell
+     * Provides detailed information about a row based on a specified target element.
+     *
+     * Integral for retrieving metadata such as row index or data object
+     * when working with events or complex tree structures.
      *
-     * @param {Element | EventTarget} target - Target row element
-     * @returns {RowInfo} - Returns row information in a JSON object
+     * @param {Element | EventTarget} target - The target element or event triggering the request.
+     * @returns {RowInfo} - Returns an object containing row information.
      */
     getRowInfo(target: Element | EventTarget): RowInfo;
     /**
-     * Gets UID by column name.
+     * Finds the unique identifier (UID) for a column based on its field name.
+     *
+     * UIDs are essential for precise identification and manipulation within complex grids.
      *
-     * @param  {string} field - Specifies the column name.
-     * @returns {string} - Returns unique id based on column field name given
+     * @param {string} field - The field name of the column.
+     * @returns {string} - Returns the unique identifier for the specified column.
      */
     getUidByColumnField(field: string): string;
     /**
-     * Gets the visible columns from the TreeGrid.
+     * Retrieves all the columns that are currently set to be visible within the TreeGrid.
      *
-     * @returns {Column[]} - Returns visible columns collection
+     * Helps in understanding the user's current view and can be used to dynamically
+     * adjust the visible columns.
+     *
+     * @returns {Column[]} - Returns an array of visible column objects.
      */
     getVisibleColumns(): Column[];
     /**
-     * By default, TreeGrid shows the spinner for all its actions. You can use this method to show spinner at your needed time.
+     * Displays a loading spinner overlay across the TreeGrid for any data action or long-running process.
+     *
+     * This can be manually invoked to indicate processing, enhancing user experience by providing feedback.
      *
      * @returns {void}
      */
     showSpinner(): void;
     /**
-     * Manually shown spinner needs to hide by `hideSpinnner`.
+     * Hides a manually shown loading spinner overlay from the TreeGrid.
+     *
+     * Ensures that any long-running process indication is removed after completion
+     * to manage user interface aesthetics.
      *
      * @returns {void}
      */
     hideSpinner(): void;
     /**
-     * Refreshes the TreeGrid header and content.
+     * Refreshes the visual appearance and data of the TreeGrid, updating header and content.
+     *
+     * This is crucial for synchronizing the displayed data with the underlying data source,
+     * ensuring the view reflects current data.
      *
      * @returns {void}
      */
     refresh(): void;
     /**
-     * Get the records of checked rows.
+     * Retrieves the records associated with rows that have their checkboxes checked.
+     *
+     * Facilitates operations that require information about specifically selected or
+     * interacted rows within the grid.
      *
-     * @returns {Object[]} - Returns records that has been checked
+     * @returns {Object[]} - Returns an array of checked row data objects.
      * @isGenericType true
      */
     getCheckedRecords(): Object[];
     /**
-     * Get the visible records corresponding to rows visually displayed.
+     * Retrieves currently visible records according to the TreeGrid's visual state.
+     *
+     * It considers row expansion and collapse states to return only those records
+     * that a user can currently interact with.
      *
-     * @returns {Object[]} - Returns visible records based on collapse state of rows
+     * @returns {Object[]} - Returns visible records reflecting the TreeGrid's current view.
      * @isGenericType true
      */
     getVisibleRecords(): Object[];
     /**
-     * Get the indexes of checked rows.
+     * Retrieves the indices of rows that have their checkboxes checked.
      *
-     * @returns {number[]} - Returns checked row indexes
+     * This can assist in programatically assessing which rows have been selected
+     * by checkbox interaction for further processing.
+     *
+     * @returns {number[]} - Returns an array of indices corresponding to checked rows.
      */
     getCheckedRowIndexes(): number[];
     /**
-     * Checked the checkboxes using rowIndexes.
+     * Selects rows in the TreeGrid using row indices, checking their associated checkboxes.
+     *
+     * This method provides automation for selecting or highlighting specific rows,
+     * useful in scenarios needing pre-selection or default selections.
      *
-     * @param {number[]} indexes - row indexes
+     * @param {number[]} indexes - An array of row indices to be marked as selected.
      * @returns {void}
      */
     selectCheckboxes(indexes: number[]): void;
     /**
-     * Refreshes the TreeGrid column changes.
+     * Updates and refreshes the TreeGrid's column definitions and layout.
+     *
+     * Ensures that the latest column settings are displayed, either refreshing the UI
+     * or adjusting internal configurations to match current data or configuration updates.
      *
-     * @param {boolean} refreshUI - Defined whether to refresh the DOM
+     * @param {boolean} refreshUI - A flag indicating whether the DOM should be updated.
      * @returns {void}
      */
     refreshColumns(refreshUI?: boolean): void;
     private getTreeColumn;
     /**
-     * Refreshes the TreeGrid header.
+     * Refreshes the header section of the TreeGrid to reflect any structural or data changes.
+     *
+     * This method is useful when there are dynamic updates or layout adjustments
+     * needed in the header portion to ensure it aligns with current grid data or settings.
      *
      * @returns {void}
      */
@@ -1790,12 +1918,15 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     private expandCollapseRequest;
     /**
-     * Expands child rows
+     * Expands the specified parent row within the TreeGrid to reveal its nested data.
+     *
+     * This method is useful for programmatically expanding rows to display their
+     * hierarchical children, providing detailed views for nested data structures.
      *
-     * @param {HTMLTableRowElement} row - Expands the given row
-     * @param {Object} record - Expands the given record
-     * @param {Object} key - Primary key value
-     * @param {number} level - Specifies the hierarchical level of the record
+     * @param {HTMLTableRowElement} row - The table row element that should be expanded.
+     * @param {Object} record - Optional. Represents the data record associated with the row to be expanded.
+     * @param {Object} key - Optional. The primary key value that uniquely identifies the record.
+     * @param {number} level - Optional. Indicates the hierarchical level of the record within the TreeGrid.
      * @returns {void}
      */
     expandRow(row: HTMLTableRowElement, record?: Object, key?: Object, level?: number): void;
@@ -1803,56 +1934,83 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
     private expandCollapseAllChildren;
     private getCollapseExpandRecords;
     /**
-     * Collapses child rows
+     * Collapses the specified parent row in the TreeGrid.
+     *
+     * This method collapses the row associated with the provided HTMLTableRowElement,
+     * hiding any of its displayed child rows. It is typically used to manage the
+     * visibility of hierarchical data within a tree structure.
      *
-     * @param {HTMLTableRowElement} row - Collapse the given row
-     * @param {Object} record - Collapse the given record
-     * @param {Object} key - Primary key value
+     * @param {HTMLTableRowElement} row - The HTMLTableRowElement representing the parent row
+     *                                    whose child rows are to be collapsed.
+     * @param {Object} record - (Optional) The data record associated with the row being collapsed.
+     *                            This can be used to access or manipulate the underlying data
+     *                            when collapsing the row.
+     * @param {Object} key - (Optional) The primary key value of the record. It can be used to identify
+     *                         the target record uniquely when collapsing the row, especially in cases
+     *                         where the row or record data needs to be referenced or logged.
      * @returns {void}
      */
     collapseRow(row: HTMLTableRowElement, record?: Object, key?: Object): void;
     private collapseRows;
     private updateExpandStateMapping;
     /**
-     * Expands the records at specific hierarchical level
+     * Expands all the records at the specified hierarchical level within the TreeGrid.
      *
-     * @param {number} level - Expands the parent rows at given level
+     * This method is useful for visually expanding data at a certain depth, making
+     * all parent rows visible at the given level and their child rows accessible.
+     *
+     * @param {number} level - The hierarchical level at which parent rows should be expanded.
      * @returns {void}
      */
     expandAtLevel(level: number): void;
     /**
-     * Expands the records by given primary key value
+     * Expands a specific record identified by the provided primary key value.
+     *
+     * This method is useful for expanding particular node in the TreeGrid when
+     * the parent rows need to be targeted individually by their unique key.
      *
-     * @param {Object} key - Expands the parent rows with given primary key value
+     * @param {Object} key - The primary key value of the record to be expanded.
      * @returns {void}
      */
     expandByKey(key: Object): void;
     private expandAction;
     private getRecordDetails;
     /**
-     * Collapses the records at specific hierarchical level
+     * Collapses all the records at the specified hierarchical level within the TreeGrid.
+     *
+     * This function helps in hiding child rows for all parent nodes at a given level,
+     * effectively reducing the visible depth of the hierarchical structure.
      *
-     * @param {number} level - Define the parent row level which needs to be collapsed
+     * @param {number} level - The hierarchical level at which parent rows should be collapsed.
      * @returns {void}
      */
     collapseAtLevel(level: number): void;
     /**
-     * Collapses the records by given primary key value
+     * Collapses a specific record identified by the provided primary key value.
      *
-     * @param {Object} key - Collapses the parent rows with given primary key value
+     * This method is useful for collapsing particular node in the TreeGrid when
+     * the parent rows need to be targeted individually by their unique key.
+     *
+     * @param {Object} key - The primary key value of the record to be collapsed.
      * @returns {void}
      */
     collapseByKey(key: Object): void;
     private expandCollapseActionByKey;
     private collapseAction;
     /**
-     * Expands All the rows
+     * Expands all rows in the TreeGrid, making the full hierarchy visible.
+     *
+     * This method should be used with caution on large datasets, as it makes
+     * all nodes and their child rows visible, which might affect performance.
      *
      * @returns {void}
      */
     expandAll(): void;
     /**
-     * Collapses All the rows
+     * Collapses all rows in the TreeGrid, hiding all child rows and leaving only parent nodes visible.
+     *
+     * This method can be used to quickly minimize the view to only top-level data,
+     * which is helpful for summarizing or performing broad overviews of the dataset.
      *
      * @returns {void}
      */
@@ -1874,15 +2032,6 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      * @hidden
      */
     private sanitize;
-    /**
-     * Updates the rows and cells
-     *
-     * @param {Object[]} records - Updates the given records
-     * @param {HTMLTableRowElement[]} rows - Updates the given rows
-     * @param {number} index -  Updates the given cell index
-     * @returns {void}
-     */
-    private updateRowAndCellElements;
     /**
      * @hidden
      * @returns {void}
@@ -1895,23 +2044,26 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     private removeListener;
     /**
-     * Filters TreeGrid row by column name with the given options.
+     * Filters the TreeGrid rows based on a specified column and filter criteria.
+     *
+     * This method allows for dynamic filtering against column data using various
+     * operators and values, supporting case-sensitive filtering and accent sensitivity.
      *
-     * @param  {string} fieldName - Defines the field name of the column.
-     * @param  {string} filterOperator - Defines the operator to filter records.
-     * @param  {string | number | Date | boolean} filterValue - Defines the value used to filter records.
-     * @param  {string} predicate - Defines the relationship between one filter query and another by using AND or OR predicate.
-     * @param  {boolean} matchCase - If match case is set to true, the TreeGrid filters the records with exact match. if false, it filters
-     * case insensitive records (uppercase and lowercase letters are treated the same).
-     * @param  {boolean} ignoreAccent - If ignoreAccent is set to true,
-     * then filter ignores diacritic characters or accents while filtering.
-     * @param  {string} actualFilterValue - Defines the actual filter value for filter column.
-     * @param  {string} actualOperator - Defines the actual filter operator for filter column.
+     * @param {string} fieldName - The name of the column to apply the filter on.
+     * @param {string} filterOperator - The operator used to perform the filter (e.g., 'equals', 'startswith').
+     * @param {string | number | Date | boolean } filterValue - The value to filter against.
+     * @param {string} predicate - The logical operator ('AND'/'OR') to combine this filter with others.
+     * @param {boolean} matchCase - If true, the filter performs a case-sensitive match.
+     * @param {boolean} ignoreAccent - If true, the filter ignores diacritical marks.
+     * @param {string} actualFilterValue - The original value used for filtering, useful for distinguishing displayed and actual values.
+     * @param {string} actualOperator - The actual operator that is applied when different from the displayed operator.
      * @returns {void}
      */
     filterByColumn(fieldName: string, filterOperator: string, filterValue: string | number | Date | boolean | number[] | string[] | Date[] | boolean[], predicate?: string, matchCase?: boolean, ignoreAccent?: boolean, actualFilterValue?: string, actualOperator?: string): void;
     /**
-     * Clears all the filtered rows of the TreeGrid.
+     * Clears all filters applied to the TreeGrid, restoring the view to show all records.
+     *
+     * This method is useful for resetting the grid to its unfiltered state.
      *
      * @returns {void}
      */
@@ -1926,54 +2078,68 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
      */
     removeFilteredColsByField(field: string, isClearFilterBar?: boolean): void;
     /**
-     * Selects a row by given index.
+     * Selects a row in the TreeGrid by its index.
      *
-     * @param  {number} index - Defines the row index.
-     * @param  {boolean} isToggle - If set to true, then it toggles the selection.
+     * Use this method to highlight a specific row; useful for programmatically navigating data.
+     *
+     * @param {number} index - Index of the row to select.
+     * @param {boolean} isToggle - If true, toggles the selection state of the row.
      * @returns {void}
      */
     selectRow(index: number, isToggle?: boolean): void;
     /**
-     * Selects a collection of rows by indexes.
+     * Selects multiple rows in the TreeGrid given an array of row indexes.
+     *
+     * Useful for batch operations where multiple row selections are necessary.
      *
-     * @param  {number[]} rowIndexes - Specifies the row indexes.
+     * @param {number[]} rowIndexes - Array of row index numbers to select.
      * @returns {void}
      */
     selectRows(rowIndexes: number[]): void;
     /**
-     * Deselects the current selected rows and cells.
+     * Deselects all selected rows and cells within the TreeGrid.
+     *
+     * Resets the selection state of the grid, which is useful after bulk operations.
      *
      * @returns {void}
      */
     clearSelection(): void;
     /**
-     * Copy the selected rows or cells data into clipboard.
+     * Copies the data of selected rows or cells to the clipboard.
      *
-     * @param {boolean} withHeader - Specifies whether the column header text needs to be copied along with rows or cells.
+     * This method supports including headers for better context when pasting elsewhere.
+     *
+     * @param {boolean} withHeader - (Optional) If true, includes column headers in the copied data.
      * @returns {void}
      */
     copy(withHeader?: boolean): void;
     /**
-     * Paste data from clipboard to selected cells.
+     * Pastes data into the selected cells from the clipboard.
+     *
+     * Automatically places the pasted data starting from the specified indices.
      *
-     * @param {boolean} data - Specifies the date for paste.
-     * @param {boolean} rowIndex - Specifies the row index.
-     * @param {boolean} colIndex - Specifies the column index.
+     * @param {string} data - The clipboard data to paste.
+     * @param {number} rowIndex - The starting row index for pasting.
+     * @param {number} colIndex - The starting column index for pasting.
      * @returns {void}
      */
     paste(data: string, rowIndex: number, colIndex: number): void;
     /**
-     * Selects a cell by the given index.
+     * Selects a cell by its index position in the TreeGrid.
+     *
+     * Useful for navigating or highlighting specific data cells within the grid.
      *
-     * @param  {IIndex} cellIndex - Defines the row and column indexes.
-     * @param  {boolean} isToggle - If set to true, then it toggles the selection.
+     * @param {IIndex} cellIndex - An object specifying the row and column indexes.
+     * @param {boolean} isToggle - (Optional) If true, toggles the selection state of the cell.
      * @returns {void}
      */
     selectCell(cellIndex: IIndex, isToggle?: boolean): void;
     /**
-     * Gets the collection of selected rows.
+     * Retrieves the currently selected rows.
      *
-     * @returns {Element[]} - Returns selected row elements collection
+     * Useful for obtaining the selected data elements for downstream processing.
+     *
+     * @returns {Element[]} - An array of Element objects representing the selected rows.
      */
     getSelectedRows(): Element[];
     /**
@@ -2126,53 +2292,74 @@ export declare class TreeGrid extends Component<HTMLElement> implements INotifyP
     getFrozenColumns(): number;
     private getFrozenCount;
     /**
-     * Gets the collection of selected row indexes.
+     * Retrieves the indexes of the currently selected rows in the TreeGrid.
+     *
+     * This method is useful when you need to perform actions based on the selected rows,
+     * such as retrieving data or changing the selection.
      *
-     * @returns {number[]} - Returns selected rows index collection
+     * @returns {number[]} - An array of numbers representing the indexes of selected rows.
      */
     getSelectedRowIndexes(): number[];
     /**
-     * Gets the collection of selected row and cell indexes.
+     * Retrieves the indexes of the selected cells within the selected rows.
+     *
+     * This can be useful for handling cell-specific operations, such as
+     * applying styles or editing values programmatically.
      *
-     * @returns {ISelectedCell[]} - Returns selected cell's index details
+     * @returns {ISelectedCell[]} - An array of objects representing the selected cells' indexes.
      */
     getSelectedRowCellIndexes(): ISelectedCell[];
     /**
-     * Gets the collection of selected records.
+     * Retrieves the data records corresponding to the currently selected rows.
+     *
+     * This method provides the full record data for the selected rows,
+     * which is useful for data manipulation or extraction operations.
      *
      * @isGenericType true
-     * @returns {Object[]} - Returns selected records collection
+     * @returns {Object[]} - An array of data objects representing the selected records.
      */
     getSelectedRecords(): Object[];
     /**
-     * Gets the data module.
+     * Obtains the data handling modules used by the TreeGrid.
+     *
+     * This includes both the base data module for standard grid operations and the tree module
+     * for handling hierarchical data, giving complete access to data management capabilities.
      *
-     * @returns {{baseModule: Data, treeModule: DataManipulation}}: Returns grid and treegrid data module
+     * @returns {{baseModule: Data, treeModule: DataManipulation}} - An object containing both grid and tree data modules.
      */
     getDataModule(): {
         baseModule: Data;
         treeModule: DataManipulation;
     };
     /**
-     * Reorder the rows based on given indexes and position
+     * Reorders rows in the TreeGrid based on specified source indexes and a target position.
+     *
+     * This functionality allows for dynamic rearrangement of rows, such as moving selected
+     * rows to a new position as siblings or children.
      *
-     * @param {number[]} fromIndexes - Source indexes of rows
-     * @param {number} toIndex - Destination index of row
-     * @param {string} position - Defines drop position as above or below or child
+     * @param {number[]} fromIndexes - An array indicating the source indexes of the rows to be moved.
+     * @param {number} toIndex - The target index where the rows should be moved.
+     * @param {string} position - The position relative to the target index ('above', 'below', 'child').
      * @returns {void}
      */
     reorderRows(fromIndexes: number[], toIndex: number, position: string): void;
     /**
-     * Indents the record to one level of hierarchy. Moves the selected row as the last child of its previous row.
+     * Indents a specified record, promoting it to one level deeper in the hierarchy.
      *
-     * @param {Object} record – specifies the record to do indented
+     * This function moves the selected row to become the last child of its preceding row,
+     * altering the visual and hierarchical data structure.
+     *
+     * @param {Object} record - (Optional) The record to be indented. If omitted, the currently selected row is used.
      * @returns {void}
      */
     indent(record?: Object): void;
     /**
-     * Outdent the record to one level of hierarchy. Moves the selected row as sibling to its parent row.
+     * Outdents a specified record, moving it one level up in the hierarchy.
+     *
+     * This method repositions the selected row to be a sibling of its parent, impacting
+     * its display and the hierarchical relationships within the TreeGrid.
      *
-     * @param {Object} record – specifies the record to do outdented
+     * @param {Object} record - (Optional) The record to be outdented. If omitted, the currently selected row is used.
      * @returns {void}
      */
     outdent(record?: Object): void;