@highcharts/grid-pro 2.1.1 → 2.3.0

package/es-modules/Data/DataTable.d.ts

@@ -1,4 +1,4 @@
-import type DataEvent from './DataEvent';
+import type { DataEvent, DataEventCallback, DataEventDetail, DataEventEmitter } from './DataEvent';
 import type DataModifier from './Modifiers/DataModifier';
 import type DataTableOptions from './DataTableOptions';
 import type { DataTableValue } from './DataTableOptions';
@@ -15,7 +15,7 @@ import DataTableCore from './DataTableCore.js';
  * @param {Highcharts.DataTableOptions} [options]
  * Options to initialize the new DataTable instance.
  */
-declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataTable.Event> {
+declare class DataTable extends DataTableCore implements DataEventEmitter<Event> {
     constructor(options?: DataTableOptions);
     private modifier?;
     private localRowIndexes?;
@@ -40,7 +40,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #cloneTable
      * @emits #afterCloneTable
      */
-    clone(skipColumns?: boolean, eventDetail?: DataEvent.Detail): DataTable;
+    clone(skipColumns?: boolean, eventDetail?: DataEventDetail): DataTable;
     /**
      * Deletes columns from the table.
      *
@@ -59,7 +59,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #deleteColumns
      * @emits #afterDeleteColumns
      */
-    deleteColumns(columnIds?: Array<string>, eventDetail?: DataEvent.Detail): (DataTable.ColumnCollection | undefined);
+    deleteColumns(columnIds?: Array<string>, eventDetail?: DataEventDetail): (ColumnCollection | undefined);
     /**
      * Deletes the row index references. This is useful when the original table
      * is deleted, and the references are no longer needed. This table is
@@ -72,11 +72,11 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      *
      * @function Highcharts.DataTable#deleteRows
      *
-     * @param {number} [rowIndex]
-     * Index to start delete of rows. If not specified, all rows will be
-     * deleted.
+     * @param {number | number[]} [rowIndex]
+     * Index of the row where deletion should start, or an array of indices for
+     * deleting multiple rows. If not specified, all rows will be deleted.
      *
-     * @param {number} [rowCount=1]
+     * @param {number} [rowCount]
      * Number of rows to delete.
      *
      * @param {Highcharts.DataTableEventDetail} [eventDetail]
@@ -88,16 +88,16 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #deleteRows
      * @emits #afterDeleteRows
      */
-    deleteRows(rowIndex?: number, rowCount?: number, eventDetail?: DataEvent.Detail): Array<DataTable.Row>;
+    deleteRows(rowIndex?: number | number[], rowCount?: number, eventDetail?: DataEventDetail): Array<Row>;
     /**
      * Emits an event on this table to all registered callbacks of the given
      * event.
      * @private
      *
-     * @param {DataTable.Event} e
+     * @param {Event} e
      * Event object with event information.
      */
-    emit(e: DataTable.Event): void;
+    emit(e: Event): void;
     /**
      * Fetches a single cell value.
      *
@@ -112,7 +112,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableCellType|undefined}
      * Returns the cell value or `undefined`.
      */
-    getCell(columnId: string, rowIndex: number): (DataTable.CellType | undefined);
+    getCell(columnId: string, rowIndex: number): (CellType | undefined);
     /**
      * Fetches the given column by the canonical column name.
      * This function is a simplified wrap of {@link getColumns}.
@@ -128,7 +128,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableColumn|undefined}
      * A copy of the column, or `undefined` if not found.
      */
-    getColumn(columnId: string, asReference?: boolean): (DataTable.Column | undefined);
+    getColumn(columnId: string, asReference?: boolean): (Column | undefined);
     /**
      * Fetches all column IDs.
      *
@@ -138,9 +138,9 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * Returns all column IDs.
      */
     getColumnIds(): Array<string>;
-    getColumns(columnIds?: Array<string>, asReference?: boolean): DataTable.ColumnCollection;
-    getColumns(columnIds: (Array<string> | undefined), asReference: true): Record<string, DataTable.Column>;
-    getColumns(columnIds: (Array<string> | undefined), asReference: false, asBasicColumns: true): Record<string, DataTable.BasicColumn>;
+    getColumns(columnIds?: Array<string>, asReference?: boolean): ColumnCollection;
+    getColumns(columnIds: (Array<string> | undefined), asReference: true): Record<string, Column>;
+    getColumns(columnIds: (Array<string> | undefined), asReference: false, asBasicColumns: true): Record<string, BasicColumn>;
     /**
      * Takes the original row index and returns the local row index in the
      * modified table for which this function is called.
@@ -187,7 +187,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableRow}
      * Returns the row values, or `undefined` if not found.
      */
-    getRow(rowIndex: number, columnIds?: Array<string>): (DataTable.Row | undefined);
+    getRow(rowIndex: number, columnIds?: Array<string>): (Row | undefined);
     /**
      * Returns the number of rows in this table.
      *
@@ -214,7 +214,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {number|undefined}
      * Index of the first row matching the cell value.
      */
-    getRowIndexBy(columnId: string, cellValue: DataTable.CellType, rowIndexOffset?: number): (number | undefined);
+    getRowIndexBy(columnId: string, cellValue: CellType, rowIndexOffset?: number): (number | undefined);
     /**
      * Retrieves the row at a given index. This function is a simplified wrap of
      * {@link getRowObjects}.
@@ -230,7 +230,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableRowObject}
      * Returns the row values, or `undefined` if not found.
      */
-    getRowObject(rowIndex: number, columnIds?: Array<string>): (DataTable.RowObject | undefined);
+    getRowObject(rowIndex: number, columnIds?: Array<string>): (RowObject | undefined);
     /**
      * Fetches all or a number of rows as an object.
      *
@@ -248,7 +248,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableRowObject}
      * Returns retrieved rows.
      */
-    getRowObjects(rowIndex?: number, rowCount?: number, columnIds?: Array<string>): (Array<DataTable.RowObject>);
+    getRowObjects(rowIndex?: number, rowCount?: number, columnIds?: Array<string>): (Array<RowObject>);
     /**
      * Fetches all or a number of rows as an array.
      *
@@ -266,7 +266,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableRow}
      * Returns retrieved rows.
      */
-    getRows(rowIndex?: number, rowCount?: number, columnIds?: Array<string>): (Array<DataTable.Row>);
+    getRows(rowIndex?: number, rowCount?: number, columnIds?: Array<string>): (Array<Row>);
     /**
      * Returns the unique version tag of the current state of the table.
      *
@@ -302,7 +302,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {boolean}
      * True, if a row has been found, otherwise false.
      */
-    hasRowWith(columnId: string, cellValue: DataTable.CellType): boolean;
+    hasRowWith(columnId: string, cellValue: CellType): boolean;
     /**
      * Registers a callback function to be executed when a specific event is
      * emitted. To stop listening to the event, call the function returned by
@@ -319,7 +319,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Function}
      * Function to unregister callback from the event.
      */
-    on<T extends DataTable.Event['type']>(type: T, callback: DataEvent.Callback<this, Extract<DataTable.Event, {
+    on<T extends Event['type']>(type: T, callback: DataEventCallback<this, Extract<Event, {
         type: T;
     }>>): Function;
     /**
@@ -361,7 +361,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #setCell
      * @emits #afterSetCell
      */
-    setCell(columnId: string, rowIndex: number, cellValue: DataTable.CellType, eventDetail?: DataEvent.Detail): void;
+    setCell(columnId: string, rowIndex: number, cellValue: CellType, eventDetail?: DataEventDetail): void;
     /**
      * Replaces or updates multiple columns in the table with new data. If a
      * column does not exist, it will be created and added to the table.
@@ -386,7 +386,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #setColumns
      * @emits #afterSetColumns
      */
-    setColumns(columns: DataTable.ColumnCollection, rowIndex?: number, eventDetail?: DataEvent.Detail, typeAsOriginal?: boolean): void;
+    setColumns(columns: ColumnCollection, rowIndex?: number, eventDetail?: DataEventDetail, typeAsOriginal?: boolean): void;
     /**
      * Assigns a new data modifier to the table.
      *
@@ -406,7 +406,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #setModifier
      * @emits #afterSetModifier
      */
-    setModifier(modifier?: DataModifier, eventDetail?: DataEvent.Detail): Promise<DataTable>;
+    setModifier(modifier?: DataModifier, eventDetail?: DataEventDetail): Promise<DataTable>;
     /**
      * Sets the original row indexes for the table. It is used to keep the
      * reference to the original rows when modifying the table.
@@ -442,7 +442,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #setRows
      * @emits #afterSetRows
      */
-    setRow(row: (DataTable.Row | DataTable.RowObject), rowIndex?: number, insert?: boolean, eventDetail?: DataEvent.Detail): void;
+    setRow(row: (Row | RowObject), rowIndex?: number, insert?: boolean, eventDetail?: DataEventDetail): void;
     /**
      * Sets cell values for multiple rows. Will insert new rows, if no index was
      * was provided, or if the index is higher than the total number of table
@@ -465,99 +465,97 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #setRows
      * @emits #afterSetRows
      */
-    setRows(rows: Array<(DataTable.Row | DataTable.RowObject)>, rowIndex?: number, insert?: boolean, eventDetail?: DataEvent.Detail): void;
+    setRows(rows: Array<(Row | RowObject)>, rowIndex?: number, insert?: boolean, eventDetail?: DataEventDetail): void;
 }
 /**
  * Additionally it provides necessary types for events.
  */
-declare namespace DataTable {
-    /**
-     * Possible value types for a table cell.
-     */
-    type CellType = (boolean | number | null | string | undefined);
-    /**
-     * Conventional array of table cells typed as `CellType`.
-     */
-    interface BasicColumn extends Array<DataTable.CellType> {
-        [index: number]: CellType;
-    }
-    /**
-     * Array of table cells in vertical expansion.
-     */
-    type Column = BasicColumn | TypedArray;
-    /**
-     * Collection of columns, where the key is the column name and
-     * the value is an array of column values.
-     */
-    interface ColumnCollection {
-        [columnId: string]: Column;
-    }
-    /**
-     * Event object for cell-related events.
-     */
-    interface CellEvent extends DataEvent {
-        readonly type: ('setCell' | 'afterSetCell');
-        readonly cellValue: DataTable.CellType;
-        readonly columnId: string;
-        readonly rowIndex: number;
-    }
-    /**
-     * Event object for clone-related events.
-     */
-    interface CloneEvent extends DataEvent {
-        readonly type: ('cloneTable' | 'afterCloneTable');
-        readonly tableClone?: DataTable;
-    }
-    /**
-     * Event object for column-related events.
-     */
-    interface ColumnEvent extends DataEvent {
-        readonly type: ('deleteColumns' | 'afterDeleteColumns' | 'setColumns' | 'afterSetColumns');
-        readonly columns?: ColumnCollection;
-        readonly columnIds: Array<string>;
-        readonly rowIndex?: number;
-    }
-    /**
-     * All information objects of DataTable events.
-     */
-    type Event = (CellEvent | CloneEvent | ColumnEvent | SetModifierEvent | RowEvent);
-    /**
-     * Event object for modifier-related events.
-     */
-    interface ModifierEvent extends DataEvent {
-        readonly type: ('setModifier' | 'afterSetModifier');
-        readonly modifier: (DataModifier | undefined);
-    }
-    /**
-     * Array of table cells in horizontal expansion. Index of the array is the
-     * index of the column names.
-     */
-    interface Row extends Array<CellType> {
-        [index: number]: CellType;
-    }
-    /**
-     * Event object for row-related events.
-     */
-    interface RowEvent extends DataEvent {
-        readonly type: ('deleteRows' | 'afterDeleteRows' | 'setRows' | 'afterSetRows');
-        readonly rowCount: number;
-        readonly rowIndex: number;
-        readonly rows?: Array<Row | RowObject>;
-    }
-    /**
-     * Object of row values, where the keys are the column names.
-     */
-    interface RowObject extends Record<string, CellType> {
-        [column: string]: CellType;
-    }
-    /**
-    * Event object for the setModifier events.
-    */
-    interface SetModifierEvent extends DataEvent {
-        readonly type: ('setModifier' | 'afterSetModifier' | 'setModifierError');
-        readonly error?: unknown;
-        readonly modifier?: DataModifier;
-        readonly modified?: DataTable;
-    }
+/**
+ * Possible value types for a table cell.
+ */
+export type CellType = (boolean | number | null | string | undefined);
+/**
+ * Conventional array of table cells typed as `CellType`.
+ */
+export interface BasicColumn extends Array<CellType> {
+    [index: number]: CellType;
+}
+/**
+ * Array of table cells in vertical expansion.
+ */
+export type Column = BasicColumn | TypedArray;
+/**
+ * Collection of columns, where the key is the column name and
+ * the value is an array of column values.
+ */
+export interface ColumnCollection {
+    [columnId: string]: Column;
+}
+/**
+ * Event object for cell-related events.
+ */
+export interface CellEvent extends DataEvent {
+    readonly type: ('setCell' | 'afterSetCell');
+    readonly cellValue: CellType;
+    readonly columnId: string;
+    readonly rowIndex: number;
+}
+/**
+ * Event object for clone-related events.
+ */
+export interface CloneEvent extends DataEvent {
+    readonly type: ('cloneTable' | 'afterCloneTable');
+    readonly tableClone?: DataTable;
+}
+/**
+ * Event object for column-related events.
+ */
+export interface ColumnEvent extends DataEvent {
+    readonly type: ('deleteColumns' | 'afterDeleteColumns' | 'setColumns' | 'afterSetColumns');
+    readonly columns?: ColumnCollection;
+    readonly columnIds: Array<string>;
+    readonly rowIndex?: number;
+}
+/**
+ * All information objects of DataTable events.
+ */
+export type Event = (CellEvent | CloneEvent | ColumnEvent | SetModifierEvent | RowEvent);
+/**
+ * Event object for modifier-related events.
+ */
+export interface ModifierEvent extends DataEvent {
+    readonly type: ('setModifier' | 'afterSetModifier');
+    readonly modifier: (DataModifier | undefined);
+}
+/**
+ * Array of table cells in horizontal expansion. Index of the array is the
+ * index of the column names.
+ */
+export interface Row extends Array<CellType> {
+    [index: number]: CellType;
+}
+/**
+ * Event object for row-related events.
+ */
+export interface RowEvent extends DataEvent {
+    readonly type: ('deleteRows' | 'afterDeleteRows' | 'setRows' | 'afterSetRows');
+    readonly rowCount: number;
+    readonly rowIndex: number | number[];
+    readonly rows?: Array<Row | RowObject>;
+}
+/**
+ * Object of row values, where the keys are the column names.
+ */
+export interface RowObject extends Record<string, CellType> {
+    [column: string]: CellType;
+}
+/**
+* Event object for the setModifier events.
+*/
+export interface SetModifierEvent extends DataEvent {
+    readonly type: ('setModifier' | 'afterSetModifier' | 'setModifierError');
+    readonly error?: unknown;
+    readonly modifier?: DataModifier;
+    readonly modified?: DataTable;
 }
 export default DataTable;

package/es-modules/Data/DataTable.js

@@ -1,10 +1,10 @@
 /* *
  *
- *  (c) 2009-2025 Highsoft AS
+ *  (c) 2009-2026 Highsoft AS
  *
- *  License: www.highcharts.com/license
+ *  A commercial license may be required depending on use.
+ *  See www.highcharts.com/license
  *
- *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
  *
  *  Authors:
  *  - Sophie Bremer
@@ -17,8 +17,8 @@
 import DataTableCore from './DataTableCore.js';
 import ColumnUtils from './ColumnUtils.js';
 const { splice, setLength } = ColumnUtils;
-import U from '../Core/Utilities.js';
-const { addEvent, defined, extend, fireEvent, isNumber, uniqueKey } = U;
+import { addEvent, defined, extend, fireEvent, isNumber } from '../Shared/Utilities.js';
+import { uniqueKey } from '../Core/Utilities.js';
 /* *
  *
  *  Class
@@ -159,11 +159,11 @@ class DataTable extends DataTableCore {
      *
      * @function Highcharts.DataTable#deleteRows
      *
-     * @param {number} [rowIndex]
-     * Index to start delete of rows. If not specified, all rows will be
-     * deleted.
+     * @param {number | number[]} [rowIndex]
+     * Index of the row where deletion should start, or an array of indices for
+     * deleting multiple rows. If not specified, all rows will be deleted.
      *
-     * @param {number} [rowCount=1]
+     * @param {number} [rowCount]
      * Number of rows to delete.
      *
      * @param {Highcharts.DataTableEventDetail} [eventDetail]
@@ -176,43 +176,77 @@ class DataTable extends DataTableCore {
      * @emits #afterDeleteRows
      */
     deleteRows(rowIndex, rowCount = 1, eventDetail) {
-        const table = this, deletedRows = [], modifiedRows = [], modifier = table.modifier;
-        table.emit({
+        const { columns, modifier } = this;
+        const deletedRows = [];
+        let indices;
+        let actualRowCount;
+        if (!defined(rowIndex)) {
+            // No index provided - delete all rows.
+            indices = [0];
+            actualRowCount = this.rowCount;
+        }
+        else if (Array.isArray(rowIndex)) {
+            // Array of indices provided - delete the specified rows.
+            indices = rowIndex
+                // Remove negative indices, and indices beyond the row count,
+                // and remove duplicates.
+                .filter((index, i, arr) => (index >= 0 &&
+                index < this.rowCount &&
+                arr.indexOf(index) === i))
+                // Sort indices in descending order.
+                .sort((a, b) => b - a);
+            actualRowCount = indices.length;
+        }
+        else {
+            // Single index provided - delete the specified range of rows.
+            indices = [rowIndex];
+            actualRowCount = rowCount;
+        }
+        this.emit({
             type: 'deleteRows',
             detail: eventDetail,
-            rowCount,
-            rowIndex: (rowIndex || 0)
+            rowCount: actualRowCount,
+            rowIndex: rowIndex ?? 0
         });
-        if (typeof rowIndex === 'undefined') {
-            rowIndex = 0;
-            rowCount = table.rowCount;
-        }
-        if (rowCount > 0 && rowIndex < table.rowCount) {
-            const columns = table.columns, columnIds = Object.keys(columns);
-            for (let i = 0, iEnd = columnIds.length, column, deletedCells, columnId; i < iEnd; ++i) {
-                columnId = columnIds[i];
-                column = columns[columnId];
-                const result = splice(column, rowIndex, rowCount);
-                deletedCells = result.removed;
-                columns[columnId] = column = result.array;
+        if (actualRowCount > 0) {
+            const columnIds = Object.keys(columns);
+            for (let i = 0; i < columnIds.length; ++i) {
+                const columnId = columnIds[i];
+                const column = columns[columnId];
+                let deletedCells;
+                // Perform a range splice.
+                if (indices.length === 1 && actualRowCount > 1) {
+                    const result = splice(column, indices[0], actualRowCount);
+                    deletedCells = result.removed;
+                    columns[columnId] = result.array;
+                }
+                else {
+                    // Perform a index splice for each index in the array.
+                    deletedCells = [];
+                    for (const index of indices) {
+                        deletedCells.push(column[index]);
+                        splice(column, index, 1);
+                    }
+                    // Reverse the deleted cells to maintain the correct order.
+                    deletedCells.reverse();
+                }
                 if (!i) {
-                    table.rowCount = column.length;
+                    this.rowCount = column.length;
                 }
                 for (let j = 0, jEnd = deletedCells.length; j < jEnd; ++j) {
-                    deletedRows[j] = (deletedRows[j] || []);
+                    deletedRows[j] = deletedRows[j] || [];
                     deletedRows[j][i] = deletedCells[j];
                 }
-                modifiedRows.push(new Array(iEnd));
             }
         }
         if (modifier) {
-            modifier.modifyTable(table);
+            modifier.modifyTable(this);
         }
-        table.emit({
+        this.emit({
             type: 'afterDeleteRows',
             detail: eventDetail,
-            rowCount,
-            rowIndex: (rowIndex || 0),
+            rowCount: actualRowCount,
+            rowIndex: rowIndex ?? 0,
             rows: deletedRows
         });
         return deletedRows;
@@ -222,7 +256,7 @@ class DataTable extends DataTableCore {
      * event.
      * @private
      *
-     * @param {DataTable.Event} e
+     * @param {Event} e
      * Event object with event information.
      */
     emit(e) {

package/es-modules/Data/DataTableCore.d.ts

@@ -1,5 +1,5 @@
-import type DataEvent from './DataEvent.js';
-import type DataTable from './DataTable.js';
+import type { DataEventDetail } from './DataEvent.js';
+import type { Column as DataTableColumn, ColumnCollection as DataTableColumnCollection, Row as DataTableRow, RowObject as DataTableRowObject } from './DataTable.js';
 import type DataTableOptions from './DataTableOptions.js';
 /**
  * Class to manage columns and rows in a table structure. It provides methods
@@ -31,7 +31,7 @@ declare class DataTableCore {
      */
     constructor(options?: DataTableOptions);
     readonly autoId: boolean;
-    readonly columns: Record<string, DataTable.Column>;
+    readonly columns: Record<string, DataTableColumn>;
     readonly id: string;
     modified?: this;
     rowCount: number;
@@ -69,7 +69,7 @@ declare class DataTableCore {
      * @return {Highcharts.DataTableColumn|undefined}
      * A copy of the column, or `undefined` if not found.
      */
-    getColumn(columnId: string, asReference?: true): (DataTable.Column | undefined);
+    getColumn(columnId: string, asReference?: true): (DataTableColumn | undefined);
     /**
      * Retrieves all or the given columns. Simplified version of the full
      * `DataTable.getColumns` method, always returning by reference.
@@ -81,7 +81,7 @@ declare class DataTableCore {
      * Collection of columns. If a requested column was not found, it is
      * `undefined`.
      */
-    getColumns(columnIds?: Array<string>, asReference?: true): DataTable.ColumnCollection;
+    getColumns(columnIds?: Array<string>, asReference?: true): DataTableColumnCollection;
     /**
      * Retrieves the row at a given index.
      *
@@ -94,7 +94,7 @@ declare class DataTableCore {
      * @return {Record<string, number|string|undefined>|undefined}
      * Returns the row values, or `undefined` if not found.
      */
-    getRow(rowIndex: number, columnIds?: Array<string>): (DataTable.Row | undefined);
+    getRow(rowIndex: number, columnIds?: Array<string>): (DataTableRow | undefined);
     /**
      * Sets cell values for a column. Will insert a new column, if not found.
      *
@@ -113,7 +113,7 @@ declare class DataTableCore {
      * @emits #setColumns
      * @emits #afterSetColumns
      */
-    setColumn(columnId: string, column?: DataTable.Column, rowIndex?: number, eventDetail?: DataEvent.Detail): void;
+    setColumn(columnId: string, column?: DataTableColumn, rowIndex?: number, eventDetail?: DataEventDetail): void;
     /**
      * Sets cell values for multiple columns. Will insert new columns, if not
      * found. Simplified version of the full `DataTableCore.setColumns`, limited
@@ -132,7 +132,7 @@ declare class DataTableCore {
      * @emits #setColumns
      * @emits #afterSetColumns
      */
-    setColumns(columns: DataTable.ColumnCollection, rowIndex?: number, eventDetail?: DataEvent.Detail): void;
+    setColumns(columns: DataTableColumnCollection, rowIndex?: number, eventDetail?: DataEventDetail): void;
     /**
      * Sets cell values of a row. Will insert a new row if no index was
      * provided, or if the index is higher than the total number of table rows.
@@ -152,13 +152,13 @@ declare class DataTableCore {
      *
      * @emits #afterSetRows
      */
-    setRow(row: DataTable.RowObject, rowIndex?: number, insert?: boolean, eventDetail?: DataEvent.Detail): void;
+    setRow(row: DataTableRowObject, rowIndex?: number, insert?: boolean, eventDetail?: DataEventDetail): void;
     /**
-     * Returns the medified (clone) or the original data table if the modified
+     * Returns the modified (clone) or the original data table if the modified
      * one does not exist.
      *
      * @return {Highcharts.DataTableCore}
-     * The medified (clone) or the original data table.
+     * The modified (clone) or the original data table.
      */
     getModified(): this;
 }

package/es-modules/Data/DataTableCore.js

@@ -1,10 +1,10 @@
 /* *
  *
- *  (c) 2009-2025 Highsoft AS
+ *  (c) 2009-2026 Highsoft AS
  *
- *  License: www.highcharts.com/license
+ *  A commercial license may be required depending on use.
+ *  See www.highcharts.com/license
  *
- *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
  *
  *  Authors:
  *  - Sophie Bremer
@@ -15,8 +15,8 @@
 'use strict';
 import ColumnUtils from './ColumnUtils.js';
 const { setLength, splice } = ColumnUtils;
-import U from '../Core/Utilities.js';
-const { fireEvent, objectEach, uniqueKey } = U;
+import { fireEvent, objectEach } from '../Shared/Utilities.js';
+import { uniqueKey } from '../Core/Utilities.js';
 /* *
  *
  *  Class
@@ -274,11 +274,11 @@ class DataTableCore {
         }
     }
     /**
-     * Returns the medified (clone) or the original data table if the modified
+     * Returns the modified (clone) or the original data table if the modified
      * one does not exist.
      *
      * @return {Highcharts.DataTableCore}
-     * The medified (clone) or the original data table.
+     * The modified (clone) or the original data table.
      */
     getModified() {
         return this.modified || this;