jspreadsheet 9.1.28 → 9.2.0

package/dist/index.d.ts

@@ -7,6 +7,39 @@ declare function jspreadsheet(element: HTMLElement, options: jspreadsheet.Spread
 
 declare namespace jspreadsheet {
 
+    /** License string. Use setLicense to define the license */
+    let license: string;
+
+    /** Default row height for a table */
+    let defaultRowHeight: number;
+
+    /** The container that holds all spreadsheet instances in the screen */
+    let spreadsheet: Spreadsheet[];
+
+    /** The container that holds all extensions loaded */
+    let extensions: object;
+
+    /** Advance excel like helpers */
+    let helpers: Helpers;
+
+    /** Native editors. You can have extra entries not defined here when working with custom editors */
+    let editors: Editors;
+
+    /** Internal method */
+    let picker: Function;
+
+    /** Define the translations from english to any other language. Ex.{ 'hello': 'Ola', 'Successfully Saved': 'Salvo com sucesso' } */
+    function setDictionary(dictionary: object) : void;
+
+    /** Set the license */
+    function setLicense(license: string) : void;
+
+    /** Set extensions to the JSS spreadsheet. Example { formula, parser, render } */
+    function setExtensions(extensions: object) : void;
+
+    /** Destroy the spreadsheet. Full destroy will clear all JSS controllers and it is not possible to re-create a new spreadsheet if true is used, until refresh the page. */
+    function destroy(element: HTMLElement, fullDestroy?: boolean) : void;
+
     /** Jspreadsheet parser extension. More info at: https://jspreadsheet.com/products */
     function parser(options: any) : void;
 
@@ -19,17 +52,61 @@ declare namespace jspreadsheet {
     /** Jspreadsheet forms extension. More info at: https://jspreadsheet.com/products */
     function forms(options: any) : void;
 
-    /** Set extensions to the JSS spreadsheet. Example { formula, parser, render } */
-    function setExtensions(extensions: object) : void;
-
-    /** Destroy the spreadsheet. Full destroy will clear all JSS controllers and it is not possible to re-create a new spreadsheet if true is used, until refresh the page. */
-    function destroy(element: HTMLElement, fullDestroy?: boolean) : void;
+    /** Get the current version */
+    function version(): object;
 
-    /** License string */
-    let license: string;
+    /** Native editors */
+    interface Editors {
+        // Create a DOM element for a cell edition
+        createEditor: (type: 'input'|'div', cellReference: HTMLElement, value: any, instance: worksheetInstance) => HTMLElement;
+        // Create a DOM for a floating editor container
+        createDialog: (cell: HTMLElement, value: any, x: number, y: number, instance: worksheetInstance) => HTMLElement;
+        // Default editor for text and numbers
+        general: Editor;
+        text: Editor;
+        number: Editor;
+        numeric: Editor;
+        percent: Editor;
+        notes: Editor;
+        dropdown: Editor;
+        autocomplete: Editor;
+        calendar: Editor;
+        color: Editor;
+        checkbox: Editor;
+        radio: Editor;
+        autonumber: Editor;
+        progressbar: Editor;
+        rating: Editor;
+        email: Editor;
+        url: Editor;
+        image: Editor;
+        html: Editor;
+        hidden: Editor;
+        tags: Editor;
+        record: Editor;
+    }
 
-    /** Set the license */
-    function setLicense(license: string) : void
+    /** Helpers */
+    interface Helpers {
+        // Get caret position for editable dom element
+        getCaretIndex: (element: HTMLElement) => number;
+        // Invert the key and values in an object
+        invert: (obj: object) => object;
+        // Get the excel-like letter based on the index number
+        getColumnName: (index: number) => string;
+        // Get the cell name from its coordinates
+        getColumnNameFromCoords: (x: number, y: number) => string;
+        // Get the coordinates from a cell name
+        getCoordsFromColumnName: (name: string) => [number, number];
+        // Shift the formula by x and y positions in the matrix
+        shiftFormula: (formula: string, x: number, y: number) => string;
+        // Get all the token names from a excel-like range
+        getTokensFromRange: (range: string) => string[];
+        // Get the range from an array of tokens
+        getRangeFromTokens: (tokens: string[]) => string;
+        // Extract the tokens from a formula
+        getTokens: (formula: string, worksheetName?: string) => string[];
+    }
 
     interface Tabs {
         /** Allow to create new tabs */
@@ -147,6 +224,31 @@ declare namespace jspreadsheet {
         placeholder?: string;
     }
 
+    interface DefinedNames {
+        index: string;
+        value: string;
+    }
+
+    /**
+     * Cell object
+     */
+    interface Records {
+        // CELL td element
+        element: HTMLTableCellElement;
+        // Cached value of the cell
+        v: string|number;
+        // Readonly
+        readonly: boolean;
+        // Coordinate X
+        x: number;
+        // Coordiname Y
+        y: number;
+        // Associate to an array of values
+        a?: any[][];
+        // Part of a merged cells
+        merged?: number[];
+    }
+
     interface Column {
         /** Define the column type. Can be a string to define a native editor, or a method to define the custom editor plugin. */
         type?: Editor | 'autocomplete' | 'calendar' | 'checkbox' | 'color' | 'dropdown' | 'hidden' | 'html' | 'image' | 'numeric' | 'radio' | 'text' | 'notes';
@@ -206,6 +308,39 @@ declare namespace jspreadsheet {
         zebra?: boolean;
     }
 
+    interface Border {
+        /** HTML Element for the border */
+        element: HTMLElement;
+        /** Border color */
+        color: string;
+        /** Used on the marching ants border */
+        moveLeft?: HTMLElement;
+        /** Used on the marching ants border */
+        moveTop?: HTMLElement;
+        /** Used on the marching ants border */
+        moveRight?: HTMLElement;
+        /** Used on the marching ants border */
+        moveDown?: HTMLElement;
+        /** Current x1 coordinates for the border */
+        x1: number;
+        /** Current y1 coordinates for the border */
+        y1: number;
+        /** Current x2 coordinates for the border */
+        x2: number;
+        /** Current y2 coordinates for the border */
+        y2: number;
+        /** Border is active in the viewport */
+        active: boolean;
+        /** Position top of the border */
+        t: number;
+        /** Position left of the border */
+        l: number;
+        /** Current border width */
+        w: number;
+        /** Current border height */
+        h: number;
+    }
+
     interface Row {
         /** Row height in pixels. */
         height?: number;
@@ -213,6 +348,29 @@ declare namespace jspreadsheet {
         title?: string;
         /** Row identification. */
         visible?: boolean;
+        /** Style for the tr */
+        style?: string;
+        /** RecordID for the row */
+        id?: number;
+        /** Group row elements */
+        group?: number[];
+        /** Group row state */
+        state?: boolean;
+    }
+
+    interface RowInstance {
+        /** Element */
+        element?: HTMLElement;
+        /** Row height in pixels. */
+        height?: number;
+        /** Row identification. */
+        visible?: boolean;
+        /** RecordID for the row */
+        id?: number;
+        /** Group row elements */
+        group?: number[];
+        /** Group row state */
+        state?: boolean;
     }
 
     interface Editor {
@@ -398,7 +556,7 @@ declare namespace jspreadsheet {
         /** When pagination is enabled and the user changes the page. */
         onchangepage?: (worksheet: worksheetInstance, pageNumber: number, oldPageNumber: number, quantityPerPage: number) => void;
         /** Add or change the options of a new worksheet. */
-        onbeforecreateworksheet?: (worksheetOptions: Worksheet, position: number) => Object;
+        onbeforecreateworksheet?: (worksheetOptions: Worksheet, options: object, position: number) => Object;
         /** When the user creates a new worksheet. */
         oncreateworksheet?: (worksheet: worksheetInstance, worksheetOptions: Worksheet, position: number) => void;
         /** When the user renames a worksheet. */
@@ -414,7 +572,7 @@ declare namespace jspreadsheet {
         /** Before the search method starts */
         onsearchstart?: (worksheet: worksheetInstance, query: string) => void;
         /** Before the search method starts */
-        onsearchsrow?: (worksheet: worksheetInstance, row: number, query: string) => boolean;
+        onsearchrow?: (worksheet: worksheetInstance, row: number, query: string) => boolean;
         /** Action to be executed before searching. The accepted method return would be: null to continue with the default behavior, false to cancel the user action or an array with the row numbers to overwrite the default result. */
         onbeforesearch?: (worksheet: worksheetInstance, query: string, results: []) => [] | boolean | void;
         /** After the search is applied to the rows. */
@@ -429,13 +587,7 @@ declare namespace jspreadsheet {
         oncreaterow?: (worksheet: worksheetInstance, rowNumber: number, tr: HTMLElement) => void;
         /** When a new column is created */
         oncreatecolumn?: (worksheet: worksheetInstance, columnNumber: number, td: HTMLElement, options: Object) => void;
-        /**
-         * Before execute a formula.
-         * @param {string} expression - formula to be executed.
-         * @param {number} coordinate x - cell coordinates
-         * @param {number} coordinate y
-         * @return {any} Return false to cancel parsing. Return new parsed formula. Return void to continue with original formula
-         */
+        /** A way to change the formula in real-time before execution */
         onbeforeformula?: (worksheet: worksheetInstance, expression: string, x: number, y: number) => string | false | void;
         /** Get the information about the expressions executed from the formula chain */
         onformulachain?: (worksheet: worksheetInstance, expressions: Array<object>) => void;
@@ -457,6 +609,16 @@ declare namespace jspreadsheet {
         onchangerowvisibility?: (worksheet: object, state: boolean, rows: []) => void
         /** When change the column visibility */
         onchangecolumnvisibility?: (worksheet: object, state: boolean, columns: []) => void
+        /** When a new row group is created */
+        oncreaterowgroup?: (worksheet: object, row: number, elements: number|number[]) => void
+        /** When a row group is destroyed */
+        ondestroyrowgroup?: (worksheet: object, row: number) => void
+        /** When open a row group */
+        onopenrowgroup?: (worksheet: object, row: number) => void
+        /** When close a row group */
+        oncloserowgroup?: (worksheet: object, row: number) => void
+        /** General event handler */
+        onevent?: (worksheet: Object, method: Object, a?: any, b?: any, c?: any, d?: any, e?: any, f?: any) => any
         /** Run every single table update action. Can bring performance issues if perform too much changes. */
         updateTable?: (worksheet: worksheetInstance, cell: Object, x: number, y: number, value: String) => void;
         /** Return false to cancel the contextMenu event, or return custom elements for the contextmenu. */
@@ -470,11 +632,13 @@ declare namespace jspreadsheet {
         /** About information */
         about?: string | Function,
         /** License string */
-        license?: string,
+        license?: string;
         /** Worksheets */
         worksheets?: Array<Worksheet>;
         /** Validations */
         validations?: any;
+        /** Plugins */
+        plugins?: Record<string, Function>
     }
 
     interface Worksheet {
@@ -491,7 +655,7 @@ declare namespace jspreadsheet {
         /** Deprecated. Please use the data property. */
         json?: Array<Record<string, any>>;
         /** Array with the rows properties definitions such as title, height. */
-        rows?: Row[];
+        rows?: Row[] | Record<number, Row>;
         /** The column properties define the behavior of a column and the associated editor */
         columns?: Array<Column>;
         /** Define the properties of a cell. This property overwrite the column definitions */
@@ -559,7 +723,7 @@ declare namespace jspreadsheet {
         /** Allow search on the spreadsheet */
         search?: boolean;
         /** Activate pagination and defines the number of records per page. Default: false */
-        pagination?: number;
+        pagination?: number | boolean;
         /** Dropdown for the user to change the number of records per page. Example: [10,25,50,100]. Default: false */
         paginationOptions?: boolean | Array<number>;
         /** Text Overflow. Default: false */
@@ -573,7 +737,7 @@ declare namespace jspreadsheet {
         /** Virtualization for columns. Works only when tableOverflow: true. Default: true */
         virtualizationX?: boolean;
         /** Virtualization for rows. Works only when tableOverflow: true. Default: true */
-        virtualizationY: boolean;
+        virtualizationY?: boolean;
         /** Initial comments. Default: null */
         comments?: Record<string, string>;
         /** Initial meta information. Default: null */
@@ -632,51 +796,51 @@ declare namespace jspreadsheet {
         /** DOM Element. Alias for el */
         element: HTMLElement;
         /** DOM Element container for the filters */
-        filters: HTMLElement;
+        filter: HTMLElement;
         /** Toggle the full screen mode */
         fullscreen: (state: Boolean) => void;
         /** Get the toolbar object definitions */
-        getToolbar: Toolbar,
+        getToolbar: (toolbar: Toolbar) => object,
         /** Set the toolbar */
         setToolbar: (toolbar: Toolbar) => void;
-        /** Show the toolbar for the worksheet */
+        /** Show the toolbar */
         showToolbar: () => void;
-        /** Hide the toolbar for the worksheet */
+        /** Hide the toolbar */
         hideToolbar: () => void;
         /** Get the worksheet by its id */
-        getWorksheet: (id: String) => Number;
+        getWorksheet: (id: String) => number;
         /** Get the active worksheet when applicable */
         getWorksheetActive: () => number;
         /** Get the worksheet instance by its position */
-        getWorksheetInstance: (position: Number) => worksheetInstance;
+        getWorksheetInstance: (position: number) => worksheetInstance;
         /** HTMLElement Helper */
         helper: HTMLElement,
         /** Array with the history information */
         history: [];
         /** Internal history index position */
-        historyIndex: Boolean;
+        historyIndex: number;
         /** Ignore events */
-        ignoreEvents: Boolean;
+        ignoreEvents: boolean;
         /** Ignore history events */
-        ignoreHistory: Boolean;
+        ignoreHistory: boolean;
         /** Ignore persistence events */
-        ignorePersistence: Boolean;
+        ignorePersistence: boolean;
         /** HTMLElement editor container */
         input: HTMLElement;
         /** HTMLElement loading element */
         loading: HTMLElement;
         /** Rename an existing worksheet by its position */
-        renameWorksheet: (position: Number, title: String) => void;
-        /** Move the position of a worksheet tab */
-        moveWorksheet: (from: Number, to: Number, updateDom: Boolean) => void;
+        renameWorksheet: (position: number, title: String) => void;
+        /** Move the position of a worksheet */
+        updateWorksheet: (from: number, to: number) => void;
+        /** Move the position of a worksheet. DOM Only (Internal method) - Please use updateWorksheet */
+        moveWorksheet: (from: number, to: number) => void;
         /** Open a worksheet */
-        openWorksheet: (position: Number) => void;
-        /** Get the worksheet name */
-        getWorksheetName: () => String;
+        openWorksheet: (position: number) => void;
         /** Spreadsheet unique name */
         name: string;
         /** List of plugins loaded to the spreadsheet */
-        plugins: Record<number, Plugin>;
+        plugins: Record<string, Plugin>;
         /** Processing flag. It would be true when the spreadsheet is loading. */
         processing: boolean;
         /** Show progressbar */
@@ -695,24 +859,34 @@ declare namespace jspreadsheet {
         tools: HTMLElement;
         /** Worksheets container */
         worksheets: Array<Worksheet>;
+        /** Load plugins into the spreadsheet */
+        setPlugins: (plugins: Record<string, Function>) => void;
+        /** Internal history handlers */
+        setHistory: (history: object) => void;
+        /** Internal history handlers */
+        resetHistory: () => void;
+        /** Internal method: event dispatch controllers. */
+        dispatch: (...args: string[]) => void;
+        /** Get the spreadsheet configuration */
+        getConfig: () => Spreadsheet;
     }
 
     interface worksheetInstance {
         /** Array with the borders information */
-        borders: Array<any>;
+        borders: Border[];
         /** Close the editon for one cell */
         closeEditor: (cell: HTMLElement, save: boolean) => void;
         /** Close the filters */
         closeFilters: (update: boolean) => void;
-        /** Array with the column width controllers */
-        colgroup: [];
+        /** Array with the HTML element references that define the columns */
+        colgroup: HTMLElement[];
         /** Hold the colgroup container */
         colgroupContainer: HTMLElement;
         /** DOM Worksheet container */
         content: HTMLElement;
         /** Copy */
         copy: (cut?: boolean) => void;
-        /** DOM Corner square */
+        /** HTML Element for the handler fill */
         corner: HTMLElement;
         /** Create a new worksheet */
         createWorksheet: (worksheetOptions: Worksheet) => worksheetInstance;
@@ -729,16 +903,18 @@ declare namespace jspreadsheet {
          * @return {array} array of data
          */
         data: (highlighted?: boolean, processedData?: boolean, delimiter?: string) => Array<Array<any>> | string
-        /** Internal use control type to defined JSON or ARRAY. */
-        dataType: boolean,
+        /** Internal use control type to defined JSON (1) or ARRAY (0). */
+        dataType: number,
         /** Delete an existing column */
         deleteColumn: (columnnumber: number, numOfColumns?: number) => void;
         /** Delete an existing row */
         deleteRow: (rownumber: number, numOfRows?: number) => void;
         /** Destroy all merged cells */
         destroyMerged: () => void;
-        /** Internal method: event dispatch controllers */
-        dispatch: (event?: string) => void;
+        /** Legacy alias destroyMerged */
+        destroyMerge: () => void;
+        /** Internal method: event dispatch controllers. */
+        dispatch: (...args: string[]) => void;
         /** Navigation down */
         down: (shiftKey?: boolean, ctrlKey?: boolean, jump?: boolean) => void;
         /** If extension render exists, execute render extension else download CSV */
@@ -746,23 +922,23 @@ declare namespace jspreadsheet {
         /** Download CSV */
         downloadCSV: (includeHeaders?: boolean, processed?: boolean) => void;
         /** Edition controllers */
-        edition: [];
+        edition?: [];
         /** DOM Worksheet. Alias for worksheet */
         element: HTMLElement;
         /** Internal method: Execute a formula. */
         executeFormula: (expression: string, x?: number, y?: number, caching?: boolean, basic?: boolean) => void;
         /** Navigation first */
         first: (shiftKey?: boolean, ctrlKey?: boolean) => void;
-        /** Footers */
+        /** Internal footer controllers */
         footers: Record<string, string>;
-        /** Formula chain. Internal use. */
+        /** Internal formula chain controllers */
         formula: [];
         /** Toggle the fullscreen mode */
         fullscreen: (state: boolean) => void;
         /** Get the border */
         getBorder: (alias: string) => object;
-        /** Get the cell element from the cellname */
-        getCell: (cellName: string) => HTMLElement | null;
+        /** Get the cell element from the cellName or via its coordinates x,y */
+        getCell: (cellNameOrColumnNumber: string|number, y?: number) => HTMLElement | null;
         /** Get the cell element from its coordinates */
         getCellFromCoords: (x: number, y: number) => Array<any>;
         /** Get attributes from one cell when applicable */
@@ -773,7 +949,7 @@ declare namespace jspreadsheet {
         getColumnData: (col: number, processed?: boolean) => Array<any>;
         /** Get the column position by its name */
         getColumnIdByName: (name: string) => number;
-        /** Alias for getProperty */
+        /** Alias for getProperties */
         getColumnOptions: (x: number, y?: number) => Column;
         /** Get the comments from one cell. Example: getComments('A1') */
         getComments: (cellName?: string) => string;
@@ -786,10 +962,10 @@ declare namespace jspreadsheet {
          * @param {boolean} get the raw or processed data
          * @param {string} delimiter to get the data as a string with columns separate by the char delimiter.
          * @param {boolean} get the data as a JSON object.
-         * @return {array|object} array or object with the data
+         * @return {array|string|null} array or string
          */
-        getData: (highlighted?: boolean, processed?: boolean, delimiter?: string, asJson?: boolean) => Array<any> | String;
-        /** Get the defined name or defined names when key is null */
+        getData: (highlighted?: boolean, processed?: boolean, delimiter?: string, asJson?: boolean) => Array<Array<any>> | Array<Record<string, any>> | string | null;
+        /** Get the defined name or all defined names when key is null */
         getDefinedNames: (key?: string) => object;
         /** Internal method: Get the editor for one cell */
         getEditor: (x: number, y: number) => Object;
@@ -807,20 +983,18 @@ declare namespace jspreadsheet {
         getHeight: (row?: number) => Array<number> | number;
         /** Get the highlighted coordinates */
         getHighlighted: () => Array<any>;
-        /** Get json */
-        getJson: (h?: boolean, processed?: boolean) => any;
-        /** Get the processed data cell shown to the user by the cell name */
-        getLabel: (cellName: string) => Object;
-        /** Get the processed data cell shown to the user by its coordinates */
-        getLabelFromCoords: (x: number, y: number) => string[];
+        /** Get the data as JSON. */
+        getJson: (h?: boolean, processed?: boolean, delimiter?: boolean, asJson?: boolean) => any;
+        /** Get the processed data cell shown to the user by the cell name or coordinates. */
+        getLabel: (cellNameOrColumnNumber: string|number, y?: number, extended?: boolean) => string;
+        /** Aliases for getLabel */
+        getLabelFromCoords: (cellNameOrColumnNumber: string|number, y?: number, extended?: boolean) => string;
         /** Get the merged cells. Cell name: A1, A2, etc or null for all cells */
         getMerge: (cellName?: string) => Object | Array<number>;
         /** Get one or all meta information for one cell. */
         getMeta: (cellName: string, property: string) => Object;
         /** Get the nested cells */
         getNestedCell: (x: number, y: number, properties?: any) => Object;
-        /** Get the nested header columns */
-        getNestedColumns: (x: number, y: number) => any[];
         /** Get the nested headers */
         getNestedHeaders: () => [];
         /** Get the next available number in the sequence */
@@ -833,6 +1007,8 @@ declare namespace jspreadsheet {
         getProcessed: (x: number, y: number, extended?: boolean) => any;
         /** Get the properties for one column when only x is present or the cell when x and y is defined. */
         getProperties: (x: number, y?: number) => Column;
+        /** Deprecated. Legacy alias to getProperties */
+        getProperty: (x: number, y?: number) => Column;
         /** Get the selection in a range format */
         getRange: () => string;
         /** Get a row data or meta information by Id. */
@@ -841,12 +1017,16 @@ declare namespace jspreadsheet {
         getRowData: (row: number, processed: boolean) => any[];
         /** Get the row id from its position */
         getRowId: (row: number) => number;
-        /** Get all selected cells */
-        getSelected: (columnNameOnly: boolean) => any[];
-        /** Get the selected columns. DOMElements or Indexes */
-        getSelectedColumns: (indexes?: Boolean) => Array<HTMLElement> | Array<number>;
+        /**
+         * Get the selected cells
+         * @param {boolean} columnNameOnly - Return an array of cell names or cell DOM elements
+         * @param {boolean} ignoreHidden - Ignore hidden cells
+         */
+        getSelected: (columnNameOnly: boolean, ignoreHidden?: boolean) => any[];
+        /** Get the selected columns indexes */
+        getSelectedColumns: () => number[];
         /** Get the selected rows. DOMElements or Indexes */
-        getSelectedRows: (indexes?: Boolean) => Array<HTMLElement> | Array<number>;
+        getSelectedRows: (indexes?: boolean) => HTMLElement[] | number[];
         /** Get the style from one cell. Ex. getStyle('A1') */
         getStyle: (cell: string) => Object;
         /** Get value by the cell name or object. The value can be the raw or processed value. */
@@ -863,8 +1043,8 @@ declare namespace jspreadsheet {
         headers: Array<HTMLElement>;
         /** Hide column */
         hideColumn: (column: number|number[]) => void;
-        /** Hide the filters */
-        hideFilter: () => void;
+        /** Hide the filters from one or all columns. */
+        hideFilter: (colNumber?: number) => void;
         /** Hide index column */
         hideIndex: () => void;
         /** Hide row */
@@ -872,21 +1052,21 @@ declare namespace jspreadsheet {
         /** Hide the search container */
         hideSearch: () => void;
         /** Add a new column */
-        insertColumn: (numOfColumns: number, columnnumber: number, insertBefore: boolean, properties: Column, data: []) => void;
+        insertColumn: (numOfColumnsOrData?: number|any[], columnNumber?: number, insertBefore?: boolean, properties?: Column, data?: any[], extraInformationFromEvents?: object, event?: object) => void;
         /** Add a new row */
-        insertRow: (numOfRows: number, rownumber: number, insertBefore: boolean, data: any[]) => void;
+        insertRow: (numOfRows: number, rowNumber: number, insertBefore: boolean, data: any[]) => void;
         /** Check if cell is attached to the DOM */
         isAttached: (x: number, y: number) => boolean;
         /** The worksheet is editable */
         isEditable: () => boolean;
-        /** Check if cell is readonly or not */
-        isReadOnly: (cell: Object) => boolean;
-        /** Cell is selected */
-        isSelected: (x: number, y: number) => boolean;
+        /** Check if cell is readonly or not. State used to set the state */
+        isReadOnly: (cell: Object, state?: boolean) => boolean;
+        /** Verify if this coordinates is within a selection or blank for the current selection */
+        isSelected: (x: number, y: number, selection?: number[]) => boolean;
         /** Navigation last */
-        last: () => void;
+        last: (shiftKey?: boolean, ctrlKey?: boolean) => void;
         /** Navigation left */
-        left: () => void;
+        left: (shiftKey?: boolean, ctrlKey?: boolean, jump?: boolean) => void;
         /** Dynamic load data to the spreadsheet. This method does not trigger events or persistence and reset the spreadsheet. To persist use setData. */
         loadData: (data: any[]) => void;
         /** Change a column position */
@@ -902,11 +1082,11 @@ declare namespace jspreadsheet {
         /** Worksheet configuration */
         options: Worksheet;
         /** Sort one column by its position. ASC (0) or DESC (1) */
-        orderBy: (column: number, direction: boolean) => void;
+        orderBy: (column: number, direction: boolean, internalValueController?: any[], internalPreviousStateController?: boolean) => void;
         /** Change page when using pagination */
-        page: (pagenumber: number) => void;
+        page: (pageNumber: number, callBack?: Function) => void;
         /** Current page number */
-        pagenumber: number;
+        pageNumber: number;
         /** Pagination DOM container */
         pagination: Object;
         /** Spreadsheet object */
@@ -915,8 +1095,8 @@ declare namespace jspreadsheet {
         paste: (x: number, y: number, data: string | any[]) => void;
         /** Get the quantity of pages when pagination is active */
         quantityOfPages?: () => number;
-        /** Array with the cell DOM elements */
-        records: Array<HTMLElement>;
+        /** Array container for all cell DOM elements */
+        records: Records[][];
         /** Refresh the whole data or from a single row  */
         refresh: (y: number | undefined) => void;
         /** Refresh the borders by the border name */
@@ -927,14 +1107,14 @@ declare namespace jspreadsheet {
         removeMerge: (cellName: String | Object) => void;
         /** Reset the borders by name border name */
         resetBorders: (border: String, resetPosition: boolean) => void;
-        /** Close the filters */
-        resetFilters: () => void;
+        /** Reset the filter of one or all columns */
+        resetFilters: (colNumber?: number) => void;
         /** Destroy the footers */
         resetFooter: () => void;
         /** Destroy freeze columns */
         resetFreezeColumns: () => void;
-        /** Reset meta data */
-        resetMeta: () => void;
+        /** Reset meta data of one or multiple cells. Null for all cells */
+        resetMeta: (cellName?: string[]|string) => void;
         /** Reset nested headers */
         resetNestedHeaders: () => void;
         /** Reset the search */
@@ -944,13 +1124,13 @@ declare namespace jspreadsheet {
         /** Get the style from one cell. Ex. resetStyle('A1') */
         resetStyle: (cell?: String) => void;
         /** DOM array of results */
-        results: Array<number>;
+        results: Array<number> | null;
         /** Navigation right */
-        right: () => void;
+        right: (shiftKey?: boolean, ctrlKey?: boolean, jump?: boolean) => void;
         /** Rotate the spreadsheet cell text. cell = A1, B1... etc */
         rotate: (cell: string|string[], value:number) => void;
-        /** DOM array of rows */
-        rows: Array<HTMLElement>;
+        /** Array of row objects */
+        rows: RowInstance[];
         /** Persistence helper method. The callback is executed with a JSON from the server */
         save: (url: String, data: Object, token?: String, callback?: (result: Object) => void) => void;
         /** ScrollX DOM Element */
@@ -982,9 +1162,9 @@ declare namespace jspreadsheet {
         /** Set the worksheet data */
         setData: (data: any[]) => void;
         /** Set the defined name */
-        setDefinedNames: (key: string, value: string) => void;
+        setDefinedNames: (names: DefinedNames[]) => void;
         /** Set filter */
-        setFilter: (colnumber: number, keywords: any[]) => void;
+        setFilter: (colNumber: number, keywords: any[]) => void;
         /** Set the footers */
         setFooter: (data: []) => void;
         /** Set the footer value */
@@ -993,18 +1173,18 @@ declare namespace jspreadsheet {
         setFreezeColumns: (num: number) => void;
         /** Set the header title. Empty or null to reset to the default header value. */
         setHeader: (x: number, title?: String) => void;
-        /** Set the height of one row by its position */
-        setHeight: (row: number, width: number) => void;
-        /** Get the merged cells. Cellname: A1, A2, etc */
-        setMerge: (cellName: String | Object, colspan?: number, rowspan?: number, forceOverwrite?: boolean) => void;
+        /** Set the height of one row by its position. currentHeight is for internal use only */
+        setHeight: (row: number|number[], height: number|number[], currentHeight?: number|number[]) => void;
+        /** Get the merged cells. Cell name: A1, A2, etc */
+        setMerge: (cellName: String | Object, colspan?: number, rowspan?: number) => void;
         /** Get one or various meta information for one cell. */
         setMeta: (cell: string | object, property?: string, value?: string) => void;
         /** Set the nested headers */
         setNestedHeaders: (config: any[]) => void;
-        /** Set plugins for the spreadsheet */
-        setPlugins: (plugins: any[]) => void;
-        /** Set the properties for one column */
-        setProperties: (column: number, settings: Object) => void;
+        /** Deprecated. Alias for parent.setPlugins */
+        setPlugins: (plugins: Record<string, Function>) => void;
+        /** Set the properties for a column or cell */
+        setProperties: (columnNumber: number, rowNumberOrColumnSettings: number|Column, settings?: Column) => void;
         /** Set or reset the cell as readonly */
         setReadOnly: (cell: Object, state: boolean) => void;
         /** Set the data from one row */
@@ -1017,29 +1197,29 @@ declare namespace jspreadsheet {
          * Set a cell value
          *
          * @param {mixed} cell destination cell
-         * @param {string} value value
-         * @param {string} force value over readonly cells
+         * @param {string|number} value
+         * @param {boolean} force value over readonly cells
          * @return void
          */
-        setValue: (cell: string, value?: String, forceOverwrite?: boolean) => void;
+        setValue: (cell: string|string[]|object, value?: string|number, forceOverwrite?: boolean) => void;
         /**
          * Set a cell value
          *
          * @param {number} x
          * @param {number} y
-         * @param {string} value value
-         * @param {string} force value over readonly cells
+         * @param {string|number} value value
+         * @param {boolean} force value over readonly cells
          * @return void
          */
-        setValueFromCoords: (x: number, y: number, value: string, force?: boolean) => void;
+        setValueFromCoords: (x: number, y: number, value: string|number, force?: boolean) => void;
         /** Set viewport width and height */
         setViewport: (width: number, height: number) => void;
         /** Set the width of one column by its position */
-        setWidth: (col: number, width: number) => void;
+        setWidth: (col: number|number[], width: number|number[]) => void;
         /** Show column */
         showColumn: (column: number|number[]) => void;
-        /** Show filter controls */
-        showFilter: () => void;
+        /** Show filter controls for one column or all columns */
+        showFilter: (column?: number) => void;
         /** Show index column */
         showIndex: () => void;
         /** Show row */
@@ -1054,14 +1234,8 @@ declare namespace jspreadsheet {
         tbody: HTMLElement;
         /** DOM Worksheet table tfoot */
         tfoot: HTMLElement;
-        /** Verify if one col + row is merged and return or not the merge cell */
-        isMerged: (x: number, y: number, getParent: boolean) => boolean | any[];
-        /** Verify if the col has any merged cells */
-        isColMerged: (x: number) => boolean;
-        /** Verify if the col has any merged cells */
-        isRowMerged: (y: number) => boolean;
         /** Navigation up */
-        up: () => void;
+        up: (shiftKey?: boolean, ctrlKey?: boolean, jump?: boolean) => void;
         /**
          * Internal method: Internal method: Set a cell value
          *
@@ -1077,13 +1251,68 @@ declare namespace jspreadsheet {
         /** Update the selection based on two DOM cell selements */
         updateSelection: (el1: number, el2: number, origin: boolean) => void;
         /** Update the selection based on coordinates */
-        updateSelectionFromCoords: (x1: number, y1: number, x2: number, y2: number, origin: boolean) => void;
+        updateSelectionFromCoords: (x1: number, y1: number, x2: number, y2: number, origin: boolean, type?: string, color?: string) => void;
         /** Getter/setter the value by coordinates */
         value?: (x: number, y: number, value?: any) => void;
         /** Which page the row number is */
         whichPage?: (row: number) => number;
+        /** Create a new group of rows */
+        setRowGroup: (row: number, elements: number|number[]) => void;
+        /** Open a new group of rows */
+        openRowGroup: (row: number) => void;
+        /** Close a new group of rows */
+        closeRowGroup: (row: number) => void;
+        /** Destroy a new group of rows */
+        destroyRowGroup: (row: number) => void;
+        /** Resize the given column numbers based on their content. */
+        autoResize: (column: number[]) => void;
+        /** Aliases for jspreadsheet.helpers. Tools to handle spreadsheet data */
+        helpers: Helpers;
+        /** Deprecated. Alias for the parent.showToolbar() */
+        showToolbar: () => void;
+        /** Deprecated. Alias for the parent.hideToolbar() */
+        hideToolbar: () => void;
+        /** Refresh the toolbar based on the current worksheet */
+        refreshToolbar: () => void;
+        /** Internal persistence handler */
+        persistence: Function;
+        /** Deprecated. Alias for parent.undo */
+        undo: () => void;
+        /** Deprecated. Alias for parent.redo */
+        redo: () => void;
+        /** Internal formula tracking */
+        tracking?: number[];
+        /** Visible columns on the viewport */
+        visibleRows?: number[];
+        /** Visible columns on the viewport */
+        visibleCols?: number[];
+        /** Viewport current width */
+        width?: number;
+        /** Viewport current width */
+        height?: number;
+        /** Get the row object */
+        getRow: (row: number) => RowInstance;
+        /** Internal worksheet onload method */
+        onload?: () => void;
+        /** Internal nested headers DOM container */
+        nested?: object;
+        /** Internal formula array values */
+        resetArray?: (x: number, y: number) => void;
+        /** Freeze a number of rows */
+        setFreezeRows: (numberOfRows: number) => void;
+        /** Reset the freeze rows */
+        resetFreezeRows: () => void;
+        /** Reset the properties of a cell */
+        resetProperty: (x: number, y: number) => void;
+        /** Internal method */
+        setFormula: () => void;
+        /** Update nested cell properties */
+        setNestedCell: (x: number, y: number, properties: Nested) => void;
+        /** Internal method: Update the merge cell dimensions */
+        updateMerge: (cellName: string, colspan: number, rowspan: number) => void;
+        /** Get the worksheet name */
+        getWorksheetName: () => string;
     }
 }
 
 export = jspreadsheet;
-