@types/datatables.net

  • Version 1.10.20
  • Published
  • 70.7 kB
  • 1 dependency
  • MIT license

Install

npm i @types/datatables.net
yarn add @types/datatables.net
pnpm add @types/datatables.net

Overview

TypeScript definitions for JQuery DataTables

Index

Namespaces

Namespaces

namespace DataTables

namespace DataTables {}

    interface AjaxData

    interface AjaxData {}

      property data

      data: any;

        property draw

        draw?: number | undefined;

          property error

          error?: string | undefined;

            property recordsFiltered

            recordsFiltered?: number | undefined;

              property recordsTotal

              recordsTotal?: number | undefined;

                interface AjaxDataRequest

                interface AjaxDataRequest {}

                  property columns

                  columns: AjaxDataRequestColumn[];

                    property data

                    data: any;

                      property draw

                      draw: number;

                        property length

                        length: number;

                          property order

                          order: AjaxDataRequestOrder[];

                            property search

                            search: AjaxDataRequestSearch;

                              property start

                              start: number;

                                interface AjaxDataRequestColumn

                                interface AjaxDataRequestColumn {}

                                  property data

                                  data: string | number;

                                    property name

                                    name: string;

                                      property orderable

                                      orderable: boolean;

                                        property search

                                        search: AjaxDataRequestSearch;

                                          property searchable

                                          searchable: boolean;

                                            interface AjaxDataRequestOrder

                                            interface AjaxDataRequestOrder {}

                                              property column

                                              column: number;

                                                property dir

                                                dir: string;

                                                  interface AjaxDataRequestSearch

                                                  interface AjaxDataRequestSearch {}

                                                    property regex

                                                    regex: boolean;

                                                      property value

                                                      value: string;

                                                        interface AjaxMethodModel

                                                        interface AjaxMethodModel {}

                                                          method json

                                                          json: () => object;
                                                          • Get the latest JSON data obtained from the last Ajax request DataTables made

                                                          method params

                                                          params: () => object;
                                                          • Get the data submitted by DataTables to the server in the last Ajax request

                                                          method reload

                                                          reload: (callback?: (json: any) => void, resetPaging?: boolean) => Api;
                                                          • Reload the table data from the Ajax data source.

                                                            Parameter callback

                                                            Function which is executed when the data as been reloaded and the table fully redrawn.

                                                            Parameter resetPaging

                                                            Reset (default action or true) or hold the current paging position (false).

                                                          method url

                                                          url: { (): string; (url: string): AjaxMethods };
                                                          • Reload the table data from the Ajax data source

                                                          • Reload the table data from the Ajax data source

                                                            Parameter url

                                                            URL to set to be the Ajax data source for the table.

                                                          interface AjaxMethods

                                                          interface AjaxMethods extends Api {}

                                                            method load

                                                            load: (callback?: (json: any) => void, resetPaging?: boolean) => Api;
                                                            • Reload the table data from the Ajax data source.

                                                              Parameter callback

                                                              Function which is executed when the data as been reloaded and the table fully redrawn.

                                                              Parameter resetPaging

                                                              Reset (default action or true) or hold the current paging position (false).

                                                            interface AjaxSettings

                                                            interface AjaxSettings extends JQueryAjaxSettings {}

                                                              property data

                                                              data?: object | FunctionAjaxData | undefined;
                                                              • Add or modify data submitted to the server upon an Ajax request. Since: 1.10

                                                              property dataSrc

                                                              dataSrc?: string | ((data: any) => any[]) | undefined;
                                                              • Data property or manipulation method for table data. Since: 1.10

                                                              interface Api

                                                              interface Api extends CoreMethods {}

                                                                property column

                                                                column: ColumnMethodsModel;
                                                                • Column Methods / object

                                                                property columns

                                                                columns: ColumnsMethodsModel;
                                                                • Columns Methods / object

                                                                property order

                                                                order: OrderMethods;
                                                                • Order Methods / object

                                                                property row

                                                                row: RowMethodsModel;
                                                                • Row Methode / object

                                                                property rows

                                                                rows: RowsMethodsModel;
                                                                • Rows Methods / object

                                                                method cell

                                                                cell: {
                                                                (cellSelector: any, modifier?: ObjectSelectorModifier): CellMethods;
                                                                (
                                                                rowSelector: any,
                                                                cellSelector: any,
                                                                modifier?: ObjectSelectorModifier
                                                                ): CellMethods;
                                                                };
                                                                • Select the cell found by a cell selector

                                                                  Parameter cellSelector

                                                                  Cell selector.

                                                                  Parameter Option

                                                                  used to specify how the cells should be ordered, and if paging or filtering

                                                                • Select the cell found by a cell selector

                                                                  Parameter rowSelector

                                                                  Row selector.

                                                                  Parameter cellSelector

                                                                  Cell selector.

                                                                  Parameter Option

                                                                  used to specify how the cells should be ordered, and if paging or filtering

                                                                method cells

                                                                cells: {
                                                                (modifier?: ObjectSelectorModifier): CellsMethods;
                                                                (cellSelector: any, modifier?: ObjectSelectorModifier): CellsMethods;
                                                                (
                                                                rowSelector: any,
                                                                cellSelector: any,
                                                                modifier?: ObjectSelectorModifier
                                                                ): CellsMethods;
                                                                };
                                                                • Select all cells

                                                                  Parameter Option

                                                                  used to specify how the cells should be ordered, and if paging or filtering

                                                                • Select cells found by a cell selector

                                                                  Parameter cellSelector

                                                                  Cell selector.

                                                                  Parameter Option

                                                                  used to specify how the cells should be ordered, and if paging or filtering

                                                                • Select cells found by both row and column selectors

                                                                  Parameter rowSelector

                                                                  Row selector.

                                                                  Parameter cellSelector

                                                                  Cell selector.

                                                                  Parameter Option

                                                                  used to specify how the cells should be ordered, and if paging or filtering

                                                                method data

                                                                data: () => Api;
                                                                • Get the data for the whole table.

                                                                method table

                                                                table: (tableSelector: any) => TableMethods;
                                                                • Select a table based on a selector from the API's context

                                                                  Parameter tableSelector

                                                                  Table selector.

                                                                method tables

                                                                tables: (tableSelector?: any) => TablesMethods;
                                                                • Select tables based on the given selector

                                                                  Parameter tableSelector

                                                                  Table selector.

                                                                call signature

                                                                (selector: string | Node | Node[] | JQuery): Api;
                                                                • Returns DataTables API instance

                                                                  Parameter table

                                                                  Selector string for table

                                                                index signature

                                                                [key: number]: any;
                                                                • API should be array-like

                                                                interface ArrayStringNode

                                                                interface ArrayStringNode {}

                                                                  index signature

                                                                  [index: string]: Node;

                                                                    interface BrowserLegacy

                                                                    interface BrowserLegacy {}

                                                                      property barWidth

                                                                      barWidth: number;

                                                                        property bBounding

                                                                        bBounding: boolean;

                                                                          property bScrollbarLeft

                                                                          bScrollbarLeft: boolean;

                                                                            property bScrollOversize

                                                                            bScrollOversize: boolean;

                                                                              interface CellIndexReturn

                                                                              interface CellIndexReturn {}

                                                                                property column

                                                                                column: number;

                                                                                  property columnVisible

                                                                                  columnVisible: number;

                                                                                    property row

                                                                                    row: number;

                                                                                      interface CellMetaSettings

                                                                                      interface CellMetaSettings {}

                                                                                        property col

                                                                                        col: number;

                                                                                          property row

                                                                                          row: number;

                                                                                            property settings

                                                                                            settings: Settings;

                                                                                              interface CellMethods

                                                                                              interface CellMethods extends CoreMethods, CommonCellMethods {}

                                                                                                method data

                                                                                                data: { (): any; (data: any): Api };
                                                                                                • Get data for the selected cell

                                                                                                • Get data for the selected cell

                                                                                                  Parameter data

                                                                                                  Value to assign to the data for the cell

                                                                                                method index

                                                                                                index: () => CellIndexReturn;
                                                                                                • Get index information about the selected cell

                                                                                                method node

                                                                                                node: () => Node;
                                                                                                • Get the DOM element for the selected cell

                                                                                                interface CellsMethods

                                                                                                interface CellsMethods extends CoreMethods, CommonCellMethods {}

                                                                                                  method data

                                                                                                  data: () => Api;
                                                                                                  • Get data for the selected cells

                                                                                                  method every

                                                                                                  every: (
                                                                                                  fn: (
                                                                                                  this: CellMethods,
                                                                                                  cellRowIdx: number,
                                                                                                  cellColIdx: number,
                                                                                                  tableLoop: number,
                                                                                                  cellLoop: number
                                                                                                  ) => void
                                                                                                  ) => Api;
                                                                                                  • Iterate over each selected cell, with the function context set to be the cell in question. Since: DataTables 1.10.6

                                                                                                    Parameter fn

                                                                                                    Function to execute for every cell selected.

                                                                                                  method indexes

                                                                                                  indexes: () => Api;
                                                                                                  • Get index information about the selected cells

                                                                                                  method nodes

                                                                                                  nodes: () => Api;
                                                                                                  • Get the DOM elements for the selected cells

                                                                                                  interface ColumnDefsSettings

                                                                                                  interface ColumnDefsSettings extends ColumnSettings {}

                                                                                                    property targets

                                                                                                    targets: string | number | Array<number | string>;

                                                                                                      interface ColumnLegacy

                                                                                                      interface ColumnLegacy {}

                                                                                                        property aDataSort

                                                                                                        aDataSort: any;

                                                                                                          property asSorting

                                                                                                          asSorting: string[];

                                                                                                            property bSearchable

                                                                                                            bSearchable: boolean;

                                                                                                              property bSortable

                                                                                                              bSortable: boolean;

                                                                                                                property bVisible

                                                                                                                bVisible: boolean;

                                                                                                                  property fnCreatedCell

                                                                                                                  fnCreatedCell: FunctionColumnCreatedCell;

                                                                                                                    property idx

                                                                                                                    idx: number;

                                                                                                                      property mData

                                                                                                                      mData: any;

                                                                                                                        property mRender

                                                                                                                        mRender: any;

                                                                                                                          property nIf

                                                                                                                          nIf: Node;

                                                                                                                            property nTh

                                                                                                                            nTh: Node;

                                                                                                                              property sClass

                                                                                                                              sClass: string;

                                                                                                                                property sContentPadding

                                                                                                                                sContentPadding: string;

                                                                                                                                  property sDefaultContent

                                                                                                                                  sDefaultContent: string;

                                                                                                                                    property sName

                                                                                                                                    sName: string;

                                                                                                                                      property sSortDataType

                                                                                                                                      sSortDataType: string;

                                                                                                                                        property sSortingClass

                                                                                                                                        sSortingClass: string;

                                                                                                                                          property sSortingClassJUI

                                                                                                                                          sSortingClassJUI: string;

                                                                                                                                            property sTitle

                                                                                                                                            sTitle: string;

                                                                                                                                              property sType

                                                                                                                                              sType: string;

                                                                                                                                                property sWidth

                                                                                                                                                sWidth: string;

                                                                                                                                                  property sWidthOrig

                                                                                                                                                  sWidthOrig: string;

                                                                                                                                                    method fnGetData

                                                                                                                                                    fnGetData: (data: any, specific: string) => any;

                                                                                                                                                      method fnSetData

                                                                                                                                                      fnSetData: (data: any, value: any) => void;

                                                                                                                                                        interface ColumnMethods

                                                                                                                                                        interface ColumnMethods extends CoreMethods, CommonColumnMethod {}

                                                                                                                                                          method data

                                                                                                                                                          data: () => Api;
                                                                                                                                                          • Get the data for the cells in the selected column.

                                                                                                                                                          method dataSrc

                                                                                                                                                          dataSrc: () => number | string | (() => string);
                                                                                                                                                          • Get the data source property for the selected column

                                                                                                                                                          method index

                                                                                                                                                          index: (t?: string) => number;
                                                                                                                                                          • Get index information about the selected cell

                                                                                                                                                            Parameter t

                                                                                                                                                            Specify if you want to get the column data index (default) or the visible index (visible).

                                                                                                                                                          method nodes

                                                                                                                                                          nodes: () => Api;
                                                                                                                                                          • Obtain the th / td nodes for the selected column

                                                                                                                                                          interface ColumnMethodsModel

                                                                                                                                                          interface ColumnMethodsModel {}

                                                                                                                                                            method index

                                                                                                                                                            index: (t: string, index: number) => number;
                                                                                                                                                            • Convert from the input column index type to that required.

                                                                                                                                                              Parameter t

                                                                                                                                                              The type on conversion that should take place: 'fromVisible', 'toData', 'fromData', 'toVisible'

                                                                                                                                                              Parameter index

                                                                                                                                                              The index to be converted

                                                                                                                                                            call signature

                                                                                                                                                            (columnSelector: any, modifier?: ObjectSelectorModifier): ColumnMethods;
                                                                                                                                                            • Select the column found by a column selector

                                                                                                                                                              Parameter cellSelector

                                                                                                                                                              Cell selector.

                                                                                                                                                              Parameter Option

                                                                                                                                                              used to specify how the cells should be ordered, and if paging or filtering in the table should be taken into account.

                                                                                                                                                            interface ColumnSettings

                                                                                                                                                            interface ColumnSettings {}

                                                                                                                                                              property cellType

                                                                                                                                                              cellType?: string | undefined;
                                                                                                                                                              • Cell type to be created for a column. th/td Since: 1.10

                                                                                                                                                              property className

                                                                                                                                                              className?: string | undefined;
                                                                                                                                                              • Class to assign to each cell in the column. Since: 1.10

                                                                                                                                                              property contentPadding

                                                                                                                                                              contentPadding?: string | undefined;
                                                                                                                                                              • Add padding to the text content used when calculating the optimal with for a table. Since: 1.10

                                                                                                                                                              property createdCell

                                                                                                                                                              createdCell?: FunctionColumnCreatedCell | undefined;
                                                                                                                                                              • Cell created callback to allow DOM manipulation. Since: 1.10

                                                                                                                                                              property data

                                                                                                                                                              data?:
                                                                                                                                                              | number
                                                                                                                                                              | string
                                                                                                                                                              | ObjectColumnData
                                                                                                                                                              | FunctionColumnData
                                                                                                                                                              | null
                                                                                                                                                              | undefined;
                                                                                                                                                              • Class to assign to each cell in the column. Since: 1.10

                                                                                                                                                              property defaultContent

                                                                                                                                                              defaultContent?: string | undefined;
                                                                                                                                                              • Set default, static, content for a column. Since: 1.10

                                                                                                                                                              property name

                                                                                                                                                              name?: string | undefined;
                                                                                                                                                              • Set a descriptive name for a column. Since: 1.10

                                                                                                                                                              property orderable

                                                                                                                                                              orderable?: boolean | undefined;
                                                                                                                                                              • Enable or disable ordering on this column. Since: 1.10

                                                                                                                                                              property orderData

                                                                                                                                                              orderData?: number | number[] | undefined;
                                                                                                                                                              • Define multiple column ordering as the default order for a column. Since: 1.10

                                                                                                                                                              property orderDataType

                                                                                                                                                              orderDataType?: string | undefined;
                                                                                                                                                              • Live DOM sorting type assignment. Since: 1.10

                                                                                                                                                              property orderFixed

                                                                                                                                                              orderFixed?: any[] | ObjectOrderFixed | undefined;
                                                                                                                                                              • Ordering to always be applied to the table. Since 1.10

                                                                                                                                                                Array type is prefix ordering only and is a two-element array: 0: Column index to order upon. 1: Direction so order to apply ("asc" for ascending order or "desc" for descending order).

                                                                                                                                                              property orderSequence

                                                                                                                                                              orderSequence?: string[] | undefined;
                                                                                                                                                              • Order direction application sequence. Since: 1.10

                                                                                                                                                              property render

                                                                                                                                                              render?:
                                                                                                                                                              | number
                                                                                                                                                              | string
                                                                                                                                                              | ObjectColumnData
                                                                                                                                                              | FunctionColumnRender
                                                                                                                                                              | ObjectColumnRender
                                                                                                                                                              | undefined;
                                                                                                                                                              • Render (process) the data for use in the table. Since: 1.10

                                                                                                                                                              property searchable

                                                                                                                                                              searchable?: boolean | undefined;
                                                                                                                                                              • Enable or disable filtering on the data in this column. Since: 1.10

                                                                                                                                                              property title

                                                                                                                                                              title?: string | undefined;
                                                                                                                                                              • Set the column title. Since: 1.10

                                                                                                                                                              property type

                                                                                                                                                              type?: string | undefined;
                                                                                                                                                              • Set the column type - used for filtering and sorting string processing. Since: 1.10

                                                                                                                                                              property visible

                                                                                                                                                              visible?: boolean | undefined;
                                                                                                                                                              • Enable or disable the display of this column. Since: 1.10

                                                                                                                                                              property width

                                                                                                                                                              width?: string | undefined;
                                                                                                                                                              • Column width assignment. Since: 1.10

                                                                                                                                                              interface ColumnsMethods

                                                                                                                                                              interface ColumnsMethods extends CoreMethods, CommonColumnMethod {}

                                                                                                                                                                method data

                                                                                                                                                                data: () => Api;
                                                                                                                                                                • Obtain the data for the columns from the selector

                                                                                                                                                                method dataSrc

                                                                                                                                                                dataSrc: () => Api;
                                                                                                                                                                • Get the data source property for the selected columns.

                                                                                                                                                                method every

                                                                                                                                                                every: (
                                                                                                                                                                fn: (
                                                                                                                                                                this: ColumnMethods,
                                                                                                                                                                colIdx: number,
                                                                                                                                                                tableLoop: number,
                                                                                                                                                                colLoop: number
                                                                                                                                                                ) => void
                                                                                                                                                                ) => Api;
                                                                                                                                                                • Iterate over each selected column, with the function context set to be the column in question. Since: DataTables 1.10.6

                                                                                                                                                                  Parameter fn

                                                                                                                                                                  Function to execute for every column selected.

                                                                                                                                                                method indexes

                                                                                                                                                                indexes: (t?: string) => Api;
                                                                                                                                                                • Get the column indexes of the selected columns.

                                                                                                                                                                  Parameter t

                                                                                                                                                                  Specify if you want to get the column data index (default) or the visible index (visible).

                                                                                                                                                                method nodes

                                                                                                                                                                nodes: () => Api[][];
                                                                                                                                                                • Obtain the th / td nodes for the selected columns

                                                                                                                                                                interface ColumnsMethodsModel

                                                                                                                                                                interface ColumnsMethodsModel {}

                                                                                                                                                                  method adjust

                                                                                                                                                                  adjust: () => Api;
                                                                                                                                                                  • Recalculate the column widths for layout.

                                                                                                                                                                  call signature

                                                                                                                                                                  (modifier?: ObjectSelectorModifier): ColumnsMethods;
                                                                                                                                                                  • Select all columns

                                                                                                                                                                    Parameter Option

                                                                                                                                                                    used to specify how the cells should be ordered, and if paging or filtering in the table should be taken into account.

                                                                                                                                                                  call signature

                                                                                                                                                                  (columnSelector: any, modifier?: ObjectSelectorModifier): ColumnsMethods;
                                                                                                                                                                  • Select columns found by a cell selector

                                                                                                                                                                    Parameter cellSelector

                                                                                                                                                                    Cell selector.

                                                                                                                                                                    Parameter Option

                                                                                                                                                                    used to specify how the cells should be ordered, and if paging or filtering in the table should be taken into account.

                                                                                                                                                                  interface CommonCellMethods

                                                                                                                                                                  interface CommonCellMethods extends CommonSubMethods {}

                                                                                                                                                                    method invalidate

                                                                                                                                                                    invalidate: (source?: string) => Api;
                                                                                                                                                                    • Invalidate the data held in DataTables for the selected cells

                                                                                                                                                                      Parameter source

                                                                                                                                                                      Data source to read the new data from.

                                                                                                                                                                    method render

                                                                                                                                                                    render: (t: string) => any;
                                                                                                                                                                    • Get data for the selected cell

                                                                                                                                                                      Parameter f

                                                                                                                                                                      Data type to get. This can be one of: 'display', 'filter', 'sort', 'type'

                                                                                                                                                                    interface CommonColumnMethod

                                                                                                                                                                    interface CommonColumnMethod extends CommonSubMethods {}

                                                                                                                                                                      method footer

                                                                                                                                                                      footer: () => HTMLElement;
                                                                                                                                                                      • Get the footer th / td cell for the selected column.

                                                                                                                                                                      method header

                                                                                                                                                                      header: () => HTMLElement;
                                                                                                                                                                      • Get the header th / td cell for a column.

                                                                                                                                                                      method order

                                                                                                                                                                      order: (direction: string) => Api;
                                                                                                                                                                      • Order the table, in the direction specified, by the column selected by the column()DT selector.

                                                                                                                                                                        Parameter direction

                                                                                                                                                                        Direction of sort to apply to the selected column - desc (descending) or asc (ascending).

                                                                                                                                                                      method visible

                                                                                                                                                                      visible: { (): boolean; (show: boolean, redrawCalculations?: boolean): Api };
                                                                                                                                                                      • Get the visibility of the selected column.

                                                                                                                                                                      • Set the visibility of the selected column.

                                                                                                                                                                        Parameter show

                                                                                                                                                                        Specify if the column should be visible (true) or not (false).

                                                                                                                                                                        Parameter redrawCalculations

                                                                                                                                                                        Indicate if DataTables should recalculate the column layout (true - default) or not (false).

                                                                                                                                                                      interface CommonRowMethod

                                                                                                                                                                      interface CommonRowMethod extends CommonSubMethods {}

                                                                                                                                                                        method invalidate

                                                                                                                                                                        invalidate: (source?: string) => Api;
                                                                                                                                                                        • Obtain the th / td nodes for the selected column

                                                                                                                                                                          Parameter source

                                                                                                                                                                          Data source to read the new data from. Values: 'auto', 'data', 'dom'

                                                                                                                                                                        interface CommonSubMethods

                                                                                                                                                                        interface CommonSubMethods {}

                                                                                                                                                                          method cache

                                                                                                                                                                          cache: (t: string) => Api;
                                                                                                                                                                          • Get the DataTables cached data for the selected cell

                                                                                                                                                                            Parameter t

                                                                                                                                                                            Specify which cache the data should be read from. Can take one of two values: search or order

                                                                                                                                                                          interface CoreMethods

                                                                                                                                                                          interface CoreMethods extends UtilityMethods {}

                                                                                                                                                                            property ajax

                                                                                                                                                                            ajax: AjaxMethodModel;
                                                                                                                                                                            • Ajax Methods

                                                                                                                                                                            property page

                                                                                                                                                                            page: PageMethods;
                                                                                                                                                                            • Page Methods / object

                                                                                                                                                                            property state

                                                                                                                                                                            state: StateMethods;
                                                                                                                                                                            • Page Methods / object

                                                                                                                                                                            method $

                                                                                                                                                                            $: (
                                                                                                                                                                            selector: string | Node | Node[] | JQuery,
                                                                                                                                                                            modifier?: ObjectSelectorModifier
                                                                                                                                                                            ) => JQuery;
                                                                                                                                                                            • Get jquery object

                                                                                                                                                                            method clear

                                                                                                                                                                            clear: () => Api;
                                                                                                                                                                            • Clear the table of all data.

                                                                                                                                                                            method destroy

                                                                                                                                                                            destroy: (remove?: boolean) => Api;
                                                                                                                                                                            • Destroy the DataTables in the current context.

                                                                                                                                                                              Parameter remove

                                                                                                                                                                              Completely remove the table from the DOM (true) or leave it in the DOM in its original plain un-enhanced HTML state (default, false).

                                                                                                                                                                            method draw

                                                                                                                                                                            draw: (paging?: boolean | string) => Api;
                                                                                                                                                                            • Redraw the DataTables in the current context, optionally updating ordering, searching and paging as required.

                                                                                                                                                                              Parameter paging

                                                                                                                                                                              This parameter is used to determine what kind of draw DataTables will perform.

                                                                                                                                                                            method i18n

                                                                                                                                                                            i18n: (token: string, def: any, numeric?: number) => string;

                                                                                                                                                                              method init

                                                                                                                                                                              init: () => Settings;

                                                                                                                                                                                method off

                                                                                                                                                                                off: (event: string, callback?: (e: Event, ...args: any[]) => void) => Api;
                                                                                                                                                                                • Table events removal.

                                                                                                                                                                                  Parameter event

                                                                                                                                                                                  Event name to remove.

                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                  Specific callback function to remove if you want to unbind a single event listener.

                                                                                                                                                                                method on

                                                                                                                                                                                on: (event: string, callback: (e: Event, ...args: any[]) => void) => Api;
                                                                                                                                                                                • Table events listener.

                                                                                                                                                                                  Parameter event

                                                                                                                                                                                  Event to listen for.

                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                  Specific callback function to remove if you want to unbind a single event listener.

                                                                                                                                                                                method one

                                                                                                                                                                                one: (event: string, callback: (e: Event, ...args: any[]) => void) => Api;
                                                                                                                                                                                • Listen for a table event once and then remove the listener.

                                                                                                                                                                                  Parameter event

                                                                                                                                                                                  Event to listen for.

                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                  Specific callback function to remove if you want to unbind a single event listener.

                                                                                                                                                                                method search

                                                                                                                                                                                search: {
                                                                                                                                                                                (): string;
                                                                                                                                                                                (input: string, regex?: boolean, smart?: boolean, caseInsen?: boolean): Api;
                                                                                                                                                                                };
                                                                                                                                                                                • Get current search

                                                                                                                                                                                • Search for data in the table.

                                                                                                                                                                                  Parameter input

                                                                                                                                                                                  Search string to apply to the table.

                                                                                                                                                                                  Parameter regex

                                                                                                                                                                                  Treat as a regular expression (true) or not (default, false).

                                                                                                                                                                                  Parameter smart

                                                                                                                                                                                  Perform smart search.

                                                                                                                                                                                  Parameter caseInsen

                                                                                                                                                                                  Do case-insensitive matching (default, true) or not (false).

                                                                                                                                                                                method settings

                                                                                                                                                                                settings: () => Api;
                                                                                                                                                                                • Obtain the table's settings object

                                                                                                                                                                                interface DataTables

                                                                                                                                                                                interface DataTables extends CoreMethods {}

                                                                                                                                                                                  index signature

                                                                                                                                                                                  [index: number]: Api;

                                                                                                                                                                                    interface ExtClassesSettings

                                                                                                                                                                                    interface ExtClassesSettings {}

                                                                                                                                                                                      property sFilter

                                                                                                                                                                                      sFilter?: string | undefined;
                                                                                                                                                                                      • Default Value: dataTables_filter

                                                                                                                                                                                      property sFilterInput

                                                                                                                                                                                      sFilterInput?: string | undefined;

                                                                                                                                                                                        property sFooterTH

                                                                                                                                                                                        sFooterTH?: string | undefined;

                                                                                                                                                                                          property sHeaderTH

                                                                                                                                                                                          sHeaderTH?: string | undefined;

                                                                                                                                                                                            property sInfo

                                                                                                                                                                                            sInfo?: string | undefined;
                                                                                                                                                                                            • Default Value: dataTables_info

                                                                                                                                                                                            property sJUIFooter

                                                                                                                                                                                            sJUIFooter?: string | undefined;

                                                                                                                                                                                              property sJUIHeader

                                                                                                                                                                                              sJUIHeader?: string | undefined;

                                                                                                                                                                                                property sLength

                                                                                                                                                                                                sLength?: string | undefined;
                                                                                                                                                                                                • Default Value: dataTables_length

                                                                                                                                                                                                property sLengthSelect

                                                                                                                                                                                                sLengthSelect?: string | undefined;

                                                                                                                                                                                                  property sNoFooter

                                                                                                                                                                                                  sNoFooter?: string | undefined;
                                                                                                                                                                                                  • Default Value: no-footer

                                                                                                                                                                                                  property sPageButton

                                                                                                                                                                                                  sPageButton?: string | undefined;
                                                                                                                                                                                                  • Default Value: paginate_button

                                                                                                                                                                                                  property sPageButtonActive

                                                                                                                                                                                                  sPageButtonActive?: string | undefined;
                                                                                                                                                                                                  • Default Value: current

                                                                                                                                                                                                  property sPageButtonDisabled

                                                                                                                                                                                                  sPageButtonDisabled?: string | undefined;
                                                                                                                                                                                                  • Default Value: disabled

                                                                                                                                                                                                  property sPaging

                                                                                                                                                                                                  sPaging?: string | undefined;
                                                                                                                                                                                                  • Default Value: dataTables_paginate paging_

                                                                                                                                                                                                  property sProcessing

                                                                                                                                                                                                  sProcessing?: string | undefined;
                                                                                                                                                                                                  • Default Value: dataTables_processing

                                                                                                                                                                                                  property sRowEmpty

                                                                                                                                                                                                  sRowEmpty?: string | undefined;
                                                                                                                                                                                                  • Default Value: dataTables_empty

                                                                                                                                                                                                  property sScrollBody

                                                                                                                                                                                                  sScrollBody?: string | undefined;
                                                                                                                                                                                                  • Default Value: dataTables_scrollBody

                                                                                                                                                                                                  property sScrollFoot

                                                                                                                                                                                                  sScrollFoot?: string | undefined;
                                                                                                                                                                                                  • Default Value: dataTables_scrollFoot

                                                                                                                                                                                                  property sScrollFootInner

                                                                                                                                                                                                  sScrollFootInner?: string | undefined;
                                                                                                                                                                                                  • Default Value: dataTables_scrollFootInner

                                                                                                                                                                                                  property sScrollHead

                                                                                                                                                                                                  sScrollHead?: string | undefined;
                                                                                                                                                                                                  • Default Value: dataTables_scrollHead

                                                                                                                                                                                                  property sScrollHeadInner

                                                                                                                                                                                                  sScrollHeadInner?: string | undefined;
                                                                                                                                                                                                  • Default Value: dataTables_scrollHeadInner

                                                                                                                                                                                                  property sScrollWrapper

                                                                                                                                                                                                  sScrollWrapper?: string | undefined;
                                                                                                                                                                                                  • Default Value: dataTables_scroll

                                                                                                                                                                                                  property sSortable

                                                                                                                                                                                                  sSortable?: string | undefined;
                                                                                                                                                                                                  • Default Value: sorting

                                                                                                                                                                                                  property sSortableAsc

                                                                                                                                                                                                  sSortableAsc?: string | undefined;
                                                                                                                                                                                                  • Default Value: sorting_asc_disabled

                                                                                                                                                                                                  property sSortableDesc

                                                                                                                                                                                                  sSortableDesc?: string | undefined;
                                                                                                                                                                                                  • Default Value: sorting_desc_disabled

                                                                                                                                                                                                  property sSortableNone

                                                                                                                                                                                                  sSortableNone?: string | undefined;
                                                                                                                                                                                                  • Default Value: sorting_disabled

                                                                                                                                                                                                  property sSortAsc

                                                                                                                                                                                                  sSortAsc?: string | undefined;
                                                                                                                                                                                                  • Default Value: sorting_asc

                                                                                                                                                                                                  property sSortColumn

                                                                                                                                                                                                  sSortColumn?: string | undefined;
                                                                                                                                                                                                  • Default Value: sorting_

                                                                                                                                                                                                  property sSortDesc

                                                                                                                                                                                                  sSortDesc?: string | undefined;
                                                                                                                                                                                                  • Default Value: sorting_desc

                                                                                                                                                                                                  property sSortIcon

                                                                                                                                                                                                  sSortIcon?: string | undefined;

                                                                                                                                                                                                    property sSortJUI

                                                                                                                                                                                                    sSortJUI?: string | undefined;

                                                                                                                                                                                                      property sSortJUIAsc

                                                                                                                                                                                                      sSortJUIAsc?: string | undefined;

                                                                                                                                                                                                        property sSortJUIAscAllowed

                                                                                                                                                                                                        sSortJUIAscAllowed?: string | undefined;

                                                                                                                                                                                                          property sSortJUIDesc

                                                                                                                                                                                                          sSortJUIDesc?: string | undefined;

                                                                                                                                                                                                            property sSortJUIDescAllowed

                                                                                                                                                                                                            sSortJUIDescAllowed?: string | undefined;

                                                                                                                                                                                                              property sSortJUIWrapper

                                                                                                                                                                                                              sSortJUIWrapper?: string | undefined;

                                                                                                                                                                                                                property sStripeEven

                                                                                                                                                                                                                sStripeEven?: string | undefined;
                                                                                                                                                                                                                • Default Value: even

                                                                                                                                                                                                                property sStripeOdd

                                                                                                                                                                                                                sStripeOdd?: string | undefined;
                                                                                                                                                                                                                • Default Value: odd

                                                                                                                                                                                                                property sTable

                                                                                                                                                                                                                sTable?: string | undefined;
                                                                                                                                                                                                                • Default Value: dataTable

                                                                                                                                                                                                                property sWrapper

                                                                                                                                                                                                                sWrapper?: string | undefined;
                                                                                                                                                                                                                • Default Value: dataTables_wrapper

                                                                                                                                                                                                                interface ExtSettings

                                                                                                                                                                                                                interface ExtSettings {}

                                                                                                                                                                                                                  property afnFiltering

                                                                                                                                                                                                                  afnFiltering: any[];

                                                                                                                                                                                                                    property afnSortData

                                                                                                                                                                                                                    afnSortData: object;

                                                                                                                                                                                                                      property aoFeatures

                                                                                                                                                                                                                      aoFeatures: any[];

                                                                                                                                                                                                                        property aTypes

                                                                                                                                                                                                                        aTypes: any[];

                                                                                                                                                                                                                          property builder

                                                                                                                                                                                                                          builder: string;

                                                                                                                                                                                                                            property classes

                                                                                                                                                                                                                            classes: ExtClassesSettings;

                                                                                                                                                                                                                              property errMode

                                                                                                                                                                                                                              errMode: string;

                                                                                                                                                                                                                                property feature

                                                                                                                                                                                                                                feature: any[];

                                                                                                                                                                                                                                  property iApiIndex

                                                                                                                                                                                                                                  iApiIndex: number;

                                                                                                                                                                                                                                    property internal

                                                                                                                                                                                                                                    internal: object;

                                                                                                                                                                                                                                      property legacy

                                                                                                                                                                                                                                      legacy: object;

                                                                                                                                                                                                                                        property oApi

                                                                                                                                                                                                                                        oApi: object;

                                                                                                                                                                                                                                          property ofnSearch

                                                                                                                                                                                                                                          ofnSearch: object;

                                                                                                                                                                                                                                            property oJUIClasses

                                                                                                                                                                                                                                            oJUIClasses: object;

                                                                                                                                                                                                                                              property oPagination

                                                                                                                                                                                                                                              oPagination: object;

                                                                                                                                                                                                                                                property order

                                                                                                                                                                                                                                                order: object;

                                                                                                                                                                                                                                                  property oSort

                                                                                                                                                                                                                                                  oSort: object;

                                                                                                                                                                                                                                                    property oStdClasses

                                                                                                                                                                                                                                                    oStdClasses: ExtClassesSettings;

                                                                                                                                                                                                                                                      property pager

                                                                                                                                                                                                                                                      pager: object;

                                                                                                                                                                                                                                                        property renderer

                                                                                                                                                                                                                                                        renderer: object;

                                                                                                                                                                                                                                                          property search

                                                                                                                                                                                                                                                          search: any[];

                                                                                                                                                                                                                                                            property selector

                                                                                                                                                                                                                                                            selector: object;

                                                                                                                                                                                                                                                              property sVersion

                                                                                                                                                                                                                                                              sVersion: string;

                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                type: ExtTypeSettings;
                                                                                                                                                                                                                                                                • Type based plug-ins.

                                                                                                                                                                                                                                                                method fnVersionCheck

                                                                                                                                                                                                                                                                fnVersionCheck: (version: string) => string;

                                                                                                                                                                                                                                                                  interface ExtTypeSettings

                                                                                                                                                                                                                                                                  interface ExtTypeSettings {}

                                                                                                                                                                                                                                                                    property detect

                                                                                                                                                                                                                                                                    detect: FunctionExtTypeSettingsDetect[];
                                                                                                                                                                                                                                                                    • Type detection functions for plug-in development.

                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                      • https://datatables.net/manual/plug-ins/type-detection

                                                                                                                                                                                                                                                                    property order

                                                                                                                                                                                                                                                                    order: object;
                                                                                                                                                                                                                                                                    • Type based ordering functions for plug-in development.

                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                      • https://datatables.net/manual/plug-ins/sorting {}

                                                                                                                                                                                                                                                                    property search

                                                                                                                                                                                                                                                                    search: object;
                                                                                                                                                                                                                                                                    • Type based search formatting for plug-in development.

                                                                                                                                                                                                                                                                      {}

                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                      $.fn.dataTable.ext.type.search['title-numeric'] = function ( d ) { return d.replace(/\n/g," ").replace( /<.*?>/g, "" ); }

                                                                                                                                                                                                                                                                    interface FeaturesLegacy

                                                                                                                                                                                                                                                                    interface FeaturesLegacy {}

                                                                                                                                                                                                                                                                      property bAutoWidth

                                                                                                                                                                                                                                                                      bAutoWidth: boolean;

                                                                                                                                                                                                                                                                        property bDeferRender

                                                                                                                                                                                                                                                                        bDeferRender: boolean;

                                                                                                                                                                                                                                                                          property bFilter

                                                                                                                                                                                                                                                                          bFilter: boolean;

                                                                                                                                                                                                                                                                            property bInfo

                                                                                                                                                                                                                                                                            bInfo: boolean;

                                                                                                                                                                                                                                                                              property bLengthChange

                                                                                                                                                                                                                                                                              bLengthChange: boolean;

                                                                                                                                                                                                                                                                                property bPaginate

                                                                                                                                                                                                                                                                                bPaginate: boolean;

                                                                                                                                                                                                                                                                                  property bProcessing

                                                                                                                                                                                                                                                                                  bProcessing: boolean;

                                                                                                                                                                                                                                                                                    property bServerSide

                                                                                                                                                                                                                                                                                    bServerSide: boolean;

                                                                                                                                                                                                                                                                                      property bSort

                                                                                                                                                                                                                                                                                      bSort: boolean;

                                                                                                                                                                                                                                                                                        property bSortClasses

                                                                                                                                                                                                                                                                                        bSortClasses: boolean;

                                                                                                                                                                                                                                                                                          property bStateSave

                                                                                                                                                                                                                                                                                          bStateSave: boolean;

                                                                                                                                                                                                                                                                                            interface FunctionColumnData

                                                                                                                                                                                                                                                                                            interface FunctionColumnData {}

                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                              (row: any, t: 'set', s: any, meta: CellMetaSettings): void;

                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                row: any,
                                                                                                                                                                                                                                                                                                t: 'display' | 'sort' | 'filter' | 'type',
                                                                                                                                                                                                                                                                                                s: undefined,
                                                                                                                                                                                                                                                                                                meta: CellMetaSettings
                                                                                                                                                                                                                                                                                                ): any;

                                                                                                                                                                                                                                                                                                  interface JQueryDataTables

                                                                                                                                                                                                                                                                                                  interface JQueryDataTables extends JQuery {}

                                                                                                                                                                                                                                                                                                    method api

                                                                                                                                                                                                                                                                                                    api: () => Api;
                                                                                                                                                                                                                                                                                                    • Returns DataTables API instance Usage: $( selector ).dataTable().api();

                                                                                                                                                                                                                                                                                                    interface LanguageAriaLegacy

                                                                                                                                                                                                                                                                                                    interface LanguageAriaLegacy {}

                                                                                                                                                                                                                                                                                                      property sSortAscending

                                                                                                                                                                                                                                                                                                      sSortAscending?: string | undefined;

                                                                                                                                                                                                                                                                                                        property sSortDescending

                                                                                                                                                                                                                                                                                                        sSortDescending?: string | undefined;

                                                                                                                                                                                                                                                                                                          interface LanguageAriaSettings

                                                                                                                                                                                                                                                                                                          interface LanguageAriaSettings {}

                                                                                                                                                                                                                                                                                                            property paginate

                                                                                                                                                                                                                                                                                                            paginate?: LanguagePaginateSettings | undefined;

                                                                                                                                                                                                                                                                                                              property sortAscending

                                                                                                                                                                                                                                                                                                              sortAscending: string;

                                                                                                                                                                                                                                                                                                                property sortDescending

                                                                                                                                                                                                                                                                                                                sortDescending: string;

                                                                                                                                                                                                                                                                                                                  interface LanguageLegacy

                                                                                                                                                                                                                                                                                                                  interface LanguageLegacy {}

                                                                                                                                                                                                                                                                                                                    property oAria

                                                                                                                                                                                                                                                                                                                    oAria?: LanguageAriaLegacy | undefined;

                                                                                                                                                                                                                                                                                                                      property oPaginate

                                                                                                                                                                                                                                                                                                                      oPaginate?: LanguagePaginateLegacy | undefined;

                                                                                                                                                                                                                                                                                                                        property sEmptyTable

                                                                                                                                                                                                                                                                                                                        sEmptyTable?: string | undefined;

                                                                                                                                                                                                                                                                                                                          property sInfo

                                                                                                                                                                                                                                                                                                                          sInfo?: string | undefined;

                                                                                                                                                                                                                                                                                                                            property sInfoEmpty

                                                                                                                                                                                                                                                                                                                            sInfoEmpty?: string | undefined;

                                                                                                                                                                                                                                                                                                                              property sInfoFiltered

                                                                                                                                                                                                                                                                                                                              sInfoFiltered?: string | undefined;

                                                                                                                                                                                                                                                                                                                                property sInfoPostFix

                                                                                                                                                                                                                                                                                                                                sInfoPostFix?: string | undefined;

                                                                                                                                                                                                                                                                                                                                  property sInfoThousands

                                                                                                                                                                                                                                                                                                                                  sInfoThousands?: string | undefined;

                                                                                                                                                                                                                                                                                                                                    property sLengthMenu

                                                                                                                                                                                                                                                                                                                                    sLengthMenu?: string | undefined;

                                                                                                                                                                                                                                                                                                                                      property sLoadingRecords

                                                                                                                                                                                                                                                                                                                                      sLoadingRecords?: string | undefined;

                                                                                                                                                                                                                                                                                                                                        property sProcessing

                                                                                                                                                                                                                                                                                                                                        sProcessing?: string | undefined;

                                                                                                                                                                                                                                                                                                                                          property sSearch

                                                                                                                                                                                                                                                                                                                                          sSearch?: string | undefined;

                                                                                                                                                                                                                                                                                                                                            property sUrl

                                                                                                                                                                                                                                                                                                                                            sUrl?: string | undefined;

                                                                                                                                                                                                                                                                                                                                              property sZeroRecords

                                                                                                                                                                                                                                                                                                                                              sZeroRecords?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                interface LanguagePaginateLegacy

                                                                                                                                                                                                                                                                                                                                                interface LanguagePaginateLegacy {}

                                                                                                                                                                                                                                                                                                                                                  property sFirst

                                                                                                                                                                                                                                                                                                                                                  sFirst?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                    property sLast

                                                                                                                                                                                                                                                                                                                                                    sLast?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                      property sNext

                                                                                                                                                                                                                                                                                                                                                      sNext?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                        property sPrevious

                                                                                                                                                                                                                                                                                                                                                        sPrevious?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                          interface LanguagePaginateSettings

                                                                                                                                                                                                                                                                                                                                                          interface LanguagePaginateSettings {}

                                                                                                                                                                                                                                                                                                                                                            property first

                                                                                                                                                                                                                                                                                                                                                            first: string;

                                                                                                                                                                                                                                                                                                                                                              property last

                                                                                                                                                                                                                                                                                                                                                              last: string;

                                                                                                                                                                                                                                                                                                                                                                property next

                                                                                                                                                                                                                                                                                                                                                                next: string;

                                                                                                                                                                                                                                                                                                                                                                  property previous

                                                                                                                                                                                                                                                                                                                                                                  previous: string;

                                                                                                                                                                                                                                                                                                                                                                    interface LanguageSettings

                                                                                                                                                                                                                                                                                                                                                                    interface LanguageSettings {}

                                                                                                                                                                                                                                                                                                                                                                      property aria

                                                                                                                                                                                                                                                                                                                                                                      aria?: LanguageAriaSettings | undefined;

                                                                                                                                                                                                                                                                                                                                                                        property decimal

                                                                                                                                                                                                                                                                                                                                                                        decimal?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                          property emptyTable

                                                                                                                                                                                                                                                                                                                                                                          emptyTable?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                            property info

                                                                                                                                                                                                                                                                                                                                                                            info?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                              property infoEmpty

                                                                                                                                                                                                                                                                                                                                                                              infoEmpty?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                property infoFiltered

                                                                                                                                                                                                                                                                                                                                                                                infoFiltered?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                  property infoPostFix

                                                                                                                                                                                                                                                                                                                                                                                  infoPostFix?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                    property lengthMenu

                                                                                                                                                                                                                                                                                                                                                                                    lengthMenu?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                      property loadingRecords

                                                                                                                                                                                                                                                                                                                                                                                      loadingRecords?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                        property paginate

                                                                                                                                                                                                                                                                                                                                                                                        paginate?: LanguagePaginateSettings | undefined;

                                                                                                                                                                                                                                                                                                                                                                                          property processing

                                                                                                                                                                                                                                                                                                                                                                                          processing?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                            property search

                                                                                                                                                                                                                                                                                                                                                                                            search?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                              property searchPlaceholder

                                                                                                                                                                                                                                                                                                                                                                                              searchPlaceholder?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                property thousands

                                                                                                                                                                                                                                                                                                                                                                                                thousands?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                  property url

                                                                                                                                                                                                                                                                                                                                                                                                  url?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                    property zeroRecords

                                                                                                                                                                                                                                                                                                                                                                                                    zeroRecords?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                      interface ObjectColumnData

                                                                                                                                                                                                                                                                                                                                                                                                      interface ObjectColumnData {}

                                                                                                                                                                                                                                                                                                                                                                                                        property display

                                                                                                                                                                                                                                                                                                                                                                                                        display?: string | number | FunctionColumnData | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                          property filter

                                                                                                                                                                                                                                                                                                                                                                                                          filter?: string | number | FunctionColumnData | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                            property sort

                                                                                                                                                                                                                                                                                                                                                                                                            sort?: string | number | FunctionColumnData | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                              type?: string | number | FunctionColumnData | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                interface ObjectColumnRender

                                                                                                                                                                                                                                                                                                                                                                                                                interface ObjectColumnRender {}

                                                                                                                                                                                                                                                                                                                                                                                                                  property display

                                                                                                                                                                                                                                                                                                                                                                                                                  display?: string | number | FunctionColumnRender | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                    property filter

                                                                                                                                                                                                                                                                                                                                                                                                                    filter?: string | number | FunctionColumnRender | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                      property sort

                                                                                                                                                                                                                                                                                                                                                                                                                      sort?: string | number | FunctionColumnRender | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                        type?: string | number | FunctionColumnRender | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                          interface ObjectOrderFixed

                                                                                                                                                                                                                                                                                                                                                                                                                          interface ObjectOrderFixed {}

                                                                                                                                                                                                                                                                                                                                                                                                                            property post

                                                                                                                                                                                                                                                                                                                                                                                                                            post?: any[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Two-element array: 0: Column index to order upon. 1: Direction so order to apply ("asc" for ascending order or "desc" for descending order).

                                                                                                                                                                                                                                                                                                                                                                                                                            property pre

                                                                                                                                                                                                                                                                                                                                                                                                                            pre?: any[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Two-element array: 0: Column index to order upon. 1: Direction so order to apply ("asc" for ascending order or "desc" for descending order).

                                                                                                                                                                                                                                                                                                                                                                                                                            interface ObjectSelectorModifier

                                                                                                                                                                                                                                                                                                                                                                                                                            interface ObjectSelectorModifier {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property order

                                                                                                                                                                                                                                                                                                                                                                                                                              order?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                              • The order modifier provides the ability to control which order the rows are processed in. Values: 'current', 'applied', 'index', 'original'

                                                                                                                                                                                                                                                                                                                                                                                                                              property page

                                                                                                                                                                                                                                                                                                                                                                                                                              page?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                              • The page modifier allows you to control if the selector should consider all data in the table, regardless of paging, or if only the rows in the currently disabled page should be used. Values: 'all', 'current'

                                                                                                                                                                                                                                                                                                                                                                                                                              property search

                                                                                                                                                                                                                                                                                                                                                                                                                              search?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                              • The search modifier provides the ability to govern which rows are used by the selector using the search options that are applied to the table. Values: 'none', 'applied', 'removed'

                                                                                                                                                                                                                                                                                                                                                                                                                              property searchPlaceholder

                                                                                                                                                                                                                                                                                                                                                                                                                              searchPlaceholder?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                              • The searchPlaceholder modifier provides the ability to provide informational text for an input control when it has no value.

                                                                                                                                                                                                                                                                                                                                                                                                                              interface objectTablesStatic

                                                                                                                                                                                                                                                                                                                                                                                                                              interface objectTablesStatic {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property api

                                                                                                                                                                                                                                                                                                                                                                                                                                api: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                • Return a DataTables API instance for the selected tables (true) or an array (false).

                                                                                                                                                                                                                                                                                                                                                                                                                                property visible

                                                                                                                                                                                                                                                                                                                                                                                                                                visible: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                • Get only visible tables (true) or all tables regardless of visibility (false).

                                                                                                                                                                                                                                                                                                                                                                                                                                interface OrderMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                interface OrderMethods {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  method fixed

                                                                                                                                                                                                                                                                                                                                                                                                                                  fixed: { (): ObjectOrderFixed; (order: ObjectOrderFixed): Api };
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the fixed ordering that is applied to the table. If there is more than one table in the API's context, the ordering of the first table will be returned only (use table() if you require the ordering of a different table in the API's context).

                                                                                                                                                                                                                                                                                                                                                                                                                                  • Set the table's fixed ordering. Note this doesn't actually perform the order, but rather queues it up - use draw() to perform the ordering.

                                                                                                                                                                                                                                                                                                                                                                                                                                  method listener

                                                                                                                                                                                                                                                                                                                                                                                                                                  listener: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  node: string | Node | JQuery,
                                                                                                                                                                                                                                                                                                                                                                                                                                  column: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                  callback: () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Add an ordering listener to an element, for a given column.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter node

                                                                                                                                                                                                                                                                                                                                                                                                                                    Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter column

                                                                                                                                                                                                                                                                                                                                                                                                                                    Column index

                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                                    Callback function

                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                  (): Array<Array<string | number>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the ordering applied to the table.

                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                  (order?: Array<string | number> | Array<Array<string | number>>): Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Set the ordering applied to the table.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter order

                                                                                                                                                                                                                                                                                                                                                                                                                                    Order Model

                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                  (order: Array<string | number>, ...args: any[]): Api;

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PageMethodeModelInfoReturn

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PageMethodeModelInfoReturn {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      property end

                                                                                                                                                                                                                                                                                                                                                                                                                                      end: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property length

                                                                                                                                                                                                                                                                                                                                                                                                                                        length: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property page

                                                                                                                                                                                                                                                                                                                                                                                                                                          page: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property pages

                                                                                                                                                                                                                                                                                                                                                                                                                                            pages: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property recordsDisplay

                                                                                                                                                                                                                                                                                                                                                                                                                                              recordsDisplay: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property recordsTotal

                                                                                                                                                                                                                                                                                                                                                                                                                                                recordsTotal: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property serverSide

                                                                                                                                                                                                                                                                                                                                                                                                                                                  serverSide: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                    start: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PageMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PageMethods {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method info

                                                                                                                                                                                                                                                                                                                                                                                                                                                        info: () => PageMethodeModelInfoReturn;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get paging information about the table

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method len

                                                                                                                                                                                                                                                                                                                                                                                                                                                        len: { (): number; (length: number): Api };
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get the table's page length.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Set the table's page length.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter length

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Page length to set. use -1 to show all records.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                        (): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get the current page of the table.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                        (page: number | string): Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Set the current page of the table.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter page

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Index or 'first', 'next', 'previous', 'last'

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RendererSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RendererSettings {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property header

                                                                                                                                                                                                                                                                                                                                                                                                                                                          header?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property pageButton

                                                                                                                                                                                                                                                                                                                                                                                                                                                            pageButton?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RowChildMethodModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RowChildMethodModel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method hide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                hide: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Hide the child row(s) of a parent row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isShown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                isShown: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Check if the child rows of a parent row are visible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                remove: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Remove child row(s) from display and release any allocated memory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                show: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Show the child row(s) of a parent row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                (): JQuery;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get the child row(s) that have been set for a parent row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                (showRemove: boolean): RowChildMethods;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get the child row(s) that have been set for a parent row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter showRemove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This parameter can be given as true or false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                data: (string | Node | JQuery) | Array<string | number | JQuery>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                className?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): RowChildMethods;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Set the data to show in the child row(s). Note that calling this method will replace any child rows which are already attached to the parent row.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The data to be shown in the child row can be given in multiple different ways.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Class name that is added to the td cell node(s) of the child row(s). As of 1.10.1 it is also added to the tr row node of the child row(s).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RowChildMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RowChildMethods extends CoreMethods {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method hide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hide: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Hide the child row(s) of a parent row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  remove: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Remove child row(s) from display and release any allocated memory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  show: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Make newly defined child rows visible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RowLegacy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RowLegacy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property nTr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nTr: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RowMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RowMethods extends CoreMethods, CommonRowMethod {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property child

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        child: RowChildMethodModel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Order Methods / object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data: { (): any[] | object; (d: object | any[]): Api };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get the data for the selected row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Set the data for the selected row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Data to use for the row.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id: (hash?: boolean) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get the id of the selected row. Since: 1.10.8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          true - Append a hash (#) to the start of the row id. This can be useful for then using the id as a selector false - Do not modify the id value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Row id. If the row does not have an id available 'undefined' will be returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get the row index of the row column.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: () => Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Obtain the tr node for the selected row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        remove: () => Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Delete the selected row from the DataTable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RowMethodsModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RowMethodsModel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          add: (data: any[] | object) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Add a new row to the table using the given data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Data to use for the new row. This may be an array, object or Javascript object instance, but must be in the same format as the other data in the table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (rowSelector: any, modifier?: ObjectSelectorModifier): RowMethods;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Select a row found by a row selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter rowSelector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Row selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter Option

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            used to specify how the cells should be ordered, and if paging or filtering in the table should be taken into account.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RowsMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RowsMethods extends CoreMethods, CommonRowMethod {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data: (d?: any[] | object) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Get / Set the data for the selected row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Data to use for the row.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method every

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            every: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            this: RowMethods,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rowIdx: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tableLoop: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rowLoop: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Iterate over each selected row, with the function context set to be the row in question. Since: DataTables 1.10.6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function to execute for every row selected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method ids

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ids: (hash?: boolean) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Get the ids of the selected rows. Since: 1.10.8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              true - Append a hash (#) to the start of each row id. This can be useful for then using the ids as selectors false - Do not modify the id value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Api instance with the selected rows in its result set. If a row does not have an id available 'undefined' will be returned as the value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method indexes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            indexes: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Get the row indexes of the selected rows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method nodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nodes: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Obtain the tr nodes for the selected rows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            remove: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Delete the selected rows from the DataTable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RowsMethodsModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RowsMethodsModel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              add: (data: any[]) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Add new rows to the table using the data given

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Array of data elements, with each one describing a new row to be added to the table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (modifier?: ObjectSelectorModifier): RowsMethods;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Select all rows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter Option

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                used to specify how the cells should be ordered, and if paging or filtering in the table should be taken into account.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (rowSelector: any, modifier?: ObjectSelectorModifier): RowsMethods;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Select rows found by a row selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter cellSelector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Row selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter Option

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                used to specify how the cells should be ordered, and if paging or filtering in the table should be taken into account.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ScrollingLegacy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ScrollingLegacy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bAutoCss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bAutoCss: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bCollapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bCollapse: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bInfinite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bInfinite: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property iBarWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iBarWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property iLoadGap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        iLoadGap: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property sX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sX: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property sY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sY: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SearchSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SearchSettings {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property caseInsensitive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                caseInsensitive?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Control case-sensitive filtering option. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property regex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                regex?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Enable / disable escaping of regular expression characters in the search term. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                search?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Set an initial filtering condition on the table. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property searchPlaceholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                searchPlaceholder?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Set a placeholder attribute for input type="text" tag elements. Since: 1.10.1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property smart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                smart?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Enable / disable DataTables' smart filtering. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Settings {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ajax

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ajax?: string | AjaxSettings | FunctionAjax | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Load data for the table's content from an Ajax source. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property autoWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  autoWidth?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Feature control DataTables' smart column width handling. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property columnDefs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  columnDefs?: ColumnDefsSettings[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Assign a column definition to one or more columns.. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  columns?: ColumnSettings[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Data to use as the display data for the table. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property createdRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createdRow?: FunctionCreateRow | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Callback for whenever a TR element is created for the table's body. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data?: any[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Data to use as the display data for the table. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property deferLoading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  deferLoading?: number | number[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Delay the loading of server-side data until second draw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property deferRender

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  deferRender?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Feature control deferred rendering for additional speed of initialisation. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  destroy?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Destroy any existing table matching the selector and replace with the new options. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property displayStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  displayStart?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Initial paging start point. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dom?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Define the table control elements to appear on the page and in what order. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property drawCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  drawCallback?: FunctionDrawCallback | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Function that is called every time DataTables performs a draw. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property footerCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  footerCallback?: FunctionFooterCallback | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Footer display callback function. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property formatNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  formatNumber?: FunctionFormatNumber | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Number formatting callback function. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property headerCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  headerCallback?: FunctionHeaderCallback | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Header display callback function. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  info?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Feature control table information display field. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property infoCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  infoCallback?: FunctionInfoCallback | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Table summary information display callback. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property initComplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  initComplete?: FunctionInitComplete | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Initialisation complete callback. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property jQueryUI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  jQueryUI?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use markup and classes for the table to be themed by jQuery UI ThemeRoller. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property language

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  language?: LanguageSettings | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property lengthChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lengthChange?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Feature control the end user's ability to change the paging display length of the table. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property lengthMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lengthMenu?: Array<number | string> | Array<Array<number | string>> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Change the options in the page length select list. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property order

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    order?: Array<number | string> | Array<Array<number | string>> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Initial order (sort) to apply to the table. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property orderCellsTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    orderCellsTop?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Control which cell the order event handler will be applied to in a column. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property orderClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    orderClasses?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Highlight the columns being ordered in the table's body. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property orderFixed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    orderFixed?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Array<number | string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Array<Array<number | string>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Ordering to always be applied to the table. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ordering

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ordering?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Feature control ordering (sorting) abilities in DataTables. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property orderMulti

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    orderMulti?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Multiple column ordering ability control. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property pageLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pageLength?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Change the initial page length (number of rows per page). Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property paging

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    paging?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enable or disable table pagination. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property pagingType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pagingType?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pagination button display options. Basic Types: numbers (1.10.8) simple, simple_numbers, full, full_numbers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property preDrawCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preDrawCallback?: FunctionPreDrawCallback | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Pre-draw callback. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property processing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    processing?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Feature control the processing indicator. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property renderer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    renderer?: string | RendererSettings | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Display component renderer types. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property responsive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    responsive?: boolean | object | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Enable or disable datatables responsive. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property retrieve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    retrieve?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Retrieve an existing DataTables instance. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rowCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rowCallback?: FunctionRowCallback | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Row draw callback.. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rowId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rowId?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Data property name that DataTables will use to set element DOM IDs. Since: 1.10.8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property scrollCollapse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scrollCollapse?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Allow the table to reduce in height when a limited number of rows are shown. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property scrollX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scrollX?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Horizontal scrolling. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property scrollY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scrollY?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Vertical scrolling. Since: 1.10 Exp: "200px"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    search?: SearchSettings | boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Set an initial filter in DataTables and / or filtering options. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property searchCols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    searchCols?: SearchSettings[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Define an initial search for individual columns. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property searchDelay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    searchDelay?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Set a throttle frequency for searching. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property searching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    searching?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Feature control search (filtering) abilities Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property searchPlaceholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    searchPlaceholder?: SearchSettings | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Set placeholder attribute for input type="text" tag elements. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property serverSide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    serverSide?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Feature control DataTables' server-side processing mode. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stateDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stateDuration?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Saved state validity duration. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stateLoadCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stateLoadCallback?: FunctionStateLoadCallback | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Callback that defines where and how a saved state should be loaded. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stateLoaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stateLoaded?: FunctionStateLoaded | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • State loaded callback. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stateLoadParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stateLoadParams?: FunctionStateLoadParams | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • State loaded - data manipulation callback. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stateSave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stateSave?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • State saving - restore table state on page reload. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stateSaveCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stateSaveCallback?: FunctionStateSaveCallback | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Callback that defines how the table state is stored and where. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stateSaveParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stateSaveParams?: FunctionStateSaveParams | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • State save - data manipulation callback. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stripeClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stripeClasses?: string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Set the zebra stripe class names for the rows in the table. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tabIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tabIndex?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tab index control for keyboard navigation. Since: 1.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SettingsLegacy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SettingsLegacy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property aanFeatures

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      aanFeatures: ArrayStringNode[][];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property aaSorting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        aaSorting: any[][];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property aaSortingFixed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          aaSortingFixed: any[][];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property aiDisplay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            aiDisplay: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property aiDisplayMaster

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              aiDisplayMaster: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property aIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                aIds: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ajax

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ajax: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property aLengthMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    aLengthMenu: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property aoColumns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      aoColumns: ColumnLegacy[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property aoData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        aoData: RowLegacy[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property aoDestroyCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          aoDestroyCallback: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property aoDrawCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            aoDrawCallback: FunctionDrawCallback[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property aoFooter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              aoFooter: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property aoFooterCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                aoFooterCallback: FunctionFooterCallback[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property aoHeader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  aoHeader: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property aoHeaderCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    aoHeaderCallback: FunctionHeaderCallback[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property aoInitComplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      aoInitComplete: FunctionInitComplete[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property aoOpenRows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        aoOpenRows: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property aoPreDrawCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          aoPreDrawCallback: FunctionPreDrawCallback[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property aoPreSearchCols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            aoPreSearchCols: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property aoRowCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              aoRowCallback: FunctionRowCallback[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property aoRowCreatedCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                aoRowCreatedCallback: FunctionCreateRow[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property aoServerParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  aoServerParams: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property aoStateLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    aoStateLoad: FunctionStateLoadCallback[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property aoStateLoaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      aoStateLoaded: FunctionStateLoaded[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property aoStateLoadParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        aoStateLoadParams: FunctionStateLoadParams[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property aoStateSave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          aoStateSave: FunctionStateSaveCallback[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property aoStateSaveParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            aoStateSaveParams: FunctionStateSaveParams[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property asDataSearch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asDataSearch: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property asDestroyStripes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                asDestroyStripes: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property asStripeClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  asStripeClasses: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bAjaxDataGet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bAjaxDataGet: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bDeferLoading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bDeferLoading: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bDrawing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bDrawing: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bFiltered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bFiltered: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bInitialized

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bInitialized: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bJUI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bJUI: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bSortCellsTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bSortCellsTop: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bSorted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bSorted: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fnCookieCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fnCookieCallback: CookieCallbackLegacy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fnFormatNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fnFormatNumber: FunctionFormatNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fnServerData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fnServerData: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property iCookieDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          iCookieDuration: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property iDraw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            iDraw: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property iDrawError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              iDrawError: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property iTabIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                iTabIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property jqXHR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  jqXHR: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property nScrollFoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nScrollFoot: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property nScrollHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nScrollHead: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property nTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        nTable: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property nTableWrapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nTableWrapper: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property nTBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nTBody: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property nTFoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nTFoot: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property nTHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nTHead: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property oApi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  oApi: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property oBrowser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    oBrowser: BrowserLegacy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property oClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      oClasses: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property oFeatures

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        oFeatures: FeaturesLegacy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property oInit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          oInit: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property oInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            oInstance: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property oLanguage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              oLanguage: LanguageLegacy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property oLoadedState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                oLoadedState: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property oPreviousSearch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  oPreviousSearch: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property oScroll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    oScroll: ScrollingLegacy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sAjaxDataProp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sAjaxDataProp: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property sAjaxSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sAjaxSource: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property sCookiePrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sCookiePrefix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property sDestroyWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sDestroyWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sDom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sDom: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property sInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sInstance: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property sPaginationType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sPaginationType: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property sServerMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sServerMethod: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sTableId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sTableId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method fnDisplayEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fnDisplayEnd: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method fnRecordsDisplay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fnRecordsDisplay: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method fnRecordsTotal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fnRecordsTotal: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method rowIdFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rowIdFn: (mSource: string | number | (() => void)) => () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface StateMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface StateMethods {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  clear: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Clear the saved state of the table.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method loaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  loaded: () => StateReturnModel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the table state that was loaded during initialisation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method save

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  save: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Trigger a state save.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (): StateReturnModel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the last saved state of the table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface StateReturnModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface StateReturnModel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    columns: StateReturnModelColumns[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      length: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property order

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        order: Array<Array<string | number>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          search: SearchSettings;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            start: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              time: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface StateReturnModelColumns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface StateReturnModelColumns {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  search: SearchSettings;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property visible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    visible: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface StaticFunctions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface StaticFunctions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Api

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Api: new (selector: string | Node | Node[] | JQuery | SettingsLegacy) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get DataTable API instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selector string for table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaults: Settings;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Default Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ext: ExtSettings;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Default Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        render: StaticRenderFunctions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Helpers for columns.render.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The options defined here can be used with the columns.render initialisation option to provide a display renderer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property util

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        util: StaticUtilFunctions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Utils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isDataTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDataTable: (table: string | Node | JQuery | Api) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Check if a table node is a DataTable already or not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Usage: $.fn.dataTable.isDataTable("selector");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The table to check.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method tables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tables: (visible?: boolean | objectTablesStatic) => Api[] | Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get all DataTable tables that have been initialised - optionally you can select to get only currently visible tables and / or retrieve the tables as API instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter visible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          As a boolean value this options is used to indicate if you want all tables on the page should be returned (false), or visible tables only (true). Since 1.10.8 this option can also be given as an object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method versionCheck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        versionCheck: (version: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Version number compatibility check function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Usage: $.fn.dataTable.versionCheck("1.10.0");

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Version string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (): JQueryDataTables;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns JQuery object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Usage: $( selector ).dataTable();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface StaticRenderFunctions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface StaticRenderFunctions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          number: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          thousands: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          decimal: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          precision: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          prefix?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          postfix?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => ObjectColumnRender;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Will format numeric data (defined by columns.data) for display, retaining the original unformatted data for sorting and filtering.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter thousands

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Thousands grouping separator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter decimal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Decimal point indicator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter precision

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Integer number of decimal points to show.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Prefix (optional).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter postfix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Postfix (/suffix) (optional).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          text: () => ObjectColumnRender;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Escape HTML to help prevent XSS attacks. It has no optional parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface StaticUtilFunctions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface StaticUtilFunctions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method escapeRegex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            escapeRegex: (str: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Escape special characters in a regular expression string. Since: 1.10.4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter str

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              String to escape

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method throttle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            throttle: (fn: FunctionThrottle, period?: number) => () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Throttle the calls to a method to reduce call frequency. Since: 1.10.3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter period

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TableMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TableMethods extends CoreMethods {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              body: () => Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the tbody node for the table in the API's context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              container: () => Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the div container node for the table in the API's context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method footer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              footer: () => Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the tfoot node for the table in the API's context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              header: () => Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the thead node for the table in the API's context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: () => Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the table node for the table in the API's context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TablesMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TablesMethods extends CoreMethods {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get the tbody nodes for the tables in the API's context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method containers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                containers: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get the div container nodes for the tables in the API's context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method footer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                footer: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get the tfoot nodes for the tables in the API's context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                header: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get the thead nodes for the tables in the API's context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method nodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nodes: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get the table nodes for the tables in the API's context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface UtilityMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface UtilityMethods {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  length: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Number of elements in an API instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  any: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method concat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    concat: (a: object, ...b: object[]) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Concatenate two or more API instances together

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      API instance to concatenate to the initial instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Additional API instance(s) to concatenate to the initial instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method count

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    count: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the number of entries in an API instance's result set, regardless of multi-table grouping (e.g. any data, selected rows, etc). Since: 1.10.8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method each

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    each: (fn: (value: any, index: number, dt: Api) => void) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Iterate over the contents of the API result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Callback function which is called for each item in the API instance result set. The callback is called with three parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method eq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    eq: (idx: number) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reduce an Api instance to a single context and result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter idx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index to select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filter: (fn: (value: any, index: number, dt: Api) => boolean) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Iterate over the result set of an API instance and test each item, creating a new instance from those items which pass.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Callback function which is called for each item in the API instance result set. The callback is called with three parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method flatten

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    flatten: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Flatten a 2D array structured API instance to a 1D array structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method indexOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    indexOf: (value: any) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Find the first instance of a value in the API instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Value to find in the instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method join

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    join: (separator: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Join the elements in the result set into a string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter separator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The string that will be used to separate each element of the result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method lastIndexOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lastIndexOf: (value: any) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Find the last instance of a value in the API instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Value to find in the instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    map: (fn: (value: any, index: number, dt: Api) => any) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Iterate over the result set of an API instance, creating a new API instance from the values returned by the callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Callback function which is called for each item in the API instance result set. The callback is called with three parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method pluck

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pluck: (property: number | string) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Iterate over the result set of an API instance, creating a new API instance from the values retrieved from the original elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      object property name to use from the element in the original result set for the new result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method pop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pop: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Remove the last item from an API instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method push

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    push: (value_1: any, ...value_2: any[]) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Add one or more items to the end of an API instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter value_1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Item to add to the API instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method reduce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reduce: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fn: (current: number, value: any, index: number, dt: Api) => number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initialValue?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Apply a callback function against and accumulator and each element in the Api's result set (left-to-right).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Callback function which is called for each item in the API instance result set. The callback is called with four parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter initialValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Value to use as the first argument of the first call to the fn callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method reduceRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reduceRight: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fn: (current: number, value: any, index: number, dt: Api) => number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initialValue?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Apply a callback function against and accumulator and each element in the Api's result set (right-to-left).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Callback function which is called for each item in the API instance result set. The callback is called with four parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter initialValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Value to use as the first argument of the first call to the fn callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reverse: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reverse the result set of the API instance and return the original array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method shift

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shift: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Remove the first item from an API instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method sort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sort: (fn?: (value1: any, value2: any) => number) => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Sort the elements of the API instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This is a standard Javascript sort comparison function. It accepts two parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method splice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    splice: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    howMany: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value_1?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...value_2: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Modify the contents of an Api instance's result set, adding or removing items from it as required.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Index at which to start modifying the Api instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter howMany

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number of elements to remove from the result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter value_1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Item to add to the result set at the index specified by the first parameter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method to$

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    to$: () => JQuery;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Convert the API instance to a jQuery object, with the objects from the instance's result set in the jQuery result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toArray: () => any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Create a native Javascript array object from an API instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toJQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toJQuery: () => JQuery;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Convert the API instance to a jQuery object, with the objects from the instance's result set in the jQuery result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method unique

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unique: () => Api;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Create a new API instance containing only the unique items from a the elements in an instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method unshift

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unshift: (value_1: any, ...value_2: any[]) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Add one or more items to the start of an API instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter value_1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Item to add to the API instance's result set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CookieCallbackLegacy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CookieCallbackLegacy = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    expires: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cookie: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FunctionAjax

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FunctionAjax = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      data: object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: (data: any) => void,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      settings: SettingsLegacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FunctionAjaxData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FunctionAjaxData = (data: object, settings: Settings) => string | object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FunctionColumnCreatedCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FunctionColumnCreatedCell = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cell: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cellData: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rowData: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          row: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          col: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FunctionColumnRender

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FunctionColumnRender = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            row: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            meta: CellMetaSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FunctionCreateRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FunctionCreateRow = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              row: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              data: any[] | object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dataIndex: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FunctionDrawCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FunctionDrawCallback = (settings: SettingsLegacy) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FunctionExtTypeSettingsDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FunctionExtTypeSettingsDetect = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  settings: Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Parameter data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Data from the column cell to be analysed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter DataTables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    settings object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FunctionFooterCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FunctionFooterCallback = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tfoot: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: any[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  end: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  display: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FunctionFormatNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FunctionFormatNumber = (formatNumber: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FunctionHeaderCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FunctionHeaderCallback = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      thead: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      data: any[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      end: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      display: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FunctionInfoCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FunctionInfoCallback = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        settings: SettingsLegacy,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        end: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mnax: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        total: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pre: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FunctionInitComplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FunctionInitComplete = (settings: SettingsLegacy, json: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FunctionPreDrawCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FunctionPreDrawCallback = (settings: SettingsLegacy) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FunctionRowCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FunctionRowCallback = (row: Node, data: any[] | object, index: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FunctionStateLoadCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FunctionStateLoadCallback = (settings: SettingsLegacy) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FunctionStateLoaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FunctionStateLoaded = (settings: SettingsLegacy, data: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FunctionStateLoadParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FunctionStateLoadParams = (settings: SettingsLegacy, data: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FunctionStateSaveCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FunctionStateSaveCallback = (settings: SettingsLegacy, data: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FunctionStateSaveParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FunctionStateSaveParams = (settings: SettingsLegacy, data: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FunctionThrottle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FunctionThrottle = (data: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/datatables.net.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/datatables.net)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@types/datatables.net"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>