jspreadsheet 11.11.0 → 11.11.2

package/dist/index.d.ts

@@ -6,19 +6,19 @@
 declare function jspreadsheet(element: HTMLElement|HTMLDivElement|null, options: jspreadsheet.Spreadsheet) : Array<jspreadsheet.worksheetInstance>;
 
 declare namespace jspreadsheet {
-
+    let current: worksheetInstance | null;
     /** ClientID */
-    let clientId: string;
+    let clientId: string | null;
     /** License string. Use setLicense to define the license */
-    let license: string;
+    let license: string | null;
     /** Default row height for a table */
     let defaultRowHeight: number | string;
+    /** Default column width for a table */
+    let defaultColWidth: number;
     /** Column index default width. Default: 50 */
     let indexColumnWidth: number;
     /** The container that holds all spreadsheet instances in the screen */
-    let spreadsheet: Spreadsheet[];
-    /** The container that holds all extensions loaded */
-    let extensions: object;
+    let spreadsheet: spreadsheetInstance[];
     /** Advance excel like helpers */
     let helpers: Helpers;
     /** Native editors. You can have extra entries not defined here when working with custom editors */
@@ -26,20 +26,20 @@ declare namespace jspreadsheet {
     /** History tracker controllers */
     let history: History;
     /** Clipboard controller */
-    let clipboard: ClipBoard;
+    let clipboard: ClipBoardMethods;
     /** Shortcuts */
     let shortcuts: Shortcuts;
     /** Get the worksheet instance by its name */
-    function getWorksheetInstanceByName(worksheetName: string, namespace?: string) : worksheetInstance;
+    let getWorksheetInstanceByName: GetWorksheetInstanceByNameFunction;
 
     /** Picker */
-    function picker(el: HTMLElement, options: PickerOptions) :  void;
+    let picker: Picker;
 
     /** Pause calculations */
     function calculations(state: boolean) : void;
 
     /** Define the translations from english to any other language. Ex.{ 'hello': 'Ola', 'Successfully Saved': 'Salvo com sucesso' } */
-    function setDictionary(dictionary: object) : void;
+    let setDictionary: SetDictionary;
 
     /** Set the license */
     function setLicense(license: string|object) : void;
@@ -54,37 +54,69 @@ declare namespace jspreadsheet {
     function destroyAll() : void;
 
     /** Jspreadsheet parser extension. More info at: https://jspreadsheet.com/products */
-    function parser(options: any) : void;
+    let parser: ((options: any) => void) | undefined;
 
     /** Jspreadsheet formula extension. More info at: https://jspreadsheet.com/products */
-    function formula(expression: string, variables: object, x: number, y: number, instance: worksheetInstance) : void;
+    let formula: ((expression: string, variables: object, x: number, y: number, instance: worksheetInstance) => void) | undefined;
 
     /** Jspreadsheet parser extension. More info at: https://jspreadsheet.com/products */
-    function render(element: HTMLElement, options: any) : void;
+    let render: ((element: HTMLElement, options: any) => void) | undefined;
 
     /** Jspreadsheet forms extension. More info at: https://jspreadsheet.com/products */
-    function forms(options: any) : void;
+    let forms: ((options: any) => void) | undefined;
 
     /** Jspreadsheet search extension. More info at: https://jspreadsheet.com/products */
-    function search() : void;
+    let search: (() => void) | undefined;
 
     /** Jspreadsheet importer extension. More info at: https://jspreadsheet.com/products */
-    function importer() : void;
+    let importer: (() => void) | undefined;
 
     /** Jspreadsheet validations extension. More info at: https://jspreadsheet.com/products */
-    function validations() : void;
+    let validations: (() => void) | undefined;
 
     /** Jspreadsheet bar extension. More info at: https://jspreadsheet.com/products */
-    function bar(options?: { suggestions?: boolean }) : void;
+    let bar: ((options?: { suggestions?: boolean }) => void) | undefined;
 
     /** Jspreadsheet charts extension. More info at: https://jspreadsheet.com/products */
-    function charts() : void;
+    let charts: (() => void) | undefined;
 
     /** Jspreadsheet shapes extension. More info at: https://jspreadsheet.com/products */
-    function shapes() : void;
+    let shapes: (() => void) | undefined;
 
     /** Get the current version */
-    function version(): object;
+    function version(): {
+        version: string,
+        edition: string,
+        host: string,
+        license: string,
+        print: () => [string],
+    };
+
+    type GetWorksheetInstanceByNameFunction = (worksheetName?: string | null | undefined, namespace?: string) => worksheetInstance | Record<string, worksheetInstance>;
+
+    interface Picker {
+        (el: HTMLElement, options: PickerOptions) : void;
+
+        cancel: () => void;
+        click: () => void;
+        e: Record<string, any> | null | undefined;
+        end: () => void;
+        getRangeFromNode: () => RangeCoords | null | undefined;
+        hasEvent: (focus?: boolean) => Record<string, any> | null | undefined;
+        input: (element: HTMLElement) => void;
+        keydown: (event: KeyboardEvent) => void;
+        palette: (colors: string[]) => void;
+        selection: (x1: number, y1: number, x2: number, y2: number, event: Event) => boolean | undefined;
+        start: (element: HTMLElement) => void;
+        update: (element: HTMLElement) => void;
+        validSelection: (acceptNewNodeOnly?: boolean) => boolean;
+    }
+
+    interface SetDictionary {
+        (dictionary: object) : void;
+
+        translate: (text: string, substitutions: string[]) => string;
+    }
 
     interface Shortcuts {
         get: (event: object) => Function | null;
@@ -92,25 +124,35 @@ declare namespace jspreadsheet {
     }
 
     interface PickerOptions {
-        // picker creates a range selection component. formula expect to be a formula starting with '='
+        /** picker creates a range selection component. formula expect to be a formula starting with '=' */
         type?: 'formula' | 'picker';
-        // When the value is changed
+        /** When the value is changed */
         onchange?: (element: HTMLElement, mouseEvent: object) => void;
-        // Each time the selection is updated
+        /** Each time the selection is updated */
         onupdate?: (element: HTMLElement, mouseEvent: object) => void;
     }
 
+    type RangeCoords = [number, number, number, number];
+
     interface ClipBoard {
         worksheet: worksheetInstance,
         value: string,
-        selection: number[],
+        selection: RangeCoords,
+        highlighted: RangeCoords | RangeCoords[],
         cut: boolean,
-        hash: string,
+        hash: string | null,
+    }
+
+    interface ClipBoardMethods {
+        set(text: string, isCut?: boolean | undefined, coords?: RangeCoords, reset?: boolean): void,
+        get(): ClipBoard,
+        reset(resetClipboard?: boolean): void,
     }
 
     /** Images */
     interface Media {
-        type: 'image' | 'chart' | 'shape',
+        id: string,
+        type?: 'image' | 'chart' | 'shape',
         src?: string,
         top?: number,
         left?: number,
@@ -118,7 +160,7 @@ declare namespace jspreadsheet {
         height?: number,
         zIndex?: number,
         options?: object,
-        // This media is anchor to a cell, so position will be relative to the cell otherwise absolute
+        /** This media is anchor to a cell, so position will be relative to the cell otherwise absolute */
         cellAnchor?: string,
     }
 
@@ -134,26 +176,29 @@ declare namespace jspreadsheet {
         row?: number,
         data?: any[],
         options: Row,
+        [key: string]: any,
     }
 
     /** Advance comments */
     interface Comment {
-        // User unique identification
+        /** User unique identification */
         user_id?: number,
-        // User name
+        /** User name */
         name?: string,
-        // Comment content
+        /** Comment content */
         comments?: string,
-        // Date of the comments
+        /** Date of the comments */
         date?: string,
     }
 
     /** Global History */
     interface History {
+        (changes: Record<string, any>): void;
+
         /** History index cursor */
         index: number;
         /** History items */
-        actions: [];
+        actions: Record<string, any>[];
         /** When true the next item is cascaded in the same existing history element */
         cascade: boolean;
         /** When true no history will be added to the tracker */
@@ -212,20 +257,18 @@ declare namespace jspreadsheet {
 
     /** Only available with the Validations extension */
     interface Validations {
-        // Index position in the array of validations
+        /** Index position in the array of validations */
         index?: number | null;
-        // The validation definition object
+        /** The validation definition object */
         value: Validation;
     }
 
     /** Native editors */
     interface Editors {
-        // Create a DOM element for a cell edition
+        /** 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
+        /** 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;
@@ -252,42 +295,84 @@ declare namespace jspreadsheet {
     /** Helpers */
     interface Helpers {
         /**
-         * Compare two arrays to see if contains exact the same elements
-         * @param {number[]} a1
-         * @param {number[]} a2
-         * @return {boolean}
+         * Compare two arrays to see if contains exact the same elements.
+         * @param a1 - Array 1.
+         * @param a2 - Array 2.
          */
         compareArray: (a1: number[], a2: number[]) => boolean;
-        // Get caret position for editable dom element
+        /**
+         * Get caret position for editable dom element.
+         */
         getCaretIndex: (element: HTMLElement) => number;
-        // Invert the key and values in an object
+        /**
+         * Invert the key and values in an object.
+         */
         invert: (obj: object) => object;
-        // Get the excel-like letter based on the index number
+        /**
+         * Get the excel-like letter based on the index number.
+         */
         getColumnName: (index: number) => string;
-        // Get the cell name from its coordinates
+        /**
+         * Get the cell name from its coordinates.
+         */
         getCellNameFromCoords: (x: number, y: number) => string;
-        // Aliases or getCellNameFromCoords
+        /**
+         * Aliases or getCellNameFromCoords.
+         */
         getColumnNameFromCoords: (x: number, y: number) => string;
-        // Get the coordinates from a cell name
-        getCoordsFromCellName: (name: string) => [number, number];
-        // Alias for getCoordsFromCellName
-        getCoordsFromColumnName: (name: string) => [number, number];
-        // Shift the formula by x and y positions in the matrix
+        /**
+         * Get the coordinates from a cell name.
+         */
+        getCoordsFromCellName: (name: string) => [number | null, number | null] | [];
+        /**
+         * Alias for getCoordsFromCellName.
+         */
+        getCoordsFromColumnName: (name: string) => [number | null, number | null] | [];
+        /**
+         * 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;
-        // Get the coordinates as a number from a range string. Adjust helps to define the height dynamically when you have A:A ranges for example. Works in the same way for 1:1 ranges. Default: true
-        getCoordsFromRange: (range: string, adjust?: boolean) => [number,number,number,number];
-        // Get range string from [x1,y1,x2,y2]
-        getRangeFromCoords: (coords: [number,number,number,number]) => string;
-        // Extract the configuration from JSS from a static HTML table
+        /**
+         * Get all the token names from a excel-like range.
+         */
+        getTokensFromRange: (range: string, force?: boolean, worksheetName?: string, removeDuplicates?: boolean) => string[];
+        /**
+         * Get the range from an array of tokens.
+         */
+        getRangeFromTokens: (tokens: string[], fixCurrencySymbol?: string) => string;
+        /**
+         * Get the coordinates as a number from a range string. Adjust helps to define the height dynamically when you have A:A ranges for example. Works in the same way for 1:1 ranges. Default: true.
+         */
+        getCoordsFromRange: (range: string, adjust?: boolean) => RangeCoords;
+        /**
+         * Get range string from [x1,y1,x2,y2].
+         */
+        getRangeFromCoords(coords: RangeCoords): string;
+        getRangeFromCoords(x1: number, y1: number, x2: number, y2: number): string;
+        /**
+         * Extract the configuration from JSS from a static HTML table.
+         */
         createFromTable: (element: HTMLElement, options?: Worksheet) => Worksheet;
-        // CSV string to JS array. delimiter default ','
-        parseCSV: (str: string, delimiter?: string) => string[];
-        // Get all token names inside an range
-        getTokensFromCoords: (x1: number, y1: number, x2: number, y2: number, worksheetName?: string) => []
+        /**
+         * CSV string to JS array.
+         * @param str - CSV string.
+         * @param delimiter - Default: ','.
+         */
+        parseCSV: (str: string, delimiter?: string) => string[][];
+        /**
+         * Get all token names inside an range.
+         */
+        getTokensFromCoords: (x1: number, y1: number, x2: number, y2: number, worksheetName?: string) => string[];
+
+        focus: (element: HTMLElement) => void;
+
+        setCaretIndex: (element: any, index: number) => void;
+
+        getCaretNode: (target: HTMLElement) => HTMLElement | null;
+
+        secureFormula: (oldValue: string, runtime?: boolean) => string;
+
+        insertLineBreak: () => void;
     }
 
     interface Tabs {
@@ -379,9 +464,9 @@ declare namespace jspreadsheet {
         /** Event handler for when a new option is added to the dropdown */
         oninsert?: (obj: object, item: DropdownItem, newItem: DropdownItem) => void;
         /** Event handler for just before a new option is added to the dropdown */
-        onbeforeinsert?: (obj: object, item: DropdownItem) => void;
+        onbeforeinsert?: (obj: object, item: DropdownItem) => DropdownItem | false | undefined;
         /** Event handler for before a search on autocomplete is performed */
-        onbeforesearch?: (obj: object, ajaxRequest: object) => boolean | null;
+        onbeforesearch?: (obj: object, ajaxRequest: object) => object | false | undefined;
         /** Event handler for processing search results */
         onsearch?: (obj: object, result: object) => void;
         /** Toggles the sorting of dropdown elements */
@@ -439,12 +524,14 @@ declare namespace jspreadsheet {
         /** Specifies the type of calendar to render. Default is 'default'. Possible values are 'default' and 'year-month-picker'. */
         type?: 'default' | 'year-month-picker';
         /** An array of numbers specifying a range of valid dates. Dates outside this range will be disabled. */
-        validRange?: number[];
+        validRange?: [number, number];
+        /** The day of the week the calendar starts on (0 for Sunday - 6 for Saturday). Default: 0. */
+        startingDay?: number;
         /** Specifies the day of the week the calendar starts on, where 0 is Sunday and 6 is Saturday. Default is 0 (Sunday). */
         format?: string;
         /** Specifies whether the calendar input is readonly or not. Default is false. */
         readonly?: boolean;
-        /** Specifies whether today's date is automatically selected when no date is defined. Default is false. */
+        /** Specifies whether today's date is automatically selected when no date is defined. */
         today?: boolean;
         /** Specifies whether to display a dropdown for selecting hour and minute values. Default is false. */
         time?: boolean;
@@ -454,6 +541,8 @@ declare namespace jspreadsheet {
         placeholder?: string;
         /** Auto select confirms the current date as the new value onblur. Default: true */
         autoSelect?: boolean;
+        /** Open in fullscreen mode. */
+        fullscreen?: boolean;
     }
 
     interface DefinedNames {
@@ -465,47 +554,39 @@ declare namespace jspreadsheet {
      * Cell object
      */
     interface Records {
-        // CELL td element
+        /** CELL td element */
         element: HTMLTableCellElement;
-        // Cached value of the cell
-        v: string|number;
-        // Readonly
-        readonly: boolean;
-        // Coordinate X
+        /** Cached value of the cell */
+        v: string | number | boolean | undefined;
+        /** Coordinate X */
         x: number;
-        // Coordinate Y
+        /** Coordinate Y */
         y: number;
-        // Associate to an array of values
-        a?: any[][];
-        // Part of a merged cells
+        /** Associate to an array of values */
+        a?: Map<Records, any>;
+        /** Part of a merged cells */
         merged?: any[];
-        // Style
+        /** Merged cells */
+        mergeCells?: [number, number];
+        /** Style */
         s?: number;
-        // Comments
-        c?: string|object;
-        // Meta
+        /** Comments */
+        c?: string | Record<string, any>[];
+        /** Meta */
         meta?: object;
-        // Chain
-        chain?: Map<object, object>;
+        /** Chain */
+        chain?: Map<Records, true>;
+        // Worksheet Instance
+        w: worksheetInstance;
     }
 
-    interface Column {
+    type ColumnType = Editor | 'text' | 'number' | 'numeric' | 'percent' | 'notes' | 'dropdown' | 'autocomplete' | 'calendar' | 'color' | 'checkbox' | 'radio' | 'autonumber' | 'progressbar' | 'rating' | 'email' | 'url' | 'image' | 'html' | 'hidden' | 'tags' | 'record';
+
+    interface ColumnPrimitiveProperties {
         /** Define the type of editor to use for the column. Can be a string to define a native editor, or a method to define a custom editor plugin. */
-        type?: Editor | 'text' | 'number' | 'numeric' | 'percent' | 'notes' | 'dropdown' | 'autocomplete' | 'calendar' | 'color' | 'checkbox' | 'radio' | 'autonumber' | 'progressbar' | 'rating' | 'email' | 'url' | 'image' | 'html' | 'hidden' | 'tags' | 'record';
-        /** The title of the column. */
-        title?: string;
-        /** The name or path of a property when the data is a JSON object. */
-        name?: string;
-        /** Define the tooltip text to display on mouseover for the column header. */
-        tooltip?: string;
-        /** The width of the column. Default: 100px */
-        width?: number;
-        /** Whether the column is visible. */
-        visible?: boolean,
+        type?: ColumnType;
         /** The alignment of the column content. Default: center. */
         align?: 'center' | 'left' | 'right' | 'justify';
-        /** A method to overwrite the column definitions in real-time just before the column is edited. */
-        filterOptions?: (worksheet: worksheetInstance, cell: HTMLElement, x: number, y: number, value: number|string, options: Column) => Column;
         /** The URL to load items from for the dropdown in this column, or when used in a text cell it will be a create a link */
         url?: string;
         /** The items to show in the dropdown or autocomplete. */
@@ -532,8 +613,6 @@ declare namespace jspreadsheet {
         format?: string;
         /** Locale for Intl.NumberFormat */
         locale?: string,
-        /** Whether the column is a primary key. */
-        primaryKey?: boolean;
         /** Extended configuration for the column. */
         options?: Calendar | Dropdown | object;
         /** Whether the column is read-only. */
@@ -542,18 +621,10 @@ declare namespace jspreadsheet {
         process?: boolean;
         /** Whether to try to cast numbers from a cell text. Default: true. */
         autoCasting?: boolean;
-        /** Whether to shift the formula when copying and pasting. This option is only valid for custom column types. Default: false. */
-        shiftFormula?: boolean;
         /** Whether to wrap the text in the column. */
         wrap?: boolean;
         /** The rotation angle for the text value, between -90 and 90. Default: null. */
         rotate?: number;
-        /** Whether to apply CSS odd-even background color to the column. Default: false. */
-        zebra?: boolean;
-        /** The number of columns to group together. */
-        group?: number;
-        /** State of the column group. */
-        state?: boolean;
         /** Record editor */
         worksheetId?: string;
         worksheetColumn?: number;
@@ -561,52 +632,33 @@ declare namespace jspreadsheet {
         locked?: boolean;
     }
 
-    interface Cell {
-        /** Define the type of editor to use for the column. Can be a string to define a native editor, or a method to define a custom editor plugin. */
-        type?: Editor | 'text' | 'number' | 'numeric' | 'percent' | 'notes' | 'dropdown' | 'autocomplete' | 'calendar' | 'color' | 'checkbox' | 'radio' | 'autonumber' | 'progressbar' | 'rating' | 'email' | 'url' | 'image' | 'html' | 'hidden' | 'tags' | 'record';
+    interface Column extends ColumnPrimitiveProperties {
         /** The title of the column. */
         title?: string;
+        /** The name or path of a property when the data is a JSON object. */
+        name?: string;
         /** Define the tooltip text to display on mouseover for the column header. */
         tooltip?: string;
-        /** The alignment of the column content. Default: center. */
-        align?: 'center' | 'left' | 'right' | 'justify';
-        /** The items to show in the dropdown or autocomplete. */
-        source?: Array<DropdownItem> | Array<string> | Array<number>;
-        /** Whether the column is an autocomplete field. */
-        autocomplete?: boolean;
-        /** Whether the dropdown or autocomplete can accept multiple options. */
-        multiple?: boolean;
-        /** The delimiter to use for separating multiple dropdown options. Default: ";". */
-        delimiter?: string;
-        /** The input mask to apply to the data cell. @see https://jsuites.net/v4/javascript-mask */
-        mask?: string;
-        /** The character to use as the decimal separator. */
-        decimal?: '.' | ',';
-        /** The maximum number of characters to display in the cell before truncating. */
-        truncate?: number,
-        /** Whether to disable the mask when editing. */
-        disabledMaskOnEdition?: boolean;
-        /** A renderer method or rule for the cell content. */
-        render?: string | ((td: HTMLElement, value: number|string, x: number, y: number, worksheet: worksheetInstance, options: Column) => void);
-        /** The format of the date or numbers in the cell. Default for the calendar: "DD/MM/YYYY". */
-        format?: string;
-        /** Locale for Intl.NumberFormat */
-        locale?: string,
-        /** Extended configuration for the column. */
-        options?: Calendar | Dropdown | object;
-        /** Whether the column is read-only. */
-        readOnly?: boolean;
-        /** The rotation angle for the text value, between -90 and 90. Default: null. */
-        rotate?: number;
-        /** URL */
-        url?: string;
-        /** Record editor */
-        worksheetId?: string;
-        worksheetColumn?: number;
-        worksheetImage?: boolean;
-        locked?: boolean;
+        /** The width of the column. Default: 100px */
+        width?: number;
+        /** Whether the column is visible. */
+        visible?: boolean,
+        /** A method to overwrite the column definitions in real-time just before the column is edited. */
+        filterOptions?: (worksheet: worksheetInstance, cell: HTMLElement, x: number, y: number, value: number|string, options: Column) => Column;
+        /** Whether the column is a primary key. */
+        primaryKey?: boolean;
+        /** Whether to shift the formula when copying and pasting. This option is only valid for custom column types. Default: false. */
+        shiftFormula?: boolean;
+        /** Whether to apply CSS odd-even background color to the column. Default: false. */
+        zebra?: boolean;
+        /** The number of columns to group together. */
+        group?: number;
+        /** State of the column group. */
+        state?: boolean;
     }
 
+    interface Cell extends ColumnPrimitiveProperties { }
+
     interface Border {
         /** HTML Element for the border */
         element: HTMLElement;
@@ -657,19 +709,11 @@ declare namespace jspreadsheet {
       readOnly?: 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 RowInstance extends Row {
+        /** Element. */
+        element: HTMLTableRowElement;
+        /** Row index. */
+        y: number;
     }
 
     interface Editor {
@@ -683,8 +727,6 @@ declare namespace jspreadsheet {
         closeEditor?: (cell: HTMLTableCellElement, confirmChanges: boolean, x: number, y: number, instance: worksheetInstance, options: Column | Cell) => any;
         /** When a cell is destroyed. */
         destroyCell?: (cell: HTMLTableCellElement, x: number, y: number, instance: worksheetInstance) => void;
-        /** Apply updates when the properties of a cell or column is changed. */
-        updateProperty?: (x: number, y: number, instance: worksheetInstance, options: Column | Cell) => void;
         /** Transform the raw data into processed data. It will show a text instead of an id in the type dropdown for example. */
         get?: (options: object, value: any, extended: boolean, instance: worksheetInstance) => string
     }
@@ -695,13 +737,13 @@ declare namespace jspreadsheet {
         /** When a new worksheet is added. */
         init?: (worksheet: worksheetInstance) => void;
         /** It would receive a call for every spreadsheet event. */
-        onevent?: (event: string, a?: any, b?: any, c?: any, d?: any) => void;
+        onevent?: (event: string, ...args: any[]) => any;
         /** When the spreadsheet needs to save something in the server. */
         persistence?: (method: string, args: object) => void;
         /** When the user opens the context menu. */
-        contextMenu?: (instance: worksheetInstance, x: number, y: number, e: MouseEvent, items:Array<ContextmenuItem> , section: string, a: any, b?: any) => void;
-        /** When the toolbar is create and clicked. */
-        toolbar?: (instance: worksheetInstance, toolbar: Toolbar) => void;
+        contextMenu?: (instance: worksheetInstance, x: number, y: number, e: MouseEvent, items:Array<ContextmenuItem> , section: string, a: any, b?: any) => Array<ContextmenuItem>;
+        /** When the toolbar is created and clicked. */
+        toolbar?: (instance: worksheetInstance, toolbar: Toolbar) => Toolbar;
     }
 
     interface Nested {
@@ -720,8 +762,6 @@ declare namespace jspreadsheet {
     interface Spreadsheet {
         /** Your application name */
         application?: string;
-        /** Deprecated */
-        cloud?: string;
         /** Remote configuration with Jspreadsheet Server */
         guid?: string;
         /** DOM element for binding the javascript events. This property is normally used when JSS is running as a web component. */
@@ -733,7 +773,7 @@ declare namespace jspreadsheet {
         /** Remote URL for the persistence server */
         server?: string;
         /** Enable the toolbars */
-        toolbar?: boolean | 'extended' | Toolbar | Function;
+        toolbar?: boolean | Toolbar | ToolbarItem[] | Function;
         /**  Allow table edition */
         editable?: boolean;
         /** Allow data export */
@@ -742,12 +782,8 @@ declare namespace jspreadsheet {
         includeHeadersOnDownload?: boolean;
         /** Force update on paste for read-only cells */
         forceUpdateOnPaste?: boolean;
-        /** Enable loading spin when loading data. Default: false. */
-        loadingSpin?: boolean;
         /** Render jspreadsheet spreadsheet on full screen mode. Default: false */
         fullscreen?: boolean;
-        /** Make sure the formulas are capital letter. Default: true */
-        secureFormulas?: boolean;
         /** Enable formula debug. Default: false */
         debugFormulas?: boolean,
         /** Execute formulas. Default: true */
@@ -758,8 +794,6 @@ declare namespace jspreadsheet {
         autoIncrement?: boolean;
         /** Try to cast numbers from cell values when executing formulas. Default: true */
         autoCasting?: boolean;
-        /** Deprecated */
-        stripHTML?: boolean;
         /** Parse HTML. Default: false (Use this with caution) */
         parseHTML?: boolean;
         /** Allow bar when extension bar is enabled. Default: true */
@@ -783,37 +817,44 @@ declare namespace jspreadsheet {
         /** When redo is applied */
         onredo?: (worksheet: worksheetInstance, historyRecord: object) => void;
         /** Before any data is sent to the backend. Can be used to overwrite the data or to cancel the action when return false. */
-        onbeforesave?: (spreadsheet: spreadsheetInstance, worksheet: worksheetInstance, data: object) => boolean | object;
+        onbeforesave?: (spreadsheet: spreadsheetInstance, worksheet: worksheetInstance, data: object) => boolean | object | undefined;
         /** After something is saved */
-        onsave?: (spreadsheet: spreadsheetInstance, worksheet: worksheetInstance, data: Array<any>, result: object) => void;
+        onsave?: (spreadsheet: spreadsheetInstance, worksheet: worksheetInstance, data: object, result: object) => void;
         /** When something goes wrong during a persistence operation */
         onerror?: (spreadsheet: spreadsheetInstance, result: object) => void;
         /** Before a column value is changed. NOTE: It is possible to overwrite the original value, by return a new value on this method. */
-        onbeforechange?: (worksheet: worksheetInstance, cell: HTMLElement, x: number, y: number, value: any) => boolean | any;
+        onbeforechange?: (worksheet: worksheetInstance, cell: HTMLElement, x: number | string, y: number | string, value: any) => false | any | undefined;
         /** After a column value is changed. */
-        onchange?: (worksheet: worksheetInstance, cell: HTMLElement, x: number, y: number, newValue: any, oldValue: any) => void;
+        onchange?: (worksheet: worksheetInstance, cell: HTMLElement, x: number | string, y: number | string, newValue: any, oldValue: any) => void;
         /** When all data have been updated. Origin: 'paste', 'handle-fill' or undefined */
-        onafterchanges?: (worksheet: worksheetInstance, records: Array<any>, origin: string) => void;
+        onafterchanges?: (worksheet: worksheetInstance, records: Record<string, any>[], origin: string | undefined) => void;
         /** When a copy is performed in the spreadsheet. Any string returned will overwrite the user data or return null to progress with the default behavior. */
-        oncopy?: (worksheet: worksheetInstance, selectedCells: Array<number>, data: string, cut: boolean) => boolean | string;
+        oncopy?: (worksheet: worksheetInstance, selectedCells: RangeCoords, data: string, cut: boolean | undefined) => false | string | undefined;
         /** Before the paste action is performed. Can return parsed or filtered data. It is possible to cancel the action when the return is false. */
-        onbeforepaste?: (worksheet: worksheetInstance, data: Array<any>, x: number, y: number, properties: []) => boolean | [];
+        onbeforepaste?: (worksheet: worksheetInstance, data: Record<string, any>[][], x: number, y: number) => false | Record<string, any>[][] | undefined;
         /** After a paste action is performed in the spreadsheet. */
-        onpaste?: (worksheet: worksheetInstance, records: Array<any>) => void;
+        onpaste?: (
+            worksheet: worksheetInstance,
+            records: {
+                x: number,
+                y: number,
+                [key: string]: any,
+            }
+        ) => void;
         /** Before a new row is inserted. You can cancel the insert event by returning false. */
-        onbeforeinsertrow?: (worksheet: worksheetInstance, newRow: []) => boolean | newRow[] | void;
+        onbeforeinsertrow?: (worksheet: worksheetInstance, newRow: Record<string, any>[]) => false | newRow[] | undefined;
         /** After a new row is inserted. */
-        oninsertrow?: (worksheet: worksheetInstance, newRow: []) => void;
+        oninsertrow?: (worksheet: worksheetInstance, newRow: Record<string, any>[]) => void;
         /** Before a row is deleted. You can cancel the delete event by returning false. */
-        onbeforedeleterow?: (worksheet: worksheetInstance,  rows: number[]) => number[] | boolean | void;
+        onbeforedeleterow?: (worksheet: worksheetInstance, rows: number[]) => number[] | false | undefined;
         /** After a row is excluded. */
         ondeleterow?: (worksheet: worksheetInstance, rows: number[]) => void;
         /** Before a new column is inserted. You can cancel the insert event by returning false. */
-        onbeforeinsertcolumn?: (worksheet: worksheetInstance, newColumn: []) => boolean | newColumn[] | void;
+        onbeforeinsertcolumn?: (worksheet: worksheetInstance, newColumn: Record<string, any>[]) => false | newColumn[] | undefined;
         /** After a new column is inserted. */
-        oninsertcolumn?: (worksheet: worksheetInstance, affected: []) => void;
+        oninsertcolumn?: (worksheet: worksheetInstance, affected: Record<string, any>[]) => void;
         /** Before a column is excluded. You can cancel the insert event by returning false. */
-        onbeforedeletecolumn?: (worksheet: worksheetInstance, cols: number[]) => number[] | boolean | void;
+        onbeforedeletecolumn?: (worksheet: worksheetInstance, cols: number[]) => false | number[] | undefined;
         /** After a column is excluded. */
         ondeletecolumn?: (worksheet: worksheetInstance, cols: number[]) => void;
         /** After a row is moved to a new position. */
@@ -825,17 +866,17 @@ declare namespace jspreadsheet {
         /** After a column width change for one or more columns. */
         onresizecolumn?: (worksheet: worksheetInstance, column: number | Array<number>, width: number | Array<number>, oldWidth: number | Array<number>) => void;
         /** Before the selection happens */
-        onbeforeselection?: (worksheet: worksheetInstance, px: number, py: number, ux: number, uy: number, origin?: object) => void | boolean;
+        onbeforeselection?: (worksheet: worksheetInstance, px: number, py: number, ux: number, uy: number, origin?: object) => boolean | undefined;
         /** When the selection is changed. */
         onselection?: (worksheet: worksheetInstance, px: number, py: number, ux: number, uy: number, origin?: object) => void;
         /** Before the comments is added or updated. Return false to cancel the event, void to accept the action or a object. */
-        onbeforecomments?: (worksheet: worksheetInstance, cells: object) => boolean | object | void;
+        onbeforecomments?: (worksheet: worksheetInstance, cells: Record<string, string>) => false | Record<string, string> | undefined;
         /** After a new comment is added or updated. */
-        oncomments?: (worksheet: worksheetInstance, newValues: object, previousValues: object) => void;
+        oncomments?: (worksheet: worksheetInstance, newValues: Record<string, string>, previousValues: Record<string, string>) => void;
         /** It runs before sorting a column. It should return an array with a custom sorting or false to cancel the user action. */
-        onbeforesort?: (worksheet: worksheetInstance, column: number, direction: number, newOrderValues: []) => boolean | [] | void;
+        onbeforesort?: (worksheet: worksheetInstance, column: number, direction: number, newOrderValues: number[]) => false | number[] | undefined;
         /** When a column is sorted. */
-        onsort?: (worksheet: worksheetInstance, column: number, direction: number, newOrderValues: []) => void;
+        onsort?: (worksheet: worksheetInstance, column: number, direction: number, newOrderValues: number[]) => void;
         /** When the spreadsheet gets the focus. */
         onfocus?: (worksheet: worksheetInstance) => void;
         /** When the spreadsheet loses the focus. */
@@ -843,9 +884,9 @@ declare namespace jspreadsheet {
         /** When merge cells is executed. */
         onmerge?: (worksheet: worksheetInstance, newValue: object, oldValue: object) => void;
         /** When the header title is changed. */
-        onchangeheader?: (worksheet: worksheetInstance, column: number, newValue: string, oldValue: string) => void;
+        onchangeheader?: (worksheet: worksheetInstance, column: number, newValue: string, oldValue: string | undefined) => void;
         /** When the footers are created or updated. */
-        onchangefooter?: (worksheet: worksheetInstance, newValue: string, oldValue: string) => void;
+        onchangefooter?: (worksheet: worksheetInstance, newValue: string[][], oldValue: string[][] | undefined) => void;
         /** When the value in a cell footer is changed. */
         onchangefootervalue?: (worksheet: worksheetInstance, x: number, y: number, value: string) => void;
         /** When the footer cell is rendered */
@@ -857,19 +898,19 @@ declare namespace jspreadsheet {
         /** When an editor is created. */
         oncreateeditor?: (worksheet: worksheetInstance, cell: HTMLElement, x: number, y: number, element: HTMLElement, options: object) => void;
         /** When the editor is opened. */
-        oneditionstart?: (worksheet: worksheetInstance, cell: HTMLElement, x: number, y: number) => boolean | void;
+        oneditionstart?: (worksheet: worksheetInstance, cell: HTMLElement, x: number, y: number) => boolean | undefined;
         /** When the editor is closed. */
         oneditionend?: (worksheet: worksheetInstance, cell: HTMLElement, x: number, y: number, newValue: any, save: boolean) => void;
         /** When the style of a cell is changed. */
-        onchangestyle?: (worksheet: worksheetInstance, newValue: object, oldValue: object) => void;
+        onchangestyle?: (worksheet: worksheetInstance, newValue: Record<string, string>, oldValue: Record<string, string | null>) => void;
         /** When a cell meta information is added or updated. */
-        onchangemeta?: (worksheet: worksheetInstance, newValue: object) => void;
+        onchangemeta?: (worksheet: worksheetInstance, newValue: Record<string, any>) => void;
         /** Before the page is changed. Can cancel the action when return is false. */
-        onbeforechangepage?: (worksheet: worksheetInstance, pageNumber: number, oldPage: number, quantityPerPage: number) => boolean | void;
+        onbeforechangepage?: (worksheet: worksheetInstance, pageNumber: number, oldPage: number, quantityPerPage: number) => boolean | undefined;
         /** 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, options: object, position: number) => object;
+        onbeforecreateworksheet?: (worksheetOptions: Worksheet, position: number) => Worksheet | false | undefined;
         /** When the user creates a new worksheet. */
         oncreateworksheet?: (worksheet: worksheetInstance, worksheetOptions: Worksheet, position: number) => void;
         /** When the user renames a worksheet. */
@@ -881,81 +922,81 @@ declare namespace jspreadsheet {
         /** When the user opens a worksheet. */
         onopenworksheet?: (worksheet: worksheetInstance, index: number) => void;
         /** When there is a row id update */
-        onchangerowid?: (worksheet: worksheetInstance, rows: []) => void;
+        onchangerowid?: (worksheet: worksheetInstance, rows: any[] | Record<string, any>) => void;
         /** Before the search method starts */
         onsearchstart?: (worksheet: worksheetInstance, query: string) => void;
         /** Before the search method starts */
-        onsearchrow?: (worksheet: worksheetInstance, row: number, query: string) => boolean;
+        onsearchrow?: (worksheet: worksheetInstance, row: number, query: string, terms: RegExp) => 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;
+        onbeforesearch?: (worksheet: worksheetInstance, query: string, results: number[]) => number[] | false | undefined;
         /** After the search is applied to the rows. */
-        onsearch?: (worksheet: worksheetInstance, query: string, results: []) => void;
+        onsearch?: (worksheet: worksheetInstance, query: string, results: number[]) => void;
         /** Action to be executed before filtering rows. It can cancel the action by returning false. */
-        onbeforefilter?: (worksheet: worksheetInstance, filters: [], data: []) => void;
+        onbeforefilter?: (worksheet: worksheetInstance, filters: string[][], data: number[]) => false | number[] | undefined;
         /** After the filter has been applied to the rows. */
-        onfilter?: (worksheet: worksheetInstance, filters: [], data: []) => void;
+        onfilter?: (worksheet: worksheetInstance, filters: string[][], data: number[]) => void;
         /** When a new cell is created */
         oncreatecell?: (worksheet: worksheetInstance, cell: HTMLElement, x: number, y: number, value: any) => void;
         /** When a new row is created */
-        oncreaterow?: (worksheet: worksheetInstance, rowNumber: number, tr: HTMLElement) => void;
+        oncreaterow?: (worksheet: worksheetInstance, rowNumber: number, tr: HTMLTableRowElement) => void;
         /** When a new column is created */
         oncreatecolumn?: (worksheet: worksheetInstance, columnNumber: number, td: HTMLElement, options: Column) => void;
         /** A way to change the formula in real-time before execution */
-        onbeforeformula?: (worksheet: worksheetInstance, expression: string, x: number, y: number) => string | false | void;
+        onbeforeformula?: (worksheet: worksheetInstance, expression: string, x: number, y: number) => string | false | undefined;
         /** Get the information about the expressions executed from the formula chain */
         onformulachain?: (worksheet: worksheetInstance, expressions: Array<object>) => void;
         /** Customize the items available when filter editor is open. */
-        onopenfilter?: (worksheet: worksheetInstance, column: number, options: Array<object>) => void | Array<object>;
+        onopenfilter?: (worksheet: worksheetInstance, column: number, options: Record<string, any>[]) => Record<string, any>[] | Promise<Record<string, any>[]> | undefined;
         /** When the viewport dimension is updated. */
-        onresize?: (worksheet: worksheetInstance, w: number, h: number) => void
+        onresize?: (w: number, h: number) => void
         /** Intercept the ajax call before save. XHR ajax object */
         onbeforesend?: (worksheet: worksheetInstance, xhr: object) => void
         /** When defined names is affected */
-        onchangedefinednames?: (worksheet: object, data: []) => void
+        onchangedefinednames?: (worksheet: worksheetInstance, data: Record<string, any>[]) => void
         /** New char is entered on editor. */
-        oninput?: (worksheet: object, event: object) => void
+        oninput?: (worksheet: object, event: object, text: string) => void
         /** When change the row visibility */
-        onchangerowvisibility?: (worksheet: object, state: boolean, rows: []) => void
+        onchangerowvisibility?: (worksheet: worksheetInstance, state: boolean, rows: number[]) => void
         /** When change the column visibility */
-        onchangecolumnvisibility?: (worksheet: object, state: boolean, columns: []) => void
+        onchangecolumnvisibility?: (worksheet: worksheetInstance, state: boolean, columns: number[]) => void
         /** When a new row group is created */
-        ongrouprow?: (worksheet: object, row: number, numOfItems: number) => void
+        ongrouprow?: (worksheet: worksheetInstance, row: number, numOfItems: number) => void
         /** When open a row group */
-        onopenrowgroup?: (worksheet: object, row: number) => void
+        onopenrowgroup?: (worksheet: worksheetInstance, row: number) => void
         /** When close a row group */
-        oncloserowgroup?: (worksheet: object, row: number) => void
+        oncloserowgroup?: (worksheet: worksheetInstance, row: number) => void
         /** When a new column group is created */
-        ongroupcolumn?: (worksheet: object, column: number, numOfItems: number) => void
+        ongroupcolumn?: (worksheet: worksheetInstance, column: number, numOfItems: number) => void
         /** When open a column group */
-        onopencolumngroup?: (worksheet: object, column: number) => void
+        onopencolumngroup?: (worksheet: worksheetInstance, column: number) => void
         /** When close a column group */
-        onclosecolumngroup?: (worksheet: object, column: number) => void
+        onclosecolumngroup?: (worksheet: worksheetInstance, column: number) => void
         /** When a media object is added, removed or updated. */
-        onchangemedia?: (worksheet: object, newValue: object[], oldValue: object, affectedRecords: object[]) => void
+        onchangemedia?: (worksheet: worksheetInstance, newValue: object[], oldValue: object[], affectedRecords: object[]) => void;
         /** Before loading an image */
-        onbeforeloadimage?: (worksheet: object, img: HTMLElement, options: object) => undefined | string | boolean;
+        onbeforeloadimage?: (worksheet: worksheetInstance, img: HTMLImageElement, options: object) => undefined | string | false;
         /** Update references. When a table structure changes */
-        onchangereferences?: (worksheet: object, affected: object, deletedTokens: string[], deletedColumns: string[], deletedRows: string[]) => void;
+        onchangereferences?: (worksheet: object, affected: Record<string, any>, deletedTokens: string[], deletedColumns: number[], deletedRows: number[]) => void;
         /** When the cell is changed */
-        onchangeproperty?: (worksheet: object, records: object[]) => void;
+        onchangeproperty?: (worksheet: worksheetInstance, records: Record<string, any>[]) => void;
         /** Fire when there is a change in the config */
-        onchangeconfig?: (worksheet: object, config: string|object, spreadsheetLevel?: boolean) => void;
+        onchangeconfig?: (config: string, spreadsheetLevel?: boolean) => void;
+        /** Fire when a worksheet's visibility is changed. */
+        onchangeworksheetstate?: (spreadsheet: spreadsheetInstance, worksheetIndex: number, state: boolean) => void;
         /** General event handler */
-        onevent?: (worksheet: worksheetInstance, method: string, a?: any, b?: any, c?: any, d?: any, e?: any, f?: any) => any
+        onevent?: (worksheet: worksheetInstance, method: string, ...args: any[]) => any
+        /** Fire when a cell's metadata is reset. */
+        onresetmeta?: (worksheet: worksheetInstance, cellNames: string[] | undefined) => void;
+        /** Fire when a cell's style is reset. */
+        onresetstyle?: (worksheet: worksheetInstance, cellNames: string[]) => void;
+        /** Fire when a validation is created, changed or removed. */
+        onvalidation?: (worksheet: worksheetInstance, records: { index: number, value: Validation | null, oldValue: Validation | null }[]) => void;
         /** Return false to cancel the contextMenu event, or return custom elements for the contextmenu. */
         contextMenu?: Contextmenu | null;
-        /** The first row is the header titles when parsing a HTML table */
-        parseTableFirstRowAsHeader?: boolean;
-        /** Try to identify a column type when parsing a HTML table */
-        parseTableAutoCellType?: boolean;
-        /** Global cell wrapping. Default: false */
-        wordWrap?: boolean;
         /** About information */
-        about?: string | Function,
-        /** License string */
-        license?: string | null;
+        about?: string,
         /** Worksheets */
-        worksheets?: Array<Worksheet>;
+        worksheets?: Worksheet[];
         /** Validations */
         validations?: Validation[];
         /** Plugins */
@@ -975,14 +1016,10 @@ declare namespace jspreadsheet {
         /** International configuration */
         international?: International;
         /** Persistence handler */
-        persistence?: (method: string, args: object) => void;
-        /** Spreadsheet name */
-        name?: string;
+        persistence?: (worksheet: worksheetInstance, method: string, args: object) => void;
     }
 
     interface Worksheet {
-        /** Logo URL */
-        logo?: string
         /** Load the data from an external server URL */
         url?: string;
         /** Persistence URL or true when the URL is the same of the URL of the data source */
@@ -997,10 +1034,8 @@ declare namespace jspreadsheet {
         columns?: Array<Column>;
         /** Define the properties of a cell. This property overwrite the column definitions */
         cells?: Record<string, Cell>;
-        /** Role of this worksheet */
-        role?: string,
         /** Nested headers definition */
-        nestedHeaders?: Array<Array<Nested>> | Array<Nested>;
+        nestedHeaders?: Array<Array<Nested>>;
         /** Default column width. Default: 50px */
         defaultColWidth?: number | string;
         /** Default row height. Default: null */
@@ -1015,9 +1050,9 @@ declare namespace jspreadsheet {
         minDimensions?: [number, number];
         /** CSV data source URL */
         csv?: string;
-        /** CSV default filename for the jspreadsheet exports. Default: 'jspreadsheet' */
+        /** CSV default filename for the jspreadsheet exports. Default: worksheetName */
         csvFileName?: string;
-        /** Consider first line as header. Default: true */
+        /** Consider first line as header. Default: false */
         csvHeaders?: boolean;
         /** Delimiter to consider when dealing with the CSV data. Default: ',' */
         csvDelimiter?: string;
@@ -1045,24 +1080,22 @@ declare namespace jspreadsheet {
         allowManualInsertColumn?: boolean;
         /** Allow rows to be deleted. Default: true */
         allowDeleteRow?: boolean;
-        /** Allow all rows to be deleted. Warning: no rows left can lead to undesirabled behavior. Default: false */
-        allowDeletingAllRows?: boolean;
         /** Allow columns to be deleted. Default: true */
         allowDeleteColumn?: boolean;
         /** Allow rename column. Default: true */
         allowRenameColumn?: boolean;
-        /** Allow users to add comments to the cells. Default: false */
+        /** Allow users to add comments to the cells. Default: true */
         allowComments?: boolean;
         /** Corner selection and corner data cloning. Default: true */
         fillHandle?: boolean;
         /** Merged cells. Default: null */
-        mergeCells?: Record<string, any[]>;
+        mergeCells?: Record<string, [number, number]>;
         /** Allow search on the spreadsheet */
         search?: boolean;
         /** Activate pagination and defines the number of records per page. Default: false */
-        pagination?: number | boolean;
+        pagination?: number;
         /** Dropdown for the user to change the number of records per page. Example: [10,25,50,100]. Default: false */
-        paginationOptions?: boolean | Array<number>;
+        paginationOptions?: Array<number>;
         /** Text Overflow. Default: false */
         textOverflow?: boolean;
         /** Table overflow. Default: false */
@@ -1089,8 +1122,6 @@ declare namespace jspreadsheet {
         freezeColumnControl?: boolean,
         /** Enable freeze row manual control. Default: false */
         freezeRowControl?: boolean,
-        /** Deprecated. Call orderBy inside onload. */
-        orderBy?: [number, boolean];
         /** Worksheet Unique Id. */
         worksheetId?: string;
         /** Worksheet Name. */
@@ -1100,11 +1131,9 @@ declare namespace jspreadsheet {
         /** Enable the column filters */
         filters?: boolean | string;
         /** Footers */
-        footers?: Array<any>;
+        footers?: any[][];
         /** Apply mask on footers. Default: true */
         applyMaskOnFooters?: boolean;
-        /** Define options for the plugins. Each key should be the pluginName. */
-        pluginOptions?: Record<string, any>;
         /** This is a internal controller for the spreadsheet locked properties. Please use editable to make it readonly. */
         locked?: boolean;
         /** Allow the selection of unlocked cells. Default: true. */
@@ -1113,8 +1142,6 @@ declare namespace jspreadsheet {
         selectLockedCells?: boolean;
         /** Enable resizable worksheet in on or both direction (horizontal | vertical | both). Default: none */
         resize?: 'horizontal' | 'vertical' | 'both' | 'none' | undefined;
-        /** Wrap. Default: false */
-        wrap?: boolean;
         /** Show the worksheet gridlines. Default: true */
         gridline?: boolean;
         /** Floating images or charts. */
@@ -1127,15 +1154,19 @@ declare namespace jspreadsheet {
         autoNames?: boolean;
     }
 
+    interface SpreadsheetHTMLElement extends HTMLDivElement {
+        spreadsheet: spreadsheetInstance;
+    }
+
     interface spreadsheetInstance {
         /** Spreadsheet configuration */
         config: Spreadsheet;
         /** Contextmenu HTMLElement */
         contextmenu: HTMLElement;
         /** DOM Element */
-        el: HTMLElement;
+        el: SpreadsheetHTMLElement;
         /** DOM Element. Alias for el */
-        element: HTMLElement;
+        element: SpreadsheetHTMLElement;
         /** DOM Element container for the filters */
         filter: HTMLElement;
         /** Toggle the full screen mode */
@@ -1154,16 +1185,8 @@ declare namespace jspreadsheet {
         name: string;
         /** List of plugins loaded to the spreadsheet */
         plugins: Record<string, Plugin>;
-        /** Processing flag. It would be true when the spreadsheet is loading. */
-        processing: boolean;
         /** Show progressbar */
         progress: (state: boolean) => void;
-        /** Queue of formulas used during the loading */
-        queue: Map<object, object>;
-        /** Undo */
-        undo: () => void;
-        /** Redo */
-        redo: () => void;
         /** DOM Textarea helper */
         textarea: HTMLElement;
         /** DOM toolbar */
@@ -1171,58 +1194,73 @@ declare namespace jspreadsheet {
         /** Tools HTMLElement container */
         tools: HTMLElement;
         /** Worksheets container */
-        worksheets: Array<Worksheet>;
+        worksheets: Array<worksheetInstance>;
         /** Load plugins into the spreadsheet */
         setPlugins: (plugins: Record<string, Function>) => void;
         /** Internal method: event dispatch controllers. */
-        dispatch: (...args: string[]) => void;
+        dispatch: (event: string, ...args: any[]) => any;
         /** Get the spreadsheet configuration */
         getConfig: () => Spreadsheet;
         /** Get the worksheet index by instance or worksheetId */
-        getWorksheet: (worksheetIdent: worksheetInstance|string, instance?: boolean) => number;
+        getWorksheet(worksheetIdent: worksheetInstance): number | false;
+        getWorksheet(worksheetIdent: string, instance?: boolean): worksheetInstance | number | false;
         /** Get the worksheet name */
-        getWorksheetName: (position: number) => string;
+        getWorksheetName: (position: number) => string | undefined;
         /** Get the worksheet instance by its name */
-        getWorksheetInstanceByName: (worksheetName: string, namespace?: string) => worksheetInstance;
+        getWorksheetInstanceByName: GetWorksheetInstanceByNameFunction;
         /** Open a worksheet */
-        openWorksheet: (position: number) => void;
+        openWorksheet: (position: number, force?: boolean) => void;
         /** Create a new worksheet */
-        createWorksheet: (worksheetOptions: Worksheet, position?: Number) => worksheetInstance;
+        createWorksheet: (worksheetOptions: Worksheet, position?: number) => worksheetInstance | false;
         /** Delete an existing worksheet by its position */
-        deleteWorksheet: (position: number) => void;
+        deleteWorksheet: (position: number) => false | undefined;
         /** Rename an existing worksheet by its position */
-        renameWorksheet: (position: number, title: string) => void;
+        renameWorksheet: (position: number, title: string) => false | undefined;
         /** Move the position of a worksheet. ignoreDomUpdates: true will block updates to the DOM */
-        moveWorksheet: (from: number, to: number, ignoreDomUpdates?: boolean) => void;
+        moveWorksheet: (from: number, to: number, ignoreDomUpdates?: boolean) => false | undefined;
         /** Get the active worksheet when applicable */
         getWorksheetActive: () => number;
-        /** Get the worksheet instance by its position */
-        getWorksheetInstance: (position: number) => worksheetInstance;
         /** Parse the toolbar definitions with defaults */
-        getToolbar: (toolbar: Toolbar) => object,
+        getToolbar: (toolbar?: Toolbar | ToolbarItem[] | Function) => object,
         /** Set the toolbar */
-        setToolbar: (toolbar: Toolbar) => void;
+        setToolbar: (toolbar: Toolbar | ToolbarItem[] | Function) => void;
         /** Show the toolbar */
         showToolbar: () => void;
         /** Hide the toolbar */
         hideToolbar: () => void;
         /** Refresh the toolbar based on the current worksheet */
-        refreshToolbar: () => void;
-        /** Internal validations cache */
-        validations: () => void;
+        refreshToolbar: (worksheet?: worksheetInstance) => void;
+        /** Set a worksheet state visibility */
+        setWorksheetState: (worksheetIndex: number, state: boolean) => void;
+        /** Change the spreadsheet settings */
+        setConfig: (config: Spreadsheet) => void;
         /** Destroy the spreadsheet */
-        destroy: () => void;
+        destroy: (spreadsheet?: spreadsheetInstance | SpreadsheetHTMLElement, destroyEventHandlers?: boolean) => void;
+    }
+
+    interface CustomArray<T> extends Array<T> {
+        [key: string]: any;
     }
 
+    interface ColumnInstance extends Column {
+        x: number;
+        colElement: HTMLTableColElement;
+        element: HTMLTableCellElement
+    }
+
+    type DeleteMediaItem = string | { id: string, [key: string]: any };
+
+    type SetValueFirstArgument = string | { x: number, y: number, value: any, force?: boolean }[];
+
     interface worksheetInstance {
         /** Array with the borders information */
-        borders: Border[] | Border;
+        borders: CustomArray<Border>;
         /** Close the edition for one cell */
         closeEditor: (cell: HTMLElement|null, save: boolean) => void;
         /** Close the filters */
-        closeFilters: (update: boolean) => void;
-        /** Array with the HTML element references that define the columns */
-        colgroup: HTMLElement[];
+        closeFilter: (update: boolean) => void;
+        /** Column settings */
+        cols: ColumnInstance;
         /** Hold the colgroup container */
         colgroupContainer: HTMLElement;
         /** DOM Worksheet container */
@@ -1236,157 +1274,147 @@ declare namespace jspreadsheet {
         /** Cut */
         cut: () => void;
         /** Alias to getData */
-        data: (highlighted?: boolean, processed?: boolean, delimiter?: string, asJson?: boolean, includeFilteredRows?: boolean) => Array<Array<any>> | Array<Record<string, any>> | string | null;
+        data: (highlighted?: boolean | RangeCoords, processed?: boolean, delimiter?: string, asJson?: boolean, includeFilteredRows?: boolean) => Array<Array<any>> | Array<Record<string, any>> | string;
         /** Internal use control type to defined JSON (1) or ARRAY (0). */
         dataType: number,
         /** Delete one more columns */
-        deleteColumn: (columnNumber: number|number[], numOfColumns?: number) => void;
+        deleteColumn(columnNumber: number[]): false | undefined;
+        deleteColumn(columnNumber: number, numOfColumns?: number): false | undefined;
         /** Delete an existing row or rows */
-        deleteRow: (rowNumber: number|number[], numOfRows?: number) => void;
+        deleteRow(rowNumber: number[]): false | undefined;
+        deleteRow(rowNumber: number, numOfRows?: number): false | undefined;
         /** Destroy all merged cells */
-        destroyMerged: () => void;
-        /** Legacy alias destroyMerged */
         destroyMerge: () => void;
         /** Internal method: event dispatch controllers. */
-        dispatch: (...args: string[]) => void;
+        dispatch: (event: string, ...args: any[]) => any;
         /** Navigation down */
         down: (shiftKey?: boolean, ctrlKey?: boolean, jump?: boolean) => void;
         /** If extension render exists, execute render extension else download CSV */
-        download: (includeHeaders?: boolean, processed?: boolean, csv?: boolean) => void;
+        download: (includeHeaders?: boolean, processed?: boolean, csv?: boolean) => false | string | undefined;
         /** Download CSV */
-        downloadCSV: (includeHeaders?: boolean, processed?: boolean) => void;
-        /** Edition controllers */
-        edition?: [];
-        /** DOM Worksheet. Alias for worksheet */
+        downloadCSV: (includeHeaders?: boolean, processed?: boolean) => false | string | undefined;
+        /** DOM Worksheet. */
         element: HTMLElement;
         /** Internal method: Execute a formula. */
-        executeFormula: (expression: string, x?: number, y?: number, caching?: boolean, basic?: boolean) => void;
+        executeFormula: (expression: string, x?: number, y?: number, caching?: boolean, basic?: boolean) => any;
         /** Navigation first */
         first: (shiftKey?: boolean, ctrlKey?: boolean) => void;
         /** Internal footer controllers */
-        footers: Record<string, string>;
-        /** Toggle the fullscreen mode */
-        fullscreen: (state: boolean) => void;
+        footers: Record<string, any>;
         /** Get the border */
         getBorder: (alias: string) => object;
         /** Get the cell element from the cellName or via its coordinates x,y */
-        getCell: (cellNameOrColumnNumber: string|number, y?: number) => HTMLElement | null;
+        getCell(cellName: string): HTMLElement;
+        getCell(columnNumber: number, y: number): HTMLElement;
         /** Alias to getCell */
-        getCellFromCoords: (x: number, y: number) => HTMLElement | null;
+        getCellFromCoords(cellName: string): HTMLElement;
+        getCellFromCoords(columnNumber: number, y: number): HTMLElement;
         /** Get attributes from one cell when applicable */
-        getCells: (cellName: string) => Column;
+        getCells: (cellName?: string) => Cell | Record<string, Cell> | undefined;
         /** Get the column object by its position */
-        getColumn: (position: number) => Column;
+        getColumn(): Column[];
+        getColumn(position: number): ColumnInstance | undefined;
         /** Get the column data from its number */
-        getColumnData: (col: number, processed?: boolean) => Array<any>;
+        getColumnData: (col: number, processed?: boolean) => false | Array<any>;
         /** Get the column position by its name */
-        getColumnIdByName: (name: string) => number;
+        getColumnIdByName: (name: string) => number | false;
         /** Alias for getProperties */
-        getColumnOptions: (x: number, y?: number) => Column;
+        getColumnOptions: (x: number, y?: number) => Cell | ColumnInstance | undefined;
         /** Get the comments from one cell or multiple cells. Example: getComments('A1') */
-        getComments: (cellName?: string) => string | object;
+        getComments: (cellName?: string) => string | Comment[] | Record<string, string | Comment[]> | undefined;
         /** Get the cached values from one cell or multiple cells. Example: getCache('A1') */
-        getCache: (cellName?: string) => string | object;
+        getCache: (cellName?: string) => false | string | object;
         /** Get the worksheet settings */
         getConfig: () => Worksheet;
-        /**
-         * Get the worksheet data
-         *
-         * @param {boolean} only the selected cells
-         * @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|string|null} array or string
-         */
-        getData: (highlighted?: boolean, processed?: boolean, delimiter?: string, asJson?: boolean, includeFilteredRows?: boolean) => Array<Array<any>> | Array<Record<string, any>> | string | null;
+        /** Get the worksheet data */
+        getData: (highlighted?: boolean | RangeCoords, processed?: boolean, delimiter?: string, asJson?: boolean, includeFilteredRows?: boolean) => Array<Array<any>> | Array<Record<string, any>> | string;
         /** Get the worksheet data from a range */
         getDataFromRange: (range: string, processed?: 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;
+        getDefinedNames: (key?: string) => any;
         /** Internal method: Get the editor for one cell */
-        getEditor: (x: number, y: number) => Column;
+        getEditor: (x: number, y: number) => [Editor, Cell | Column];
         /** Internal method: Get the filter */
-        getFilter: (column: number, getAsSets?: boolean) => Array<any>;
+        getFilter: (column: number, getAsSets?: boolean) => string[] | string[][] | Set<string> | Set<string>[] | undefined;
         /** Get the footers configuration */
-        getFooter: () => Array<any>;
+        getFooter: () => Array<any> | undefined;
         /** Get the footer value */
         getFooterValue: (x: number, y: number) => any;
         /** Get the header title */
         getHeader: (columnNumber: number) => string;
         /** Get all header elements */
-        getHeaders: (asArray: boolean) => Array<any>;
+        getHeaders: (asArray: boolean) => string | string[];
         /** Get the height of one row by its position when height is defined. */
         getHeight: (row?: number) => Array<number> | number;
         /** Bring an array of selection coordinates [x1,y1,x2,y2][]. */
-        getHighlighted: () => null | number[][];
+        getHighlighted: () => RangeCoords[];
         /** Get the data as JSON. */
-        getJson: (h?: boolean, processed?: boolean, delimiter?: boolean, asJson?: boolean) => any;
+        getJson: (highlighted?: boolean | RangeCoords, processed?: boolean, delimiter?: string, asJson?: boolean, includeFilteredRows?: boolean) => Array<Array<any>> | Array<Record<string, any>> | string;
         /** Get the processed data cell shown to the user by the cell name or coordinates. */
-        getLabel: (cellNameOrColumnNumber: string|number, y?: number, extended?: boolean) => string;
+        getLabel: (cellNameOrColumnNumber: string|number, y?: number, extended?: boolean) => any;
         /** Aliases for getLabel */
-        getLabelFromCoords: (cellNameOrColumnNumber: string|number, y?: number, extended?: boolean) => string;
+        getLabelFromCoords: (cellNameOrColumnNumber: string|number, y?: number, extended?: boolean) => any;
         /** Get the merged cells. Cell name: A1, A2, etc or null for all cells */
-        getMerge: (cellName?: string) => object | Array<number>;
+        getMerge: (cellName?: string) => [number, number] | Record<string, [number, number]> | undefined;
         /** Get one or all meta information for one cell. */
-        getMeta: (cellName: string, property: string) => object;
+        getMeta: (cellName: string, property: string) => object | undefined;
         /** Get the nested cells */
-        getNestedCell: (x: number, y: number, properties?: any) => object;
+        getNestedCell: (x: number, y: number) => HTMLTableCellElement;
         /** Get the nested headers */
-        getNestedHeaders: () => [];
+        getNestedHeaders: () => Nested[][] | undefined;
         /** Get the next available number in the sequence */
-        getNextSequence: () => number;
+        getNextSequence: () => number | null;
         /** Alias to getProperty */
-        getOptions: (x: number, y?: number) => Column;
+        getOptions: (x: number, y?: number) => Cell | ColumnInstance | undefined;
         /** Get the primaryKey column when applicable. */
-        getPrimaryKey: () => number;
+        getPrimaryKey: () => number | false;
         /** Get processed data by the coordinates of the cell. Extended process a color, progressbar and rating as raw. */
         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;
+        getProperties: (x: number, y?: number) => Cell | ColumnInstance | undefined;
         /** Deprecated. Legacy alias to getProperties */
-        getProperty: (x: number, y?: number) => Column;
+        getProperty: (x: number, y?: number) => Cell | ColumnInstance | undefined;
         /** Get the selection in a range format */
-        getRange: () => string;
+        getRange: (coords?: RangeCoords, includeName?: boolean) => string;
         /** Get a row data or meta information by Id. */
-        getRowById: (row: number, element: boolean) => Row;
+        getRowById: (row: number, element?: boolean) => RowInstance | false | any[][] | Record<string, any>[];
         /** Get the data from one row */
-        getRowData: (row: number, processed: boolean) => any[];
+        getRowData: (row: number, processed?: boolean) => any[] | Record<string, any> | undefined;
         /** Get the row id from its position */
-        getRowId: (row: number) => number;
+        getRowId: (row: number, primaryKey?: boolean) => any;
         /**
          * Get the selected cells
          * @param {boolean?} columnNameOnly - Return an array of cell names or cell DOM elements
          */
-        getSelected: (columnNameOnly?: boolean) => any[];
+        getSelected: (columnNameOnly?: boolean) => string[] | { x: number, y: number }[];
         /** Get the coordinates of the main selection */
-        getSelection: (preserveOrder?: boolean) => null | Array<number>;
+        getSelection: (preserveOrder?: boolean) => RangeCoords | undefined;
         /** Get the selected columns indexes */
         getSelectedColumns: (visibleOnly?: boolean) => number[];
         /** Get the selected rows indexes. */
         getSelectedRows: (visibleOnly?: boolean) => number[];
 
         /** Get the style from a cell or all cells. getStyle() or getStyle('A1') */
-        getStyle: (cellName?: string|null, onlyIndexes?: boolean) => string|object;
+        getStyle: (cellName?: string | null, onlyIndexes?: boolean) => string | number | Record<string, string> | Record<string, number> | undefined;
         /** Get the style index from a cell or all cells */
-        getStyleIndexes: (cellName?: string|null) => number|object;
+        getStyleIndexes: (cellName?: string | null) => number | Record<string, number> | undefined;
         /** Find a style ID from a style string. Null when no styleId is found */
-        getStyleId: (styleString?: string) => number|null;
+        getStyleId: (styleString?: string) => number | null;
         /** Get value by the cell name or object. The value can be the raw or processed value. */
-        getValue: (cell: string, processed: boolean) => string;
+        getValue(cell: string, processed?: boolean): Array<Array<any>> | Array<Record<string, any>> | string;
+        getValue(cell: { x: number, y: number }, processed?: boolean): any;
         /** Get value by the coordinates. The value can be the source or processed value, including not formatted proceed data. */
         getValueFromCoords: (x: number, y: number, processed?: boolean, raw?: boolean) => any;
         /** Get the width of one column by index or all column width as an array when index is null. */
         getWidth: (x?: number) => Array<number> | number;
         /** Go to the row number, [col number] */
-        goto: (y: number, x?: number) => void;
+        goto: (y?: number | null, x?: number | null) => void;
         /** Hold the header container */
         headerContainer: HTMLElement;
-        /** Array with the header DOM elements */
-        headers: Array<HTMLElement>;
         /** Hide column */
         hideColumn: (column: number|number[]) => void;
         /** Hide the filters for column, columns or cell range. */
-        hideFilter: (colNumber?: number) => void;
+        hideFilter: (colNumber?: number | string) => void;
         /** Hide index column */
         hideIndex: () => void;
         /** Hide row */
@@ -1395,63 +1423,76 @@ declare namespace jspreadsheet {
         hideSearch: () => void;
         /**
          * Add new column(s)
-         * @param {number|object[]} column - number of columns or array with column information
-         * @param {number?} columnNumber - reference when the first argument is a number
-         * @param {boolean?} insertBefore - insertBefore when the first argument is a number
-         * @param {object?} properties - column properties
-         * @param {any?} data
-         * @param {boolean?} createSelection
+         * @param column - number of columns or array with column information
+         * @param columnNumber - reference when the first argument is a number
+         * @param insertBefore - insertBefore when the first argument is a number
+         * @param properties - column properties
+         * @param data
+         * @param createSelection
          */
-        insertColumn: (column?: number | newColumn[], columnNumber?: number, insertBefore?: boolean, properties?: Column[], data?: any, createSelection?: boolean) => void;
+        insertColumn: (column?: number | newColumn[], columnNumber?: number, insertBefore?: boolean, properties?: Column[], data?: any, createSelection?: boolean) => false | undefined;
         /**
          * Add new row(s)
-         * @param {number|object[]} row - number of rows or array with row information
-         * @param {number?} rowNumber - reference when the first argument is a number
-         * @param {boolean?} insertBefore - insertBefore when the first argument is a number
-         * @param {any?} data
-         * @param {boolean?} createSelection
+         * @param row - number of rows or array with row information
+         * @param rowNumber - reference when the first argument is a number
+         * @param insertBefore - insertBefore when the first argument is a number
+         * @param data
+         * @param createSelection
          */
-        insertRow: (row?: number | newRow[], rowNumber?: number, insertBefore?: boolean, data?: any, createSelection?: boolean) => void;
+        insertRow: (row?: number | newRow[], rowNumber?: number, insertBefore?: boolean, data?: any, createSelection?: boolean) => false | undefined;
         /** Check if cell is attached to the DOM */
         isAttached: (x: number, y: number) => boolean;
         /** The worksheet is editable */
         isEditable: () => boolean;
+        /** Check if the cell is merged */
+        isMerged: (x: number, y: number) => Records | false;
         /** Check if cell is readonly or not by cellName or Coordinates. isReadonly('A1') or isReadonly(x, y) */
-        isReadOnly: (cellNameOrX: string|number, y?: number) => boolean;
+        isReadOnly(cellNameOrX: string, y?: undefined, ignoreLocked?: boolean): boolean | null;
+        isReadOnly(cellNameOrX: number, y: number, ignoreLocked?: boolean): boolean | null;
+        /** Check if the row is merged */
+        isRowMerged: (row: number) => Records | undefined;
         /** Verify if this coordinates is within a selection or blank for the current selection */
-        isSelected: (x: number, y: number, selection?: number[]) => boolean;
+        isSelected: (x: number, y: number, selection?: RangeCoords) => boolean;
         /** Navigation last */
         last: (shiftKey?: boolean, ctrlKey?: boolean) => void;
         /** Navigation left */
         left: (shiftKey?: boolean, ctrlKey?: boolean, jump?: boolean) => void;
         /** Change the data without events */
         loadData: (data: any[], adjustDimension?: boolean) => void;
+        /** HTML element that contains the floating media */
+        media: HTMLDivElement;
         /** Move one or more columns to another position */
-        moveColumn: (col: number, to: number, quantityOfColumns?: number) => void;
+        moveColumn: (col: number, to: number, quantityOfColumns?: number) => false | undefined;
         /** Move one or more rows to another position  */
-        moveRow: (row: number, to: number, quantityOfRows?: number) => void;
+        moveRow: (row: number, to: number, quantityOfRows?: number) => false | undefined;
         /** Get the column name */
-        name: (col: number) => string;
+        name: (col: number) => string | number;
         /** Start the edition for one cell */
-        openEditor: (cell: HTMLElement, empty?: boolean, mouseEvent?: object) => void;
+        openEditor: (cell: HTMLElement, empty?: boolean, mouseEvent?: object) => false | undefined;
         /** Open the filters */
         openFilter: (column: number) => void;
         /** Worksheet configuration */
         options: Worksheet;
         /** Sort one column by its position. ASC (0) or DESC (1) */
-        orderBy: (column: number, direction: boolean, internalValueController?: any[], internalPreviousStateController?: boolean) => void;
+        orderBy: (column: number, direction?: boolean, internalValueController?: number[], internalPreviousStateController?: any) => void;
         /** Change page when using pagination */
-        page: (pageNumber: number, callBack?: Function) => void;
+        page: (pageNumber: number | null, callBack?: Function) => false | undefined;
+
+        pageDown: () => void;
         /** Current page number */
         pageNumber: number;
+
+        pageUp: () => void;
         /** Pagination DOM container */
         pagination: HTMLElement;
         /** Spreadsheet object */
         parent: spreadsheetInstance;
         /** Paste */
-        paste: (x: number, y: number, data: string | any[]) => void;
+        paste: (x: number, y: number, data: string | any[], selections?: boolean) => false | undefined;
+
+        print: () => void;
         /** Get the quantity of pages when pagination is active */
-        quantityOfPages?: () => number;
+        quantityOfPages?: () => number | false;
         /** Array container for all cell DOM elements */
         records: Records[][];
         /** Refresh the borders by the border name */
@@ -1459,9 +1500,9 @@ declare namespace jspreadsheet {
         /** Refresh footers */
         refreshFooter: () => void;
         /** Remove the merged cells by the cell name or a object with all cells to be removed. */
-        removeMerge: (cellName: string | object) => void;
+        removeMerge: (cellName: string | Record<string, any>) => false | undefined;
         /** Reset the borders by name border name */
-        resetBorders: (border: string, resetPosition: boolean) => void;
+        resetBorders: (border?: string, resetPosition?: boolean) => void;
         /** Reset the filter of one or all columns */
         resetFilters: (colNumber?: number, destroy?: boolean) => void;
         /** Destroy the footers */
@@ -1469,15 +1510,15 @@ declare namespace jspreadsheet {
         /** Destroy freeze columns */
         resetFreezeColumns: () => void;
         /** Reset meta data of one or multiple cells. Null for all cells */
-        resetMeta: (cellName?: string[]|string) => void;
+        resetMeta: (cellName?: string[]|string) => false | undefined;
         /** Reset nested headers */
         resetNestedHeaders: () => void;
         /** Reset the search */
         resetSearch: () => void;
         /** Reset the main selection */
-        resetSelection: () => void;
+        resetSelection: () => boolean;
         /** Get the style from one cell. Ex. resetStyle('A1') or resetStyle(['A1']) */
-        resetStyle: (cell?: string|string[]) => void;
+        resetStyle: (cell?: string|string[]) => false | undefined;
         /** DOM array of results */
         results: Array<number> | null;
         /** Navigation right */
@@ -1488,12 +1529,8 @@ declare namespace jspreadsheet {
         rows: RowInstance[] | Record<number, 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 */
-        scrollX: HTMLElement;
-        /** ScrollY DOM Element */
-        scrollY: HTMLElement;
         /** Search for something */
-        search: (str: string) => void;
+        search: (str: string) => false | undefined;
         /** Search HTML container */
         searchContainer: HTMLElement;
         /** Search HTML input */
@@ -1501,88 +1538,99 @@ declare namespace jspreadsheet {
         /** Select All */
         selectAll: () => void;
         /** Selected cells */
-        selectedCell: any[];
+        selectedCell: RangeCoords | null;
         /** Internal record id sequence */
         sequence: number;
         /** Set borders with a border name and color. */
         setBorder: (x1: number, y1: number, x2: number, y2: number, border?: string, color?: string) => void;
         /** Set attributes for one cell */
-        setCells: (cellName: string, settings: Column) => void;
+        setCells(cellName: Record<string, Cell>): false | undefined;
+        setCells(cellName: string, settings: Cell): false | undefined;
         /** Set the column data from its number */
         setColumnData: (col: number, data: any[], force?: boolean) => void;
         /** Set the comments for one or multiple cells */
-        setComments: (cellName: string | Record<string, string>, comments?: string) => void;
+        setComments(cellName: Record<string, string>): false | undefined;
+        setComments(cellName: string, comments: string): false | undefined;
         /** Set the cache for one or multiple cells */
-        setCache: (cellName: string | Record<string, string>, values?: string) => void;
+        setCache(cellName: Record<string, any>): false | undefined;
+        setCache(cellName: string, values?: any): false | undefined;
         /** Change the worksheet settings */
-        setConfig: (config: Worksheet) => void;
+        setConfig: (config: Worksheet | Spreadsheet, spreadsheetLevel?: boolean) => void;
         /** Set the worksheet data */
         setData: (data: any[]) => void;
         /** Create or update names */
-        setDefinedNames: (names: DefinedNames[]) => void;
+        setDefinedNames: (names: DefinedNames | DefinedNames[]) => void;
         /** Reset names by indexes */
         resetDefinedNames: (names: DefinedNames[]) => void;
         /** Set filter */
-        setFilter: (colNumber: number, keywords: any[]) => void;
+        setFilter: (colNumber: number, keywords?: string[]) => void;
         /** Set the footers */
-        setFooter: (data: []) => void;
+        setFooter: (data: any[][]) => void;
         /** Set the footer value */
         setFooterValue: (col: number, row: number, value: any) => void;
         /** List of columns to freeze. Should be a number or an array of consecutive numbers. Example: [4,5,6] */
-        setFreezeColumns: (num: number|number[]) => void;
+        setFreezeColumns: (num?: number | number[] | null) => void;
         /** Set the header title. Empty or null to reset to the default header value. */
-        setHeader: (x: number, title?: string) => void;
+        setHeader: (x: number, title?: string) => false | undefined;
         /** 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;
+        setMerge(cellName: Record<string, [number, number]>): false | undefined;
+        setMerge(cellName: string, colspan: number, rowspan: number): false | undefined;
         /** Get one or various meta information for one cell. */
-        setMeta: (cell: string | object, property?: string, value?: string) => void;
+        setMeta: (cell: string | Record<string, any>, property?: string, value?: string) => false | undefined;
         /** Set the nested headers */
-        setNestedHeaders: (config: any[]) => void;
+        setNestedHeaders: (config: Nested[][]) => void;
         /** Deprecated. Alias for parent.setPlugins */
         setPlugins: (plugins: Record<string, Function>) => void;
         /** Alias for setProperty */
-        setProperties: (columnNumber: number, rowNumberOrColumnSettings: number|Column, cellSettings?: Cell) => void;
+        setProperties(columnNumber: number, rowNumber: number, cellSettings?: Cell): boolean;
+        setProperties(columnNumber: number, columnSettings: Column): boolean;
+        setProperties(changes: ({ x: number, value: Column } | { x: number, y: number, value: Cell })[]): boolean;
+        setProperties(changes: Record<string, Cell>): boolean;
         /** Add a new configuration settings for a column or cell */
-        setProperty: (columnNumber: number, rowNumberOrColumnSettings: number|Column, cellSettings?: Cell) => void;
+        setProperty(columnNumber: number, rowNumber: number, cellSettings?: Cell): boolean;
+        setProperty(columnNumber: number, columnSettings: Column): boolean;
+        setProperty(changes: ({ x: number, value: Column } | { x: number, y: number, value: Cell })[]): boolean;
+        setProperty(changes: Record<string, Cell>): boolean;
         /** Add new properties to the existing column or cell settings */
-        updateProperty: (columnNumber: number, rowNumberOrColumnSettings: number|Column, cellSettings?: Cell) => void;
+        updateProperty(columnNumber: number, rowNumber: number, cellSettings?: Cell, ignoreDOM?: boolean): void;
+        updateProperty(columnNumber: ({ x: number, value: Column } | { x: number, y: number, value: Cell })[], rowNumber?: undefined, cellSettings?: undefined, ignoreDOM?: boolean): void;
         /** Set or reset the cell as readonly */
         setReadOnly: (cellName: string|HTMLElement, state: boolean) => void;
         /** Set the data from one row */
-        setRowData: (row: number, data: any[], force: boolean) => void;
+        setRowData: (row: number, data: any[], force?: boolean) => void;
         /** Set the row id from its position */
-        setRowId: (row: number, newId: number) => void;
+        setRowId(row: Record<number, number>): void;
+        setRowId(row: number, newId: number): void;
         /** Set the style for one cell. Ex. setStyle('A1', 'background-color', 'red') */
-        setStyle: (cell: string | object, property?: string, value?: string, forceOverwrite?: boolean) => void;
+        setStyle(cell: string | string[] | { x: number, y: number }[], property: string, value?: string, forceOverwrite?: boolean): false | undefined;
+        setStyle(cell: Record<string, string>, property?: undefined, value?: undefined, forceOverwrite?: boolean): false | undefined;
         /**
          * Set a cell value
          *
-         * @param {string|string[]|object} cell destination cell
-         * @param {string|number} value
-         * @param {boolean} force value over readonly cells
-         * @return void
+         * @param cell destination cell
+         * @param value
+         * @param force value over readonly cells
          */
-        setValue: (cell: string|string[]|object, value?: string|number, forceOverwrite?: boolean) => void;
+        setValue: (cell: SetValueFirstArgument, value?: any, forceOverwrite?: boolean, origin?: string) => false | undefined;
         /**
          * Set a cell value
          *
-         * @param {number} x
-         * @param {number} y
-         * @param {string|number} value value
-         * @param {boolean} force value over readonly cells
-         * @return void
+         * @param x
+         * @param y
+         * @param value value
+         * @param force value over readonly cells
          */
-        setValueFromCoords: (x: number, y: number, value: string|number, force?: boolean) => void;
+        setValueFromCoords: (x: number, y: number, value: any, 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|number[], width: number|number[]) => void;
+        setWidth: (col: number | number[], width: number | number[], oldWidth?: number | number[]) => void;
         /** Show column */
         showColumn: (column: number|number[]) => void;
         /** Show filter controls for one column, all columns or a cell range */
-        showFilter: (columnOrCellRange?: number|string) => void;
+        showFilter: (columnOrCellRange?: number | string | null) => void;
         /** Show index column */
         showIndex: () => void;
         /** Show row */
@@ -1602,25 +1650,24 @@ declare namespace jspreadsheet {
         /**
          * Internal method: Internal method: Set a cell value
          *
-         * @param {number} x
-         * @param {number} y
-         * @param {string} value value
-         * @param {string} force value over readonly cells
-         * @return void
+         * @param x
+         * @param y
+         * @param value value
+         * @param force value over readonly cells
          */
-        updateCell: (x: number, y: number, value: string, force?: boolean) => void;
+        updateCell: (x: number, y: number, value: any, force?: boolean) => void;
         /** Internal method: update cells in a batch */
-        updateCells: (o: Array<Record<string, object>>) => void;
+        updateCells: (o: Record<string, any>[]) => void;
         /** Update the selection based on coordinates */
-        updateSelectionFromCoords: (x1: number, y1: number, x2?: number, y2?: number, origin?: boolean, type?: string, color?: string) => void;
+        updateSelectionFromCoords: (x1: number | number, y1: number | number, x2?: number | number, y2?: number | number, origin?: boolean, type?: string, color?: string) => void;
         /** Getter/setter the value by coordinates */
-        value?: (x: number, y: number, value?: any) => void;
+        value?: (x: number | string, y: number, value?: any, removeProperty?: boolean) => any;
         /** Current page or which page the row number is */
-        whichPage?: (row?: number) => number;
+        whichPage?: (row?: number) => number | false | null;
         /** Get all group of rows */
-        getRowGroup: () => object;
+        getRowGroup: () => Record<number, { group: number, state: boolean }>;
         /** Create a new group of rows */
-        setRowGroup: (row: number, numOfItems?: number) => void;
+        setRowGroup: (row: number, numOfItems?: number, state?: boolean, ignoreHistory?: boolean) => void;
         /** Open a new group of rows */
         openRowGroup: (row: number) => void;
         /** Close a new group of rows */
@@ -1628,17 +1675,15 @@ declare namespace jspreadsheet {
         /** Reset a group of rows */
         resetRowGroup: (row: number) => void;
         /** Get all group of columns */
-        getColumnGroup: () => object;
+        getColumnGroup: () => Record<number, { group: number, state: boolean }>;
         /** Create a new group of columns */
-        setColumnGroup: (column: number, numOfItems?: number) => void;
+        setColumnGroup: (column: number, numOfItems?: number, state?: boolean, ignoreHistory?: boolean) => void;
         /** Open a new group of columns */
         openColumnGroup: (column: number) => void;
         /** Close a new group of columns */
         closeColumnGroup: (column: number) => void;
         /** Reset a group of columns */
         resetColumnGroup: (column: 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;
         /** Internal persistence handler */
@@ -1647,8 +1692,6 @@ declare namespace jspreadsheet {
         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 */
@@ -1658,31 +1701,38 @@ declare namespace jspreadsheet {
         /** Viewport current width */
         height?: number;
         /** Get the row object or get the rows configuration when pass null. */
-        getRow: (row?: number) => RowInstance;
-        /** Internal worksheet onload method */
-        onload?: () => void;
+        getRow: (row?: number) => Row[] | RowInstance;
         /** Internal nested headers DOM container */
         nested?: object;
         /** List of rows to freeze. Should be a number or an array of consecutive numbers. Example: [4,5,6] */
-        setFreezeRows: (numberOfRows: number|number[]) => void;
+        setFreezeRows: (numberOfRows?: number | number[] | null) => void;
         /** Reset the freeze rows */
         resetFreezeRows: () => void;
         /** Reset the properties of a cell */
-        resetProperty: (x: number, y: number) => void;
+        resetProperty: (x: number, y: number) => boolean;
         /** Internal method */
         setFormula: () => void;
         /** Update nested cell properties */
-        setNestedCell: (x: number, y: number, properties: Nested) => void;
+        setNestedCell(x: number, y: number, properties: Nested): false | undefined;
+        setNestedCell(
+            changes: {
+                x: number,
+                y: number,
+                properties: Nested
+            }[]
+        ): false | undefined;
         /** Get a validation object. Require the extension Validations. */
-        getValidations: (validationIndex: number | null) => Validation | Validation[];
+        getValidations: (validationIndex?: number) => Validation | Validation[] | undefined;
         /** Insert or update existing validations by index. Require the extension Validations. */
-        setValidations: (validations: Validations[]) => void;
+        setValidations: (validations: Validations | Validations[]) => false | undefined;
         /** Reset validations by validation indexes. Require the extension Validations. Undefined will remove all validations */
-        resetValidations: (validationIndex?: number | number[]) => void;
+        resetValidations: (validationIndex?: number | number[]) => false | undefined;
         /** Load all validations rules from a cell based on its coordinates. */
-        loadValidations: (xOrCell: number|object, y?: number, includeIndexes?: boolean) => object[];
+        loadValidations(xOrCell: Records, y?: undefined, includeIndexes?: boolean): Validation[] | { index: number, rules: Validation }[] | undefined;
+        loadValidations(xOrCell: number, y: number, includeIndexes?: boolean): Validation[] | { index: number, rules: Validation }[] | undefined;
         /** This method returns true if a cell fails to meet all the defined validation criteria. If invoked without arguments, this method will scan the entire worksheet and return true if it detects validation errors. */
-        hasErrors: (col?: number|object, row?: number) => boolean;
+        hasErrors(col: string): boolean;
+        hasErrors(col?: number, row?: number): boolean;
         /** Resize columns to match the visible content */
         autoWidth: (columns: number[]) => void;
         /** Show the column headers */
@@ -1692,51 +1742,50 @@ declare namespace jspreadsheet {
         /** Refresh the search on the viewport */
         updateSearch: () => void;
         /** Get the worksheet index by instance or worksheetId */
-        getWorksheet: (worksheetIdent: worksheetInstance|string, instance?: boolean) => number;
+        getWorksheet(worksheetIdent: worksheetInstance): number | false;
+        getWorksheet(worksheetIdent: string, instance?: boolean): worksheetInstance | number | false;
         /** Open a worksheet */
-        openWorksheet: (position?: number) => void;
+        openWorksheet: (position?: number, force?: boolean) => void;
         /** Create a new worksheet */
-        createWorksheet: (worksheetOptions: Worksheet, position?: Number) => worksheetInstance;
+        createWorksheet: (worksheetOptions: Worksheet, position?: number) => false | worksheetInstance;
         /** Delete an existing worksheet by its position */
-        deleteWorksheet: (position?: number) => void;
+        deleteWorksheet: (position?: number) => false | undefined;
         /** Rename an existing worksheet by its position */
-        renameWorksheet: (position: number, title: string) => void;
+        renameWorksheet: (position: number | undefined, title: string) => false | undefined;
         /** Move the position of a worksheet. ignoreDomUpdates: true will block updates to the DOM */
-        moveWorksheet: (from: number, to: number, ignoreDomUpdates?: boolean) => void;
+        moveWorksheet: (from: number, to: number, ignoreDomUpdates?: boolean) => false | undefined;
         /** Get the active worksheet when applicable */
         getWorksheetActive: () => number;
         /** Get the worksheet name */
-        getWorksheetName: (position?: number) => string;
+        getWorksheetName: (position?: number) => string | undefined;
         /** Get the worksheet instance by its name */
-        getWorksheetInstanceByName: (worksheetName: string, namespace?: string) => worksheetInstance;
+        getWorksheetInstanceByName: GetWorksheetInstanceByNameFunction;
         /** Set a worksheet state visibility */
         setWorksheetState: (worksheetIndex: number, state: boolean) => void;
         /** Parse the toolbar definitions with defaults */
-        getToolbar: (toolbar: Toolbar) => object;
+        getToolbar: (toolbar?: Toolbar | ToolbarItem[] | Function) => object;
         /** Set the toolbar */
-        setToolbar: (toolbar: Toolbar) => void;
+        setToolbar: (toolbar: Toolbar | ToolbarItem[] | Function) => void;
         /** Show the toolbar */
         showToolbar: () => void;
         /** Hide the toolbar */
         hideToolbar: () => void;
         /** Refresh the toolbar based on the current worksheet */
-        refreshToolbar: () => void;
-        /** Add, update or delete a new worksheet floating image */
-        setMedia: (items: Media[]) => void;
+        refreshToolbar: (worksheet?: worksheetInstance) => void;
+        /** Add, update or delete a worksheet media */
+        setMedia: (items: Partial<Media> | Partial<Media[]>) => void;
         /** Get a media element position or object by guid. */
-        getMedia: (guid: string, position?: boolean) => void;
+        getMedia: (guid: string, position?: boolean) => number | Media | null;
         /** List of all guids to delete. Can be charts and images */
-        deleteMedia: (items: object[]|string[]) => void;
+        deleteMedia: (items: DeleteMediaItem | DeleteMediaItem[]) => false | undefined;
         /** Add a global formula to the tracking system. Use from formula pro. Only use if necessary. */
         setTracking: () => void;
-        /** Internal column names */
-        names: object;
         /** Set a worksheet zoom value > 0 and <= 1. */
         setZoom: (value: number) => void;
         /** Get the current zoom value. Default 1 */
         getZoom: () => number;
-        // Get the coordinates as a number from a range string. Adjust helps to define the height dynamically when you have A:A ranges for example. Works in the same way for 1:1 ranges. Default: true
-        getCoordsFromRange: (range: string, adjust?: boolean) => [number,number,number,number];
+        /** Get the coordinates as a number from a range string. Adjust helps to define the height dynamically when you have A:A ranges for example. Works in the same way for 1:1 ranges. Default: true */
+        getCoordsFromRange: (range: string, adjust?: boolean) => [number | null, number | null, number | null, number | null];
     }
 
     interface International {
@@ -1744,8 +1793,6 @@ declare namespace jspreadsheet {
         locale: string;
         /** General number format */
         NumberFormat?: Intl.NumberFormat;
-        /** Not yet implemented */
-        DateTimeFormat?: Intl.DateTimeFormat;
     }
 }