swing-ui 0.1.25 → 1.0.1

package/types/classes/Table.d.ts

@@ -0,0 +1,652 @@
+/**
+ * A Table UI component displays data in a structured grid of rows and columns, making it easy to read, sort, and interact with.
+ * It supports features like column resizing, column reordering, sorting, filtering, multiple data types and more.
+ *
+ * Column object format is shown in example below. Rows are arrays of values (cells), each value for a corresponding column. Row cell data type must match the data type required for it's column type.
+ *
+ * // NOTE: When adding a new column, only "text" is required for the column, other properties are optional.
+ * @class
+ * @global
+ * @see TableColumn
+ * @see ScrollableComponent
+ */
+export class Table extends ScrollableComponent {
+    /**
+     * Enum for column sorting modes.
+     * Used in column definitions, e.g., `{ sorting: Table.Sorting.Natural }`.
+     *
+     * @readonly
+     * @enum {number}
+     * @property {number} None - No sorting applied.
+     * @property {number} Natural - (Default) Natural order sorting (alphanumeric).
+     * @property {number} CaseInsensitive - Case-insensitive string sorting.
+     * @property {number} Integer - Sort values as integers.
+     * @property {number} Float - Sort values as floating-point numbers.
+     * @see TableColumn
+     * @example
+     * table.addColumn({
+     *    text: "New Column",
+     *    sorting: Table.Sorting.CaseInsensitive
+     * });
+     */
+    static readonly Sorting: Readonly<{
+        None: 0;
+        Natural: 1;
+        CaseInsensitive: 2;
+        Integer: 3;
+        Float: 4;
+    }>;
+    /**
+     * Enum for sort order.
+     *
+     * @readonly
+     * @enum {number}
+     * @property {number} None - No sorting order applied.
+     * @property {number} Ascending - Values sorted from smallest to largest.
+     * @property {number} Descending - Values sorted from largest to smallest.
+     * @see Table#sortOrder
+     * @example <h2>Sorting rows by column 2 in ascending order:</h2>
+     * table.sortOrder(2, false, Table.SortOrder.Ascending);
+     */
+    static readonly SortOrder: Readonly<{
+        None: 0;
+        Ascending: 1;
+        Descending: 2;
+    }>;
+    /**
+     * Enum for table column auto-resizing modes. Used with {@link Table#autoResizeColumns}.
+     *
+     * @readonly
+     * @enum {number}
+     * @property {number} None - Do not auto-resize columns when one of the columns is resized.
+     * @property {number} NextColumn - Resize the next column when current column changes.
+     * @property {number} SubsequentColumns - Resize all columns to the right of the changed column.
+     * @property {number} LastColumn - Resize only the last column.
+     * @property {number} AllColumns - Resize all other columns equally to adapt to new size of a column that is being resized.
+     * @see TableColumn
+     * @see Table#autoResizeColumns
+     * @example
+     * Table.AutoResize.AllColumns
+     */
+    static readonly AutoResize: Readonly<{
+        None: 0;
+        NextColumn: 1;
+        SubsequentColumns: 2;
+        LastColumn: 3;
+        AllColumns: 4;
+    }>;
+    /**
+     * Enum for table grid line display modes.
+     *
+     * @readonly
+     * @enum {number}
+     * @property {number} None - No grid lines.
+     * @property {number} Horizontal - Show only horizontal lines.
+     * @property {number} Vertical - Show only vertical lines.
+     * @property {number} Both - Show both horizontal and vertical lines.
+     * @see Table#gridLines
+     * @example <h2>Setting to show only horizontal grid lines:</h2>
+     * table.gridLines(Table.GridLines.Horizontal);
+     */
+    static readonly GridLines: Readonly<{
+        None: 0;
+        Horizontal: 1;
+        Vertical: 2;
+        Both: 3;
+    }>;
+    /**
+     * Adds a column to a Table as a last column or at specified index. An empty data will be added at that column index for each row.
+     * For detail about column object format and all possible column properties refer to examples in the {@link Table} class description above.
+     * See usage example below.
+     *
+     * @param {string|number|TableColumn} column - A column Object with column properties, such as text, background color, etc.
+     * @param {number} [index] - Insert at this position. Index is the original position of columns that were before columns are reordered.
+     * @return {number} Returns an index of added column, or -1 if the column was not added for some reason.
+     * @see TableColumn
+     * @example <h2>Inserting a new column at an index 3:</h2>
+     * table.addColumn({text: "Customer Name", headerAlign:"center"}, 3);
+     */
+    addColumn(column: string | number | TableColumn, ...args: any[]): number;
+    /**
+     * Retrieve or updates a column at specified index.
+     *
+     * @param {number} i - Index of the column to retrieve or update.
+     * @param {boolean} [new_order] - Should the index be interpreted as a new sorted order index or original order. Default is `false`.
+     * @param {TableColumn} [column] - An object of column properties to update in a column at specified index. To retrieve the column omit this argument.
+     * @return {Table|TableColumn} When retrieving the column a column `object` is returned, otherwise `this` Table instance is returned.
+     * @see TableColumn
+     */
+    column(i: number, new_order?: boolean, ...args: any[]): Table | TableColumn;
+    /**
+     * Moves a column from one position to another. Uses new column order for column indexes (if columns were reordered).
+     *
+     * @param {number} from_index - Index of the column to move
+     * @param {number} to_index - New position index
+     */
+    moveColumn(from_index: number, to_index: number): void;
+    /**
+     * Sets or gets ability to change order of columns by dragging-dropping them by a user.
+     *
+     * @param {boolean} [enable] - To enable reordering pass `true`, to disable pass `false`.
+     * @return {boolean|Table} If setting a value this method returns `this` Table instance, when getting current value a `boolean` is returned.
+     */
+    canReorderColumns(...args: any[]): boolean | Table;
+    /**
+     * Removes a column at specified index. Also data at that column index for each row will also be removed.
+     *
+     * @param {number} i - Index of the column to remove.
+     * @param {boolean} [new_order] - Should the index be interpreted as a new sorted order index or original order. Default is `false`.
+     * @return {Table} Returns `this` Table instance for method chaining.
+     */
+    removeColumn(i: number, new_order?: boolean): Table;
+    /**
+     * Sets or get visibility of a column.
+     *
+     * @param {number} i - Index of the column
+     * @param {boolean} [new_order] - Should the index be interpreted as a new sorted order index or original order. Default is `false`.
+     * @param {boolean} [visible] - `true` to make the column visible, `false` to hide it.
+     * @return {boolean|Table} If `visible` argument is passed, then `this` Table object is returned, otherwise current visibility value is returned.
+     */
+    columnVisible(i: number, new_order?: boolean, ...args: any[]): boolean | Table;
+    /**
+     * Returns the amount of columns currently in the Table.
+     * @type {number}
+     * @readonly
+     */
+    readonly get columnCount(): number;
+    /**
+     * Gets or sets the list of columns for the table. To simple remove all columns pass `null` or empty Array.
+     *
+     * - When passing an array of column objects, it replaces the existing columns.
+     * - Passing `null` removes all columns.
+     * - Passing fewer columns than currently exist will also remove the extra columns from all rows.
+     *
+     * @param {string[]|number[]|TableColumn[]|boolean} [c] - An array of columns replaces existing ones. To remove all columns just pass an empty Array []. To get an Array of columns pass a `boolean` or nothing:
+     *  - `true` to get columns in a new order.
+     *  - `false` (default) to get columns in original order.
+     * @return {TableColumn[]|Table}
+     * @see TableColumn
+     */
+    columns(c?: string[] | number[] | TableColumn[] | boolean): TableColumn[] | Table;
+    /**
+     * Gets or sets columns' behavior when a single column is resized (usually manually by the user).
+     * Check description of each value of {@link Table#AutoResize} on this page.
+     * See usage example below.
+     *
+     * @param {Table.AutoResize} [value] - One of: Table.AutoResize.None (default), Table.AutoResize.NextColumn, Table.AutoResize.SubsequentColumns, Table.AutoResize.LastColumn, Table.AutoResize.AllColumns
+     * @return {Table.AutoResize|Table} Returns current auto-resize mode if no argument is passed, otherwise the `Table` instance for chaining.
+     * @example
+     * // disables resizing of other columns when one column is resized
+     * table.autoResizeColumns(Table.AutoResize.None);
+     *
+     * // last column will be resize to accommodate room for a column being resized
+     * table.autoResizeColumns(Table.AutoResize.LastColumn);
+     */
+    autoResizeColumns(...args: any[]): Readonly<{
+        None: 0;
+        NextColumn: 1;
+        SubsequentColumns: 2;
+        LastColumn: 3;
+        AllColumns: 4;
+    }> | Table;
+    /**
+     * Gets or sets current sort state of the table rows by specifying column and order. Does not sort by columns that are set to be not sortable.
+     *
+     * - When called without arguments, returns the current sort configuration.
+     * - When called with arguments, updates the sort state for the specified column.
+     * - Columns marked as non-sortable will be ignored.
+     *
+     * See usage examples below.
+     *
+     * @param {number|null|undefined} [column] - Column index to sort by, or `null` to clear sorting al onn columns. Omit or leave `undefined` to get current sort state.
+     * @param {boolean} [new_column_order=false] - Whether the given column index should be interpreted as a new column order (useful if columns were reordered).
+     * @param {Table.SortOrder} [order=Table.SortOrder.None] - One of: Table.SortOrder.None (default), Table.SortOrder.Ascending, Table.SortOrder.Descending.
+     * @return {Table|object|null} Returns `this` Table object for method chaining when settings a sort, otherwise returns current sort order as {column:number, order:Table.SortOrder} or `null` when table rows are not sorted.
+     * @see Table#SortOrder
+     * @example <h2>Setting a sort column and order:</h2>
+     * // Sorts rows by column 2 in descending order
+     * table.sortOrder(2, false, Table.SortOrder.Descending);
+     *
+     * // Resets sorting by column 2 while still sorting by previously sorted columns (if any)
+     * table.sortOrder(2, false, Table.SortOrder.None);
+     *
+     * // Resets row sorting for all columns. Rows become unsorted.
+     * table.sortOrder(null);
+     *
+     * @example <h2>Getting current sort state:</h2>
+     * let sorting = table.sortOrder();
+     * // returns `null` if there was no sorting applied to the table
+     * // or object like {column: 2, order: Table.SortOrder.Descending} if column 2 is currently sorted.
+     * // Returned `column` index is the original column index (remain same even after after columns were reordered).
+     */
+    sortOrder(column?: number | null | undefined, new_column_order?: boolean, order?: Readonly<{
+        None: 0;
+        Ascending: 1;
+        Descending: 2;
+    }>): Table | object | null;
+    /**
+     * Returns a number of rows in the Table.
+     *
+     * @type {number}
+     * @readonly
+     */
+    readonly get rowCount(): number;
+    /**
+     * Gets an array of all selected rows with all data in them.
+     *
+     * @type {Array.<Array.<(string|number|boolean)>>}
+     * @readonly
+     * @see Table#selection
+     * @see Table#selectedIndex
+     * @see Table#selectedCell
+     * @see Table#selectedValue
+     * @see Table#selectionMode
+     */
+    readonly get selectedRows(): Array<Array<(string | number | boolean)>>;
+    /**
+     * Sets or gets a background color of rows.
+     *
+     * @param {string} color - Hex style color string (e.g. #004453 or #00445377 with alpha), or `null` to reset background color to default.
+     * @return {string|Table} Returns current value when no argument is passed, otherwise returns `this` Table instance for method chaining.
+     */
+    rowBackground(...args: any[]): string | Table;
+    /**
+     * Gets/Sets/Resets the height of all table rows, or one existing row at specified index.
+     *
+     * @param {number|null|undefined} [height=undefined] - Set `number` to set height to specific number, `null` to reset height to default value, `undefined` to get height.
+     * @param {number} [index=-1] - Index of a specific row to apply given height to. Index is the original row position, it doesn't change due to sorting. -1 means that height will be applied to all rows.
+     * @return {number|Table} - If no argument is passed or `height` is set to `undefined` then current value is returned, otherwise `this` Table instance is returned for method chaining.
+     * @example
+     * // To get height of all rows
+     * let h = table.rowHeight();
+     *
+     * // To get a height of a specific row at index 5
+     * let h = table.rowHeight(undefined, 5);
+     *
+     * @example
+     * // To set height to all rows
+     * table.rowHeight(40);
+     *
+     * // To set height to row at index 5
+     * table.rowHeight(40, 5);
+     *
+     * @example
+     * // To reset height of all rows to default height
+     * table.rowHeight(null);
+     *
+     * // To reset height of row at index 5 to default height
+     * table.rowHeight(null, 5);
+     */
+    rowHeight(height?: number | null | undefined, index?: number): number | Table;
+    /**
+     * Sets or gets a row style at a specified row index. When the row is removed, the row style is also removed.
+     *
+     * @param {number} index - The row index.
+     * @param {boolean} [new_order=false] - Should the index be interpreted as a new sorted order index or original order. Default is `false`.
+     * @param {Object|null} [style=undefined] - An object containing style properties to set, `undefined` to get the row style object, or `null` to clear the styles.
+     *                              For example: {background:"#FF0000", color:"#0000FF", height: 40}.
+     *                              Set to `null` to clear all styles, or set a specific property to `null` to remove only that style (e.g., {background:null}).
+     *                              If omitted, the function returns the current style properties of the row.
+     * @return {Object|Table} - When setting the style, an instance of `this` Table is returned, otherwise a current style of specified row is returned.
+     * @example
+     * // how to set style for a row index 5
+     * table.rowStyle(5, false, {background:"#FF0000", color:"#FFAAAA", height: 40});
+     *
+     * // how to reset one style a row at index 5
+     * table.rowStyle(5, false, {color:"#FFAAAA"});
+     *
+     * // how to remove all styles from a row at index 5
+     * table.rowStyle(5, false, null);
+     *
+     * @example
+     * // How to get style of a row at index 5
+     * let style = table.rowStyle(5);
+     * console.log(style);
+     */
+    rowStyle(index: number, new_order?: boolean, style?: Object | null): Object | Table;
+    /**
+     * Adds a new row at the end of table or at a specified index.
+     *
+     * @param {Array.<(string|number|boolean)>} row - An array of cell values of the row according to each column. Missing cells will be filled with empty data.
+     * @param {number} [index] - Index at which to insert the row (original indexing, sorting is ignored).
+     * @return {number} Returns an index of added row, or -1 if the row was not added for some reason.
+     * @example
+     * table.addRow(["John Dow", 45, true, "Charlotte, NC", "[View|Remove]"]);
+     */
+    addRow(row: Array<(string | number | boolean)>, ...args: any[]): number;
+    /**
+     * Sets or gets all rows (array of arrays representing rows and cells) of the table. When setting rows, it replaces existing rows. To simply remove all rows pass `null` or empty Array as first argument.
+     * When getting rows you can pass "true" to get them in the new sorted order instead of original order.
+     * To filter out some rows pass `filter` argument. See {@link Table#filter} function's documentation for details about filter expression.
+     *
+     * @param {Array|boolean} [rows_or_new_order=false] - Array of rows to set for the table, or boolean `true` to return the rows in the new sorted order or `false` for original order.
+     * @param {string} [criteria=undefined] - Filter expression to retrieving only rows that meet the specified criteria. Default is `undefined`, no filter. Only use it for getting rows, NOT setting. Learn more about filter expression in docs from {@link Table#filter} method.
+     * @return {Array|Table} When settings rows to the table an instance of `this` this Table is returned. When retrieving rows a two-dimensional Array of rows is returned.
+     * @example <h2>Clearing all rows</h2>
+     * table.rows([]); // passing empty aray clears all existing rows
+     */
+    rows(rows_or_new_order?: any[] | boolean, criteria?: string): any[] | Table;
+    /**
+     * Gets or updates an existing row at a specified index.
+     *
+     * @param {number} index - Index of the row.
+     * @param {boolean} [new_order=false] - Specifies if the `index` argument is based on a new sorted order (true) or not (false).
+     * @param {Array.<(string|number|boolean)>} [row] array - A new row that will replace an existing row at specified index.
+     * @return {Array.<(string|number|boolean)>|Table} When retrieving a row an Array is returned. When updating updating a row an instance of `this` Table is returned.
+     * @example
+     * // To update values of an existing row at index 5
+     * table.row(5, false, ["Jane Dow", 40, false, "Charlotte, NC", "[View|Remove]"]);
+     */
+    row(index: number, new_order?: boolean, ...args: any[]): Array<(string | number | boolean)> | Table;
+    /**
+     * Removes one row at a specified index.
+     *
+     * @param {number} i - Index of the row to remove.
+     * @param {boolean} [new_order=false] - Indicates if given index is adjusted the sort order.
+     * @return {Table} Returns an instance of `this` Table for method chaining.
+     */
+    removeRow(i: number, new_order?: boolean): Table;
+    /**
+     * Sets/Removes selection of single row, list, or a range of rows, or gets an array of currently selected rows. Without arguments this returns an array of currently selected row indexes.
+     *
+     * @param {number|number[]|{from:number,to:number}|null} [selection] - One index, an array of indexes, or index range object {from:number, to:number}. Pass `null` to clear current selection. Omit this argument to get current selection.
+     * @param {boolean} [new_order=false] - Use new order after the rows were sorted (true) instead of using original order of rows by default (false). Default is false.
+     * @param {boolean} [add_remove=undefined] - Instead of setting a new selection use `true` to add, or `false` to remove from existing selection. Default is `undefined`.
+     * @returns {Table|number[]} When setting selection, an instance of `this` Table is returned. When getting selection, an array if indexes is returned.
+     * @see Table#selectedIndex
+     * @see Table#selectAll
+     * @example
+     * // Example of clearing current selection
+     * table.selection(null);
+     *
+     * @example
+     * // Examples of setting selection using a single index:
+     * table.selection(5) - Selects a single row.
+     * table.selection(5, true) - Selects a single row based on new sort order.
+     * table.selection(5, false, true) - Selects an additional single row (if it wasn't selected yet) based on original order.
+     *
+     * @example
+     * // Examples of selecting a range of rows using an index range object:
+     * table.selection({from:5, to:9}) - Selects only a range of rows from index 5 to 9 (Only possible when selection mode is set to SelectionMode.Range or SelectionMode.Multiple).
+     * table.selection({from:5, to:9}, true) - Selects only a range of rows from index 5 to 9 based on new sort order (Only possible when selection mode is set to SelectionMode.Range or SelectionMode.Multiple).
+     * table.selection({from:5, to:9}, true, true) - Selects a range of rows from index 5 to 9 based on new sort order in addition to previously selected rows (Only possible when selection mode is set to SelectionMode.Range or SelectionMode.Multiple).
+     *
+     * @example
+     * // Examples of selecting/deselecting multiple rows using an array of indexes:
+     * table.selection([6, 7, 4, 1]) - Selects only indexes specified in the array (Multiple intervals (ranges) are only possible when selection mode is set to SelectionMode.Multiple).
+     * table.selection([6, 7, 4, 1], true) - Selects only indexes specified in the array  based on new sort order (Multiple intervals (ranges) are only possible when selection mode is set to SelectionMode.Multiple).
+     * table.selection([6, 7], true, false) - Deselects rows at indexes specified in the array based on new sort order from previously selected rows.
+     *
+     */
+    selection(...args: any[]): Table | number[];
+    /**
+     * Selects/Deselects all rows in the Table
+     *
+     * @param {boolean} [selected=true] - `true` to select all rows, `false` to deselect all rows.
+     * @return {Table} Returns an instance of `this` Table for method chaining.
+     * @see Table#selectedIndex
+     * @see Table#selection
+     */
+    selectAll(selected?: boolean): Table;
+    /**
+     * Sets or returns an index of a single selected row. If multiple rows are selected, it returns an index of the first one. Selected index assumes new sorted row order the way it is viewed (not original order).
+     * To get/set one or more rows selection indexes and specify new or original sort order, use {@link Table#selection} method.
+     *
+     * @param {number} [index] - Index of the row to select. If index is not valid, it will have no effect.
+     * @returns {number|Table} When setting `index`, an instance of `this` Table is returned, otherwise a currently selected first row's index is returned, or -1 if no row is selected.
+     * @see Table#selection
+     * @see Table#selectAll
+     */
+    selectedIndex(...args: any[]): number | Table;
+    /**
+     * Sets row filter expression which can be a combination of conditions similar to `if()` condition in JavaScript.
+     *
+     * Setting the filter hides rows that don't match specified filter criteria. When filter is set to "", filter gets cleared and all rows become visible again.
+     *
+     * - Filter format is in the form of IF condition: `"column(index) operator comparison_value"`.
+     * - Note that a column must be specified on the left side of the condition and comparison value on the right side.
+     * - Conditions can be combined using AND "&&", OR "||", and parentheses "( )".
+     * - Condition in parentheses can be negated by "!" before parentheses.
+     * - Valid operators are: `! ( ) < == != > && || regex`.
+     * - `comparison_value` can be a `number`, `string` value, `string` regular expression, or `boolean`.
+     *
+     * See examples below.
+     *
+     * @param {string} [filter] - Filter to use to display only rows that meet the specified conditions. Default is "" (no filter).
+     * @return {Table|string} Returns `this` Table when setting filter, otherwise returns current filter.
+     * @example
+     * // Using case-insensitive regular expression
+     * table.filter(`column(1) regex "(?i)^Jim.*"`);
+     *
+     * @example
+     * // Filtering by numeric value
+     * table.filter("column(1) < 50");
+     *
+     * @example
+     * // Filtering by date
+     * table.filter(`column(3) > "2023-04-01 00:00:00" && column(3) < "2024-05-30 00:00:00"`);
+     *
+     * @example
+     * // Filtering by a boolean for checkbox
+     * table.filter("column(4) != false");
+     */
+    filter(...args: any[]): Table | string;
+    /**
+     * Finds rows by provided criteria and returns their indexes.
+     *
+     * @param {string} criteria] - Criteria expression to retrieve indexes or rows that meet the specified criteria. Learn more about filter expression in docs from {@link Table#filter} method.
+     * @param [new_order=false] - Boolean `true` to return the rows in the new sorted order or `false` for original order.
+     * @returns {number[]} Returns row indexes found by provided criteria.
+     */
+    findRows(criteria: string, new_order?: boolean | undefined): number[];
+    /**
+     * Scrolls the vertical scroll bar to make sure the row at specified index is visible (only if the row is not visible). If position is specified, the row will be placed at the specified position between the top and bottom of the Table component.
+     *
+     * @param {number} index - Index of a table row to make visible.
+     * @param {boolean} [new_order=false] - Specifies if the `index` argument is based on a new sorted order (true) or not (false).
+     * @param {number} [position] - A decimal number between 0 and 1 indicating vertical position in percentages (0% - 100% of the height of the component). If omitted, the row will only become visible, but not at a specific location.
+     */
+    scrollToIndex(index?: number, new_order?: boolean, position?: number): any;
+    /**
+     * Sets or gets selection mode, how user is able to select rows; only one at a time, any multiple rows, or only a range of rows.
+     * Default is "Table.Single".
+     *
+     * @param {SelectionMode} [mode] - One of: SelectionMode.Single (default), SelectionMode.Range, SelectionMode.Multiple. See {@link SelectionMode}.
+     * @return (SelectionMode|Table} When setting mode, an instance of `this` Table is returned, otherwise current mode is returned.
+     * @see SelectionMode
+     */
+    selectionMode(...args: any[]): any;
+    /**
+     * Sets or gets a value in currently selected cell (row and column). Has no effect when setting a value but no cells are selected or more than one cell is selected.
+     *
+     * @param {string|number|boolean} [value] - Value to set to the cell. Omit to get the value instead of setting.
+     * @return {string|number|boolean|Table} When setting a value an instance of `this` Table is returned, otherwise a current value is returned.
+     */
+    selectedValue(...args: any[]): string | number | boolean | Table;
+    /**
+     * Sets or gets a row and a column of selected cell.
+     *
+     * @param {number} [row] - Row of a cell. (Original order is used, sorting is disregarded.)
+     * @param {number} [column] - Column of a cell (required if row is specified). (Original order is used, column reordering is disregarded.)
+     * @return {number[]|Table} When both `row` and `cell` are passed, an instance of `this` Table is returned, otherwise a currently selected row and column is returned as an array of integers [row, column], or NULL if there is no selection.
+     */
+    selectedCell(...args: any[]): number[] | Table;
+    /**
+     * Gets or sets the cell currently being edited.
+     * When `row` and `column` are provided and are valid, the specified cell enters edit mode.
+     * Pass `null` as a first argument to stop editing currently edited cell. Do it before reading data from the Table to make sure the cell editor commits it's new value to the Table's data.
+     * When called with no arguments, returns the cell currently being edited, or `null` if no cell is being edited.
+     *
+     * @param {number} [row] - Row index of the cell to edit, or `null` to stop editing currently edited cell (if any).
+     * @param {number} [column] - Column index of the cell to edit.
+     * @param {boolean} [new_order=false] - Specified if row and column should be interpreted as new index as displayed (after row sorting and column reordering) or not.
+     * @return {Cell|null|Table} When row and cell is specified, an instance of `this` Table is returned, otherwise a currently edited cell is retuned of `null` if no cell is being edited.
+     * @example <h2>Stop editing before reading Table data</h2>
+     * if(table.editingCell() != null) table.editingCell(null); // stop editing a cell to commit its changes
+     * const _rows = table.rows(); // read new data
+     */
+    editingCell(...args: any[]): Cell | null | Table;
+    /**
+     * Sets or gets whether sorting can be toggled to unsorted state.
+     *
+     * @param {boolean} [enabled] - `true` to enable, `false` to disable. Omit to get current value.
+     * @return {boolean|Table} When setting, and instance of `this` Table is returned, otherwise a current value is returned.
+     */
+    triStateSorting(...args: any[]): boolean | Table;
+    /**
+     * Enables or disables Table header. When it's disabled, it doesn't respond to user's interaction.
+     *
+     * @param {boolean} [enable] - `true` to enable, `false` to disable.
+     * @return {boolean|Table} When setting, and instance of `this` Table is returned, otherwise a current value is returned.
+     */
+    headerEnabled(...args: any[]): boolean | Table;
+    /**
+     * Sets or gets a size (height) of Table header. Set it to 0 to make it not visible.
+     * @param {number} [size] - Height of table to set. Omit this argument to get current height.
+     * @return {number|Table} When setting, an instance of `this` Table is returned, otherwise a current value is returned.
+     */
+    headerSize(...args: any[]): number | Table;
+    /**
+     * Gets or sets which grid lines are visible (horizontal, vertical, both, or none).
+     *
+     * @param {Table.GridLines} [value] - One of: Table.GridLines.None, Table.GridLines.Horizontal, Table.GridLines.Vertical, Table.GridLines.Both (default). See {@link Table#GridLines}.
+     * @return {Table.GridLines|Table} Returns the current value if no parameter is provided; otherwise, returns the Table instance for chaining.
+     * @see Table#GridLines
+     */
+    gridLines(...args: any[]): Readonly<{
+        None: 0;
+        Horizontal: 1;
+        Vertical: 2;
+        Both: 3;
+    }> | Table;
+    /**
+     * Gets or sets the color of the table's grid lines.
+     * Note: This only has an effect if grid lines are enabled.
+     *
+     * @param {string} [color] - A valid CSS color string (e.g., "#000000" for black).
+     * @return {string|Table} Returns the current value if no parameter is provided; otherwise, returns the Table instance for chaining.
+     * @example
+     * // Set the grid line color
+     * table.gridColor("#000000");
+     *
+     * // Get the current grid line color
+     * alert(table.gridColor());
+     */
+    gridColor(...args: any[]): string | Table;
+    /**
+     * Sets or gets a value at a specified row and column. Returns `undefined` if specified row or column doesn't exist.
+     *
+     * @param {number} row - Index of the row in question
+     * @param {number} column - Index of the column in question
+     * @param {boolean} [new_order] - To use the new sorted order of rows and columns or not
+     * @param {string|number|boolean} [value] - The value to set the specified cell
+     * @return {string|number|boolean|Table} Returns the current cell value if new value is provided by `value` parameter; otherwise, returns the Table instance for chaining.
+     */
+    valueAt(row: number, column: number, new_order?: boolean, ...args: any[]): string | number | boolean | Table;
+    /**
+     * Returns the bounds of a table cell, position relative to the Table, position relative to screen, and the size.
+     *
+     * @param {number} row Zero-based row index.
+     * @param {number} column Zero-based column index.
+     * @param {boolean} [new_order=false] If `true`, the row and column indexes are interpreted using the current display order after sorting or column reordering. If `false`, the original model indexes are used.
+     * @returns {{x: number, y: number, screenX: number, screenY: number, width: number, height: number}} An object containing the cell's size in pixels, position relative to the table's client area, and position relative to screen.
+     * @example <h2>Getting cell bounds</h2>
+     * const bound = myTable.cellBounds(0, 0);
+     * console.log(bounds);
+     *
+     * // result is something like this
+     * {
+     * 	width: 20,
+     * 	height: 20,
+     * 	x: 1,
+     * 	y: 28,
+     * 	screenX: 437,
+     * 	screenY: 334
+     * }
+     */
+    cellBounds(row: number, column: number, new_order?: boolean): {
+        x: number;
+        y: number;
+        screenX: number;
+        screenY: number;
+        width: number;
+        height: number;
+    };
+    /**
+     * Gets a cell [row,column] located at specified X and Y coordinates relative to the Table's top-left corner.
+     *
+     * @param {number} x - X
+     * @param {number} y - Y
+     * @return {Cell|null} Returns the cell, or `null` if the coordinates are outside any cell.
+     */
+    cellAt(x: number, y: number): Cell | null;
+    /**
+     * Sets or gets how many quick mouse clicks on editable cells are required to change the cell to editing mode.
+     *
+     * @param {number} [clicks] - Amount of clicks: 1, 2, or 3. Default is 2 (double-click).
+     * @return {number|Table} Returns the current value if no parameters are provided; otherwise, and instance of `this` Table is returned.
+     */
+    clicksToEdit(...args: any[]): number | Table;
+    /**
+     * Gets, registers or unregisters a column event handler function. This event handler is called when a column is inserted, removed, resized, or moved (reordered).
+     *
+     * @param {function(ColumnEvent): any} [callback] - The event handler function. Receives a {@link ColumnEvent} formatted object.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {Table|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see ColumnEvent
+     * @see Table
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: Table,       // The Table component that triggered the event.
+     *   type: string,        // "insert", "remove", "move", "resize".
+     *   index: number        // Only when type is "insert", "remove", or "resize". Index of the column.
+     *   fromIndex: number,   // Only when type is "move". Indicates the previous index of the column.
+     *   toIndex: number,     // Only when type is "move". Indicates the new index of the column.
+     *   fromSize: number,    // Only when type is "resize". Indicates the previous size of the column.
+     *   toSize: number,      // Only when type is "resize". Indicates the new size of the column.
+     *   interactive: boolean // `true` when column was moved by the user interacting with the GUI. `false` when it was made programmatically.
+     * };
+     */
+    onColumnEvents(callback?: (arg0: ColumnEvent) => any, ...args: any[]): Table | Function[];
+    /**
+     * Gets, registers or unregisters a row event handler function. This event handler is called when rows are inserted, removed, or cell value was updated (also check out onChange() event handler for to simply detect a cell value change).
+     *
+     * @param {function(RowEvent): any} [callback] - The event handler function. Receives an {@link RowEvent} formatted object.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {Table|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see RowEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,        // The Table component that triggered the event.
+     *   type: string,          // "insert", "remove", "update".
+     *   row: number,           // Only when one row was effected. Index of the row.
+     *   column: number         // Only when type is "update". Column index of effected cell. Value of -1 means that all columns were effected.
+     *   fromRow: number        // Only when multiple rows were effected. Indicates beginning index within the range of effected rows.
+     *   toRow: number          // Only when multiple rows were effected. Indicates the last index within the range of effected rows.
+     *   interactive: boolean   // Only when type is "update". `true` when update was made by the user interacting with the GUI. `false` when update was made programmatically.
+     * };
+     */
+    onRowEvents(callback?: (arg0: RowEvent) => any, ...args: any[]): Table | Function[];
+    /**
+     * Gets, registers or unregisters an event handler function for column sorting event. This event handler is called when a column is sorted by user or programmatically.
+     *
+     * @param {function(Object): any} [callback] - The event handler function. Receives a {@link SortEvent} formatted object.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {Table|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see SortEvent
+     *
+     * @example
+     * // Example SortEvent object:
+     * const e = {
+     *   target: Table,         // The Table component that triggered the event.
+     *   type: Table.SortOrder, // Table.SortOrder.None, Table.SortOrder.Ascending, or Table.SortOrder.Descending.
+     *   column: number         // Only when type is not Table.SortOrder.None. Column index.
+     *   newOrderColumn: number // Only when type is not Table.SortOrder.None. New column index, taking into account that columns may be re-ordered.
+     *   interactive: boolean   // `true` when sorting was made by the user interacting with the GUI. `false` when it was made programmatically.
+     * };
+     */
+    onSort(callback?: (arg0: Object) => any, ...args: any[]): Table | Function[];
+}
+import { ScrollableComponent } from "./ScrollableComponent.js";