diff --git a/jquery.dynatable/jquery.dynatable-tests.ts b/jquery.dynatable/jquery.dynatable-tests.ts
new file mode 100644
index 000000000..7a9f3aab7
--- /dev/null
+++ b/jquery.dynatable/jquery.dynatable-tests.ts
@@ -0,0 +1,229 @@
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="jquery.dynatable.d.ts"/>
+
+
+// Using the global setup option
+// =============================
+$.dynatableSetup({ features: { pushState: false }, dataset: { perPageDefault: 5, perPageOptions: [2, 5, 10] } });
+
+
+// Without any settings (using all defaults)
+// =========================================
+var dynatableWithDefaultSettings = $('#example-table').dynatable();
+
+
+// Building a config piece by piece
+// ================================
+// JQueryDynatable.Features
+var featsConfig: JQueryDynatable.Features = {
+    paginate: true,
+    sort: false,
+    pushState: true,
+    search: true,
+    recordCount: true,
+    perPageSelect: true
+};
+var featsPartialConfig: JQueryDynatable.Features = {
+    search: false,
+    paginate: false
+};
+// JQueryDynatable.Column
+var col: JQueryDynatable.Column = {
+    index: 0,
+    label: 'Col from JS',
+    id: 'someColId',
+    attributeWriter: function myAttrWriter(data: any): any {
+        return data[this.id];
+    },
+    attributeReader: function myAttrReader(cell: Element, data: any): string {
+        return $(cell).html();
+    },
+    sorts: ['un', 'deux'],
+    hidden: false,
+    textAlign: 'right'
+};
+// JQueryDynatable.Table
+var tableConfig: JQueryDynatable.Table = {
+    defaultColumnIdStyle: 'underscore',
+    columns: [col], // Just for fun & testing... because will be reset by dynatable
+    headRowSelector: '.my-head-row-selector',
+    bodyRowSelector: 'tbody tr',
+    headRowClass: 'custom-head-row-class'
+};
+var tablePartialConfig: JQueryDynatable.Table = {
+    defaultColumnIdStyle: 'trimDash'
+};
+// JQueryDynatable.Inputs
+var tableInputs: JQueryDynatable.Inputs = {
+    // Must match exactly target value, strict comparison!
+    queries: $('#countryFilter, #yearFilter'),
+    // I believe this setting is unused!
+    sorts: null,
+    multisort: ['shiftKey'],
+    // I believe this setting is unused!
+    page: null,
+    queryEvent: 'keyup',
+    recordCountTarget: $('#record-count'),
+    recordCountPlacement: 'after',
+    paginationLinkTarget: '#record-count',
+    paginationLinkPlacement: 'before',
+    paginationClass: 'paginationClass',
+    paginationLinkClass: 'paginationLinkClass',
+    paginationPrevClass: 'paginationPrevClass',
+    paginationNextClass: 'paginationNextClass',
+    paginationActiveClass: 'paginationActiveClass',
+    paginationDisabledClass: 'paginationDisabledClass',
+    paginationPrev: '&lt; Prev.',
+    paginationNext: 'Next &gt;',
+    paginationGap: [3, 1, 1, 3],
+    searchTarget: $('#record-count').get(0),
+    searchPlacement: 'after',
+    searchText: 'Search: ',
+    perPageTarget: '#record-count',
+    perPagePlacement: 'before',
+    perPageText: 'Display: ',
+    pageText: 'Pages: ',
+    recordCountPageBoundTemplate: '{pageLowerBound} t-o {pageUpperBound} o-f',
+    recordCountPageUnboundedTemplate: '{recordsShown} -of-',
+    recordCountTotalTemplate: '{recordsQueryCount} x {collectionName}',
+    recordCountFilteredTemplate: ' (found from {recordsTotal} total entries)',
+    recordCountText: 'Rendering',
+    recordCountTextTemplate: '{text} {pageTemplate} {totalTemplate} {filteredTemplate}',
+    recordCountTemplate: '<span id="dynatable-record-count-{elementId}" class="dynatable-record-count">!!{textTemplate}!!</span>',
+    processingText: 'Working...'
+};
+// JQueryDynatable.Dataset
+var tableDataset: JQueryDynatable.Dataset = {
+    ajax: false,
+    ajaxUrl: null,
+    ajaxCache: null,
+    ajaxOnLoad: false,
+    ajaxMethod: 'GET',
+    ajaxDataType: 'json',
+    totalRecordCount: null,
+    queries: {},
+    queryRecordCount: null,
+    page: null,
+    perPageDefault: 3,
+    perPageOptions: [2, 3, 10],
+    sorts: {},
+    sortsKeys: [],
+    sortTypes: {},
+    records: null
+};
+// JQueryDynatable.Writers
+var tableWriters: JQueryDynatable.Writers = {
+    _rowWriter: function exampleRowWriter(rowIndex, record, columns, cellWriter) {
+        var tr = '';
+        // grab the record's attribute for each column
+        for (var i = 0, len = columns.length; i < len; i++) {
+            tr += cellWriter(columns[i], record);
+        }
+        return '<tr>' + tr + '</tr>';
+    },
+    _cellWriter: function exampleCellWriter(column, record) {
+        var html = column.attributeWriter(record),
+            td = '<td';
+
+        if (column.hidden || column.textAlign) {
+            td += ' style="';
+
+            // keep cells for hidden column headers hidden
+            if (column.hidden) {
+                td += 'display: none;';
+            }
+
+            // keep cells aligned as their column headers are aligned
+            if (column.textAlign) {
+                td += 'text-align: ' + column.textAlign + ';';
+            }
+
+            td += '"';
+        }
+
+        return td + '>' + html + '</td>';
+    },
+    _attributeWriter: function exampleAttributeWriter(record) {
+        // `this` is the column object in settings.columns
+        return record[this.id];
+    }
+};
+// JQueryDynatable.Readers
+var tableReaders: JQueryDynatable.Readers = {
+    _rowReader: null,
+    _attributeReader: function exampleAttributeReader(cell, record) {
+        return $(cell).html();
+    }
+};
+// JQueryDynatable.Params
+var tableParams: JQueryDynatable.Params = {
+    dynatable: 'dynatable',
+    queries: 'queries',
+    sorts: 'sorts',
+    page: 'page',
+    perPage: 'perPage',
+    offset: 'offset',
+    records: 'records',
+    record: null,
+    queryRecordCount: 'queryRecordCount',
+    totalRecordCount: 'totalRecordCount'
+};
+var dynatableOptions: JQueryDynatable.Options = {
+    // Grouping config components
+    features: featsConfig,
+    table: tableConfig,
+    inputs: tableInputs,
+    dataset: tableDataset,
+    writers: tableWriters,
+    readers: tableReaders,
+    params: tableParams
+};
+// Init with the options
+var dynatableWithOptions = $('#example-with-options').dynatable(dynatableOptions);
+
+// Inline config
+// =============
+// Init with the options
+var dynatableWithInlineOptions = $('#example-with-inline-options').dynatable({
+    features: {
+        paginate: false,
+        search: false,
+        sort: true
+    }
+});
+
+
+// Using $element
+// ==============
+var dtable: JQueryDynatable.Dynatable = $('#testing-element').dynatable().data('dynatable');
+dtable.$element.addClass('some-class-to-be-added-on-the-element');
+
+
+// Using the API
+// =============
+// domColumns API
+dtable.domColumns.add($('<th>A</th>'), 0, false, true);
+dtable.domColumns.add($('<th>B</th>'), 1, false, true);
+// dom API
+dtable.dom.update(); // update the dom with the current record set
+// paginationPage API
+dtable.paginationPage.set(2);
+// paginationPerPage API
+dtable.paginationPerPage.set(1, true);
+// processingIndicator API
+setTimeout(function() { dtable.processingIndicator.show(); }, 1000);
+setTimeout(function() { dtable.processingIndicator.hide(); }, 3000);
+// queries API
+// records API
+// recordsCount API
+// settings API
+// sorts API
+dtable.sorts.clear();
+dtable.sorts.add('theRank', -1) // 1=ASCENDING, -1=DESCENDING
+dtable.sorts.remove('country');
+dtable.process();
+// sortsHeaders API
+// state API
+
+// Creating a Custom Sort Function
+// dynatable.queries.functions['max-price'] = function(record, queryValue) {
diff --git a/jquery.dynatable/jquery.dynatable.d.ts b/jquery.dynatable/jquery.dynatable.d.ts
new file mode 100644
index 000000000..5158b2240
--- /dev/null
+++ b/jquery.dynatable/jquery.dynatable.d.ts
@@ -0,0 +1,1155 @@
+// Type definitions for jquery.dynatable v0.3.1
+// Project: http://www.dynatable.com/
+// Definitions by: François Massart <https://github.com/francoismassart/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts" />
+
+interface JQuery {
+    /**
+    * @constructor
+    */
+    dynatable: JQueryDynatable.Dynatable;
+}
+
+/** Static members of jQuery (those on $ and jQuery themselves) */
+interface JQueryStatic {
+    /**
+     * Global dynatable plugin setting defaults
+     *
+     * @param options The configuration options to be set globally
+     */
+    dynatableSetup(options: JQueryDynatable.Options): void;
+}
+
+declare module JQueryDynatable {
+    interface Features {
+        /**
+         * Enable the pagination feature
+         * 
+         * @default true
+         */
+        paginate?: boolean;
+        /**
+         * Enable the sorting feature
+         * 
+         * @default true
+         */
+        sort?: boolean;
+        /**
+         * Enable the pushState feature
+         * Used to update the page URL parameters and cache the query result for the browser's forward- and back-buttons
+         *
+         * @default true
+         */
+        pushState?: boolean;
+        /**
+         * Enable the search feature
+         * 
+         * @default true
+         */
+        search?: boolean;
+        /**
+         * Enable the recordCount feature
+         * When pagination is enabled, dynatable will also show the currently displayed records and the total number of records
+         *
+         * @default true
+         */
+        recordCount?: boolean;
+        /**
+         * Enable the perPageSelect feature
+         * The perPageSelect will insert a form control filled with the options from `perPageOptions`
+         * 
+         * @default true
+         */
+        perPageSelect?: boolean;
+    }
+    interface Column {
+        index: number;
+        label: string;
+        /** 
+         * Determined by the `data-dynatable-column` or using the `defaultColumnIdStyle` 
+         *
+         * @example
+         * // Using the `defaultColumnIdStyle` of `camelCase`
+         * // `<th>Favorite Music</th>` would be translated into the id `favoriteMusic`
+         */
+        id: string;
+        /**
+         * Function that returns the cell data to be written inside the cell
+         *
+         * @param record A data object representing the current line of data
+         * @return The data for the current cell
+         * 
+         * @example
+         * function exampleAttributeWriter(record) {
+         *     return record[this.id];
+         * };
+         */
+        attributeWriter: (record: any) => any;
+        /**
+         * Function that interprets the cell html data in order to convert it into data
+         *
+         * @param cell A html node of the target cell
+         * @param record A data object representing the current line of data
+         * @return the html content for the current cell
+         * 
+         * @example
+         * function exampleAttributeReader(cell, record) {
+         *     return $(cell).html();
+         * };
+         */
+        attributeReader: (cell: Element, record: any) => string;
+        /** List of ids for sorting, generated by the plugin, can be tweaked by using `data-dynatable-sorts` */
+        sorts: Array<string>;
+        hidden: boolean;
+        /**
+         * Detected internally by dynatable.
+         * Possible values are:
+         *
+         * @enum('left', 'right', 'center', 'justify', 'initial', 'inherit')
+         */
+        textAlign: string;
+    }
+    interface Table {
+        /**
+         * By default, dynatable converts headings to JSON attribute names using:
+         *
+         * @enum('camelCase', 'trimDash', 'dashed', 'underscore', 'lowercase')
+         * @default 'camelCase'
+         * @see http://www.dynatable.com/#converting-attribute-names
+         *
+         * @example
+         * // Given the html `<th>Favorite Music</th>` column header
+         * // `camelCase` would translate it to id `favoriteMusic`
+         * // `trimDash` would translate it to id `Favorite-Music`
+         * // `dashed` would translate it to id `favorite-music`
+         * // `underscore` would translate it to id `favorite_music`
+         * // `lowercase` would translate it to id `favorite music`
+         */
+        defaultColumnIdStyle?: string;
+        /** Generated internally by the plugin, will be reset by the DomColumns at init */
+        columns?: Array<JQueryDynatable.Column>;
+        /**
+         * Selector used by dynatable in order to find the table header row
+         * 
+         * @default 'thead tr'
+         */
+        headRowSelector?: string;
+        /**
+         * Selector used by dynatable in order to find the table body rows
+         * 
+         * @default 'tbody tr'
+         */
+        bodyRowSelector?: string;
+        /**
+         * Optional classname that can be added by dynatable to the header cells
+         * 
+         * @default null
+         */
+        headRowClass?: string;
+    }
+    interface Inputs {
+        /**
+         * Allows you to provide an array of jQuery objects which point to our filter inputs.
+         * The inputs musts have a name attribute value matching a columnId in order to work.
+         * Input values must strictly match the data from the cell...
+         * Searching for "Lux" won't show "Luxembourg" event if it starts if the same letters!
+         *
+         * @default null
+         * @see http://www.dynatable.com/#querying
+         * 
+         * @example
+         * $('#search-year')
+         */
+        queries?: JQuery;
+        /**
+         * @todo Find out how this `inputs.sorts` setting is useful + show an example
+         * @default null
+         * @see http://www.dynatable.com/#sorting
+         */
+        sorts?: any;
+        /**
+         * Allows you to define the accepted modifier keys to trigger a multisort action
+         *
+         * @default ['ctrlKey', 'shiftKey', 'metaKey']
+         * @see https://en.wikipedia.org/wiki/Modifier_key
+         */
+        multisort?: Array<string>;
+        /**
+         * @todo Find out how this `inputs.page` setting is useful + show an example
+         * @default null
+         */
+        page?: any;
+        /**
+         * The events attached to the search/filtering inputs elements
+         *
+         * @default 'blur change'
+         */
+        queryEvent?: string;
+        /**
+         * The jQuery object pointing to a target where to insert the recordCount html
+         *
+         * @default null
+         * 
+         * @example
+         * $('#chart-status-text')
+         */
+        recordCountTarget?: JQuery;
+        /**
+         * Determines where the recordCount is inserted
+         *
+         * @enum('before', 'after')
+         * @default 'after'
+         * @see http://api.jquery.com/category/manipulation/dom-insertion-outside/
+         */
+        recordCountPlacement?: string;
+        /**
+         * The target inside next to which the pagination block will be inserted (before or after).
+         * You can use a selector string, an Element or a JQuery.
+         *
+         * @default null
+         */
+        paginationLinkTarget?: string|Element|JQuery;
+        /**
+         * Determines where the pagination links are inserted
+         *
+         * @enum('before', 'after')
+         * @default 'after'
+         * @see http://api.jquery.com/category/manipulation/dom-insertion-outside/
+         */
+        paginationLinkPlacement?: string;
+        /**
+         * The classname to be injected on the `<ul>` containing the pagination
+         *
+         * @default 'dynatable-pagination-links'
+         */
+        paginationClass?: string;
+        /**
+         * The classname to be injected on every pagination link
+         *
+         * @default 'dynatable-page-link'
+         */
+        paginationLinkClass?: string;
+        /**
+         * The classname to be injected on the previous page link
+         *
+         * @default 'dynatable-page-prev'
+         */
+        paginationPrevClass?: string;
+        /**
+         * The classname to be injected on the next page link
+         *
+         * @default 'dynatable-page-next'
+         */
+        paginationNextClass?: string;
+        /**
+         * The classname to be injected on the current page link
+         *
+         * @default 'dynatable-active-page'
+         */
+        paginationActiveClass?: string;
+        /**
+         * The classname to be injected on the disabled page links
+         *
+         * @default 'dynatable-disabled-page'
+         */
+        paginationDisabledClass?: string;
+        /**
+         * Text content for the previous page link
+         * 
+         * @default 'Previous'
+         */
+        paginationPrev?: string;
+        /**
+         * Text content for the next page link
+         * 
+         * @default 'Next'
+         */
+        paginationNext?: string;
+        /**
+         * Define the number of page number links shown inside the pagination
+         *
+         * @default [1,2,2,1]
+         */
+        paginationGap?: Array<number>;
+        /**
+         * The target next to which the search block will be inserted (before or after).
+         * You can use a selector string, an Element or a JQuery.
+         *
+         * @default null
+         */
+        searchTarget?: string|Element|JQuery;
+        /**
+         * Determines where the search field is inserted
+         *
+         * @enum('before', 'after')
+         * @default 'before'
+         * @see http://api.jquery.com/category/manipulation/dom-insertion-outside/
+         */
+        searchPlacement?: string;
+        /**
+         * Text preceding the search field
+         *
+         * @default 'Search: '
+         */
+        searchText?: string;
+        /**
+         * The target next to which the per page pagination block will be inserted (before or after).
+         * You can use a selector string, an Element or a jQuery object.
+         *
+         * @default null
+         */
+        perPageTarget?: string|Element|JQuery;
+        /**
+         * Determines where the perPage menu is inserted
+         *
+         * @enum('before', 'after')
+         * @default 'before'
+         * @see http://api.jquery.com/category/manipulation/dom-insertion-outside/
+         */
+        perPagePlacement?: string;
+        /**
+         * Text content preceding the items per page <select>
+         * 
+         * @default 'Show: '
+         */
+        perPageText?: string;
+        /**
+         * Text content introducing the pagination
+         * 
+         * @default 'Pages: '
+         */
+        pageText?: string;
+        /**
+         * Text content used inside the recordsCount
+         * 
+         * @default '{pageLowerBound} to {pageUpperBound} of'
+         */
+        recordCountPageBoundTemplate?: string;
+        /**
+         * Text content used inside the recordsCount
+         * 
+         * @default '{recordsShown} of'
+         */
+        recordCountPageUnboundedTemplate?: string;
+        /**
+         * Text content used inside the recordsCount
+         * 
+         * @default '{recordsQueryCount} {collectionName}'
+         */
+        recordCountTotalTemplate?: string;
+        /**
+         * Text content used inside the recordsCount
+         * 
+         * @default ' (filtered from {recordsTotal} total records)'
+         */
+        recordCountFilteredTemplate?: string;
+        /**
+         * Text content used inside the recordsCount
+         * 
+         * @default 'Showing '
+         */
+        recordCountText?: string;
+        /**
+         * Text content used inside the recordsCount
+         * 
+         * @default '{text} {pageTemplate} {totalTemplate} {filteredTemplate}'
+         */
+        recordCountTextTemplate?: string;
+        /**
+         * Text content used inside the recordsCount
+         * 
+         * @default '<span id="dynatable-record-count-{elementId}" class="dynatable-record-count">{textTemplate}</span>'
+         */
+        recordCountTemplate?: string;
+        /**
+         * Text content injected inside the processingIndicator
+         * 
+         * @default 'Processing...'
+         */
+        processingText?: string;
+    }
+    interface Dataset {
+        /**
+         * Enable the `ajax` mode
+         * 
+         * @default false
+         */
+        ajax?: boolean;
+        /**
+         * A string containing the URL to which the request is sent.
+         * 
+         * @default null
+         */
+        ajaxUrl?: string;
+        /**
+         * Defining the `cache` setting for the jQuery's ajax call...
+         * true or false for dataType 'script' and 'jsonp'
+         * 
+         * @default null
+         * @see http://api.jquery.com/jQuery.ajax
+         */
+        ajaxCache?: boolean;
+        /**
+         * Send the ajax request automatically
+         * 
+         * @default false
+         */
+        ajaxOnLoad?: boolean;
+        /**
+         * Defining the `method` setting for the jQuery's ajax call...
+         * The HTTP method to use for the request (e.g. "POST", "GET", "PUT"). 
+         * 
+         * @enum('GET', 'POST')
+         * @default 'GET'
+         * @todo Check if other methods could be used... ('GET', 'PUT', 'HEAD', 'POST', 'PATCH', 'TRACE', 'DELETE', 'CONNECT', 'OPTIONS', 'IS_AWARE', 'IS_EAGER', 'PROPFIND', 'IS_OPTIONAL', 'IS_REQUIRED', 'IS_CONSTRUCTOR', 'IS_INSTANTIATOR')
+         */
+        ajaxMethod?: string;
+        /**
+         * The type of data that you're expecting back from the server. 
+         * If none is specified, jQuery will try to infer it based on the MIME type of the response...
+         * 
+         * @enum('xml', 'html', 'script', 'json', 'jsonp', 'text')
+         * @default 'json'
+         * @see http://api.jquery.com/jQuery.ajax
+         */
+        ajaxDataType?: string;
+        /**
+         * Name of the property in the dataset that contains the total number of records 
+         * 
+         * @default null
+         */
+        totalRecordCount?: string;
+        /**
+         * Object describing the current request's filtering
+         * 
+         * @default {}
+         */
+        queries?: Object;
+        /**
+         * Name of the property in the dataset that contains the total number of records for the current query
+         * 
+         * @default null
+         */
+        queryRecordCount?: string;
+        /**
+         * The page represented in the for the current dataset
+         * 
+         * @default null
+         */
+        page?: number;
+        /**
+         * The default number of items loaded per page
+         * 
+         * @default 10
+         */
+        perPageDefault?: number;
+        /**
+         * The default options available in the perPage menu built by dynatable
+         * 
+         * @default [10,20,50,100]
+         */
+        perPageOptions?: Array<number>;
+        /**
+         * Object describing the current request's sorting
+         * 
+         * @default {}
+         */
+        sorts?: Object;
+        /**
+         * The sorting keys (generated by dynatable)
+         * 
+         * @default null
+         */
+        sortsKeys?: Array<string>;
+        /**
+         * The sorting types (generated by dynatable)
+         * It will hosts the type of object to sort (string, number, etc.)
+         * 
+         * @default {}
+         */
+        sortTypes?: Object;
+        /**
+         * The core data (generated or loaded by dynatable)
+         * 
+         * @default null
+         */
+        records?: any;
+    }
+    interface Writers {
+        /**
+         * Function that write the data inside each row
+         *
+         * @param rowIndex The index of the current row (from 0 to the perPage value)
+         * @param record A data object containing all the data for the current record (current line)
+         * @param columns  An array of columns
+         * @param cellWriter A reference to the function responsible for writing inside the cell
+         * @return the data for the current cell
+         *
+         * @default defaultRowWriter
+         * 
+         * @example
+         * function exampleRowWriter(rowIndex, record, columns, cellWriter) {
+         *     var tr = '';
+         *     // grab the record's attribute for each column
+         *     for (var i = 0, len = columns.length; i < len; i++) {
+         *         tr += cellWriter(columns[i], record);
+         *     }
+         *     return '<tr>' + tr + '</tr>';
+         * };
+         */
+        _rowWriter?: (rowIndex: number, record: any, columns: Array<Column>, cellWriter: Function) => string;
+        /**
+         * Function that returns the HTML code that will be injected for the cell
+         *
+         * @param column The column object describing the config for the current column
+         * @param record A data object representing the current line of data
+         * @return the data for the current cell
+         *
+         * @default defaultCellWriter
+         * 
+         * @example
+         * function exampleCellWriter(column, record) {
+         *     var html = column.attributeWriter(record),
+         *     td = '<td';
+         * 
+         *     if (column.hidden || column.textAlign) {
+         *         td += ' style="';
+         * 
+         *         // keep cells for hidden column headers hidden
+         *         if (column.hidden) {
+         *             td += 'display: none;';
+         *         }
+         * 
+         *         // keep cells aligned as their column headers are aligned
+         *         if (column.textAlign) {
+         *             td += 'text-align: ' + column.textAlign + ';';
+         *         }
+         * 
+         *         td += '"';
+         *     }
+         * 
+         *     return td + '>' + html + '</td>';
+         * };
+         */
+        _cellWriter?: (column: Column, record: any) => string;
+        /**
+         * Function that returns the cell data to be written inside the cell
+         *
+         * @param record A data object representing the current line of data
+         * @return the data for the current cell
+         * 
+         * @default defaultAttributeWriter
+         *
+         * @example
+         * function exampleAttributeWriter(record) {
+         *     // `this` is the column object in settings.columns
+         *    return record[this.id];
+         * };
+         */
+        _attributeWriter?: (record: any) => any;
+    }
+    interface Readers {
+        /**
+         * Function that interprets the row into data
+         *
+         * @param index The index of the current row (from 0 to the perPage value)
+         * @param thisRef 
+         * @param record
+         * @return the data for the current row
+         * 
+         * @default null
+         * 
+         * @example
+         * function exampleRowReader(index, this, record) {
+         *     //...
+         * };
+         */
+        _rowReader?: (index: number, thisRef: any, record: any) => any;
+        /**
+         * Function that interprets the cell into data
+         *
+         * @param cell A html node of the target cell
+         * @param record A data object representing the current line of data
+         * @return the data for the current cell
+         * 
+         * @default defaultAttributeReader
+         * 
+         * @example
+         * function exampleAttributeReader(cell, record) {
+         *    return $(cell).html();
+         * };
+         */
+        _attributeReader?: (cell: Element, record: any) => any;
+    }
+    interface Params {
+        /**
+         * @default 'dynatable'
+         */
+        dynatable?: string;
+        /**
+         * @default 'queries'
+         */
+        queries?: string;
+        /**
+         * @default 'sorts'
+         */
+        sorts?: string;
+        /**
+         * @default 'page'
+         */
+        page?: string;
+        /**
+         * @default 'perPage'
+         */
+        perPage?: string;
+        /**
+         * @default 'offset'
+         */
+        offset?: string;
+        /**
+         * @default 'records'
+         */
+        records?: string;
+        /**
+         * @default null
+         */
+        record?: Object;
+        /**
+         * @default 'queryRecordCount'
+         */
+        queryRecordCount?: string;
+        /**
+         * @default 'totalRecordCount'
+         */
+        totalRecordCount?: string;
+    }
+    interface Options {
+        features?: Features;
+        table?: Table;
+        inputs?: Inputs;
+        dataset?: Dataset;
+        writers?: Writers;
+        readers?: Readers;
+        params?: Params;
+    }
+    interface DOM {
+        /**
+         * Manually update the dom with the current record set...
+         * This can be useful after multiple calls to `domcolumns.add()` with `skipUpdate` set to true.
+         * This way we improve performance by generating the DOM only once.
+         */
+        update(): void;
+    }
+    interface DOMColumns {
+        /**
+         * Add a new column at runtime
+         *
+         * @param $column A jQuery object containing the html markup for the `th`
+         * @param position The position index indicating where we want to insert the new column
+         * @param skipAppend A boolean allowing to skip the appending of the column header to table
+         * @param skipUpdate A boolean allowing to skip the call to `dom.update()`
+         */
+        add($column: JQuery, position: number, skipAppend?: boolean, skipUpdate?: boolean): void;
+        /**
+         * Add several `data-` attributes on the provided `$cell`
+         *
+         * @param $cell A jQuery object pointing to the target cell
+         * @return the modified jQuery object `$cell`
+         */
+        attachGeneratedAttributes($cell: JQuery): JQuery;
+        /**
+         * Generate a jQuery object if none is provided and decorate it by calling `attachGeneratedAttributes`
+         *
+         * @param $cell An optional jQuery object pointing to the target cell
+         */
+        generate($cell?: JQuery): JQuery;
+        /**
+         * Parse the table header row, analyse its cells and save the columns.
+         * 
+         * @return Could return an `$.error()` if nothing is found.
+         */
+        getFromTable(): void|JQuery;
+        /** Initializes `settings.table.columns` array and calls `getFromTable()` */
+        init(): void;
+        /** 
+         * Check if the `$element` is valid (if it is a `table`) 
+         *
+         * @return A boolean
+         */
+        initOnLoad(): boolean;
+        /**
+         * Generate a jQuery object  if none is provided and decorate it by calling `attachGeneratedAttributes`
+         *
+         * @param columnIndexOrId A number (the column index) or a string (the column id)
+         */
+        remove(columnIndexOrId: number|string): void;
+        /**
+         * Remove the column from `settings.table.columns`
+         *
+         * @param index A number (the column index)
+         */
+        removeFromArray(index: number): void;
+        /**
+         * Remove the column from the DOM
+         *
+         * @param columnId A string matching the id used in `data-dynatable-column` attribute
+         */
+        removeFromTable(columnId: string): void;
+    }
+    interface InputsSearch {
+        /** Inject the search form at the target location */
+        attach(): void;
+        /**
+         * Build the html markup for the search form
+         *
+         * @return The jQuery object for the search form
+         */
+        create(): JQuery;
+        /** Call the `attach()` method */
+        init(): void;
+        /** 
+         * Check if the search feature is enabled in `settings.features`
+         * 
+         * @return A boolean
+         */
+        initOnLoad(): boolean;
+    }
+    interface PaginationLinks {
+        /** Insert the pagination links inside the page */
+        attach(): void;
+        /**
+         * Generate a string containing the html of a pagination link
+         * 
+         * @param page The page number
+         * @param label The text of the link (could be Previous, Next or a number)
+         * @param linkClass The classname for the `<a>`
+         * @param conditional Do we want to use the conditionalClass
+         * @param conditionalClass The classname for both the `<li>` and its `<a>`
+         * @return A string containing html markup
+         */
+        buildLink(page: number, label: string|number, linkClass: string, conditional: boolean, conditionalClass: string): string;
+        /** 
+         * Build the `<ul>` and creates the event listeners
+         *
+         * @return A string containing html markup
+         */
+        create(): string;
+        /** Call the attach method */
+        init(): void;
+        /** 
+         * Check if the paginate feature is enabled in `settings.features`
+         * 
+         * @return A boolean
+         */
+        initOnLoad(): boolean;
+    }
+    interface PaginationPage {
+        /** Parse the current window.location in order to determine the target page */
+        init(): void;
+        /** 
+         * Check if the paginate feature is enabled in `settings.features`
+         * 
+         * @return A boolean
+         */
+        initOnLoad(): boolean;
+        /** 
+         * Set the page in the dataset
+         * 
+         * @param page The new page number
+         */
+        set(page: number): void;
+    }
+    interface PaginationPerPage {
+        /** Insert the pagination per page inside the page */
+        attach(): void;
+        /**
+         * Generate the html markup for the pagination per page
+         *
+         * @return A jQuery object containing the `<label>` and the `<select>`
+         */
+        create(): JQuery;
+        /** Set up the pagination per page */
+        init(): void;
+        /** 
+         * Check if the paginate feature is enabled in `settings.features`
+         * 
+         * @return A boolean
+         */
+        initOnLoad(): boolean;
+        /**
+         * Set the new value for the pagination per page
+         *
+         * @param number The new number of items visible per page
+         * @param skipResetPage By default (false) it sends you to page 1
+         */
+        set(number: number, skipResetPage?: boolean): void;
+    }
+    interface ProcessingIndicator {
+        /** Insert the processing indicator inside the page */
+        attach(): void;
+        /**
+         * Generate the html markup for the processing indicator
+         *
+         * @return A jQuery object containing the generated html
+         */
+        create(): JQuery;
+        /** Hide the processing indicator */
+        hide(): void;
+        /** Set up the processing indicator */
+        init(): void;
+        /**
+         * Position the processing indicator at the center
+         *
+         * @return A jQuery object containing the processing indicator
+         */
+        position(): JQuery;
+        /** Show the processing indicator */
+        show(): void;
+    }
+    interface Queries {
+        /**
+         * Add a new condition in the queries
+         * 
+         * @param name The key for for the query
+         * @param value The value we wish to find
+         * @return A reference to the related Dynatable object
+         */
+        add(name: string, value: any): Dynatable;
+        /** functions object for Queries */
+        functions: QueriesFunctions;
+        /** Set up the initial search parameters */
+        init(): void;
+        /**
+         * Check if search feature is enabled
+         * 
+         * @return A boolean if search feature is enabled
+         */
+        initOnLoad(): boolean;
+        /**
+         * Remove the query from the dataset
+         * 
+         * @param name The key for for the query to be removed
+         * @return A reference to the related Dynatable object
+         */
+        remove(name: string): Dynatable;
+        /**  Run a search with all the saved queries */
+        run(): any;
+        /** 
+         * Shortcut for performing simple query from built-in search
+         *
+         * @param q The value that will be searched for
+         */
+        runSearch(q: any): void;
+        /** Set up the input fields for creating queries */
+        setupInputs(): void;
+    }
+    interface QueriesFunctions {
+        /**
+         * Search in all of the properties of the provided single record
+         * 
+         * @param record A data object with all the properties of the current line
+         * @param queryValue The researched value
+         * @return A boolean indicating if a match was found
+         */
+        search(record: any, queryValue: string): boolean;
+    }
+    interface Records {
+        /**
+         * Count records from table
+         *
+         * @return The length of the records Array
+         */
+        count(): number;
+        /**
+         * Get initial recordset to populate table
+         * if ajax, call ajaxUrl
+         * otherwise, initialize from in-table records
+         *
+         * @return An Array with the records
+         */
+        getFromTable(): Array<Object>;
+        /** Create and init the records */
+        init(): void;
+        /**
+         * Check if ajax feature is enabled
+         * 
+         * @return A boolean if ajax feature is enabled
+         */
+        initOnLoad(): boolean;
+        /**
+         * Get the first and the last indexes based on current page and number of items per page
+         *
+         * @return An Array with the first index ([0]) and the last index ([1])
+         */
+        pageBounds(): Array<number>;
+        /** Update the records with the new page */
+        paginate(): void;
+        /** Reset the records */
+        resetOriginal(): void;
+        /**
+         * Call the appropriated sort function
+         * 
+         * @return The number (-1, 0 or +1) representing the comparison
+         */
+        sort(): number;
+        /**
+         * Merge ajax response json with cached data including (meta-data and records)
+         * 
+         * @param data The new data
+         */
+        updateFromJson(data: any): void;
+    }
+    interface RecordsCount {
+        /** Insert the record count inside the page */
+        attach(): void;
+        /**
+         * Generate the html markup for the record count
+         *
+         * @return A jQuery object containing the generated html
+         */
+        create(): JQuery;
+        /** Create and init the records count */
+        init(): void;
+        /**
+         * Check if recordCount feature is enabled
+         * 
+         * @return A boolean if recordCount feature is enabled
+         */
+        initOnLoad(): boolean;
+    }
+    interface Settings {
+        dataset: Dataset;
+        features: Features;
+        inputs: Inputs;
+        params: Params;
+        readers: Readers;
+        table: Table;
+        writers: Writers;
+    }
+    interface Sorts {
+        /**
+         * Add a new sort in sortKeys
+         * 
+         * @param attr The key for for the sorting
+         * @param direction The sorting direction (-1 or +1)
+         * @return A reference to the related Dynatable object
+         */
+        add(attr: string, direction: number): Dynatable;
+        /** Remove all the sortKeys */
+        clear(): void;
+        /** functions object for Sorts */
+        functions: SortsFunctions;
+        /**
+         * Try to intelligently guess which sort function to use based on the type of attribute values.
+         * 
+         * @param a The first record
+         * @param b The second record
+         * @param attr The key of the property
+         * @return A string containing one of the types ('string' or 'number')
+         */
+        guessType(a: any, b: any, attr: string): string;
+        /** Create and init the sorts */
+        init(): void;
+        /**
+         * Check if sort feature is enabled
+         * 
+         * @return A boolean if sort feature is enabled
+         */
+        initOnLoad(): boolean;
+        /**
+         * Remove a sort attribute from the sortKeys
+         * 
+         * @param attr The key to be removed from the sorting
+         * @return A reference to the related Dynatable object
+         */
+        remove(attr: string): Dynatable;
+    }
+    interface SortsFunctions {
+        /**
+         * Sorting between 2 numbers
+         * 
+         * @param a The first record
+         * @param b The second record
+         * @param attr The key of the property
+         * @param direction The number describingthe order: ASC (+1), DESC (-1) or none (0)
+         * @return The number (-1, 0 or +1) representing the comparison
+         */
+        number(a: any, b: any, attr: string, direction: number): number;
+        /**
+         * Restores the original order we had...
+         * 
+         * @param a The first record
+         * @param b The second record
+         * @return The number (-1, 0 or +1) representing the comparison
+         */
+        originalPlacement(a: any, b: any): number;
+        /**
+         * Sorting between 2 strings
+         * 
+         * @param a The first record
+         * @param b The second record
+         * @param attr The key of the property
+         * @param direction The number describingthe order: ASC (+1), DESC (-1) or none (0)
+         * @return The number (-1, 0 or +1) representing the comparison
+         */
+        string(a: any, b: any, attr: string, direction: number): number;
+    }
+    interface SortsHeaders {
+        /**
+         * Inject the arrow down inside the $link
+         *
+         * @param $link The jQuery object to be used
+         */
+        appendArrowDown($link: JQuery): void;
+        /**
+         * Inject the arrow up inside the $link
+         *
+         * @param $link The jQuery object to be used
+         */
+        appendArrowUp($link: JQuery): void;
+        /** Go through each cell and call `attachOne` */
+        attach(): void;
+        /**
+         * If sorting is allowed for the provided cell, it injects the hml generated by `create`
+         *
+         * @param cell The cell Element to be parsed
+         */
+        attachOne(cell: Element): void;
+        /**
+         * Generate the html markup to be inserted inside the header of the sortable column
+         *
+         * @param cell An Element which point to the cell in the header row
+         * @return A jQuery object containing the markup of the link
+         */
+        create(cell: Element): JQuery;
+        /** Create and init the sorts */
+        init(): void;
+        /**
+         * Check if sort feature is enabled
+         * 
+         * @return A boolean if sort feature is enabled
+         */
+        initOnLoad(): boolean;
+        /** Remove all the sort headers from the table */
+        removeAll(): void;
+        /** Remove all arrows Elements from the table */
+        removeAllArrows(): void;
+        /** 
+         * Remove the arrow found inside the provided $link 
+         *
+         * @param $link The jQuery object containing the `<a>` markup in the sortable headers
+         */
+        removeArrow($link: JQuery): void;
+        /** 
+         * Remove the link generated by dynatable inside the sortable header
+         * and restore its original html content
+         *
+         * @param cell The cell Element that will be parsed
+         */
+        removeOne(cell: Element): void;
+        /** 
+         * @todo learn more about this method and document it
+         *
+         * @param $link The jQuery object to be used
+         * @param column The Column object that will be used
+         * @return A boolean which is true if supplied test function passes for ALL items in an array
+         */
+        sortedByColumn($link: JQuery, column: Column): boolean;
+        /** 
+         * Inspect the settings to determine the order to use
+         *
+         * @param column The Column object that will be used
+         * @return A number (-1 or +1) describing the order to use (DESC or ASC)
+         */
+        sortedByColumnValue(column: Column): number;
+        /** 
+         * Refresh the [multi] sorting of the dataset
+         *
+         * @param $e The event object (of the click on the table sortable header)
+         * @param $link The header link
+         * @param column The Column object to be sorted
+         */
+        toggleSort(e: Event, $link: JQuery, column: Column): void;
+    }
+    interface State {
+        /** Set up a listener for popstate event on window */
+        init(): void;
+        /**
+         * Check if pushState option is true, and if browser supports it
+         *
+         * @return A boolean
+         */
+        initOnLoad(): boolean;
+        /**
+         * Handler for the popstate event
+         *
+         * @param event The native popstate event
+         */
+        pop(event: Event): void;
+        /**
+         * Update the URL data using pushState
+         *
+         * @param data An object with the parameters we want to push
+         */        
+        push(data: Object): void;
+    }
+    interface Dynatable {
+        /**
+        * Initialize Dynatable plugin
+        *
+        * @param options An optional object that allow you to change the default configuration options
+        */
+        (options?: Options): JQuery;
+        /**
+         * Each dynatable instance inherits from this,
+         * set properties specific to instance
+         * 
+         * @param element The html node to be used by dynatable
+         * @param options The JQueryDynatable.Options object which contains all the settings
+         * @return A reference to the current and brand new dynatable object
+         */
+        init(element: Element, options: Options): Dynatable;
+        /**
+         * Call the process method on all the components of this dynatable
+         *
+         * @param skipPushState A boolean allowing to skip the update the query string in the URL
+         */
+        process(skipPushState?: boolean): void;
+        /** The `element` encapsulated inside a jQuery object */
+        $element: JQuery;
+        /** The `dom` API */
+        dom: DOM;
+        /** The `domColumns` API */
+        domColumns: DOMColumns;
+        /** The native element on which the dynatable plugin was called */
+        element: Element
+        /** The `inputsSearch` API */
+        inputsSearch: InputsSearch;
+        /** The `paginationLinks` API */
+        paginationLinks: PaginationLinks;
+        /** The `paginationPage` API */
+        paginationPage: PaginationPage;
+        /** The `paginationPerPage` API */
+        paginationPerPage: PaginationPerPage;
+        /** The `processingIndicator` API */
+        processingIndicator: ProcessingIndicator;
+        /** The `queries` API */
+        queries: Queries;
+        /** The `records` API */
+        records: Records;
+        /** The `recordsCount` API */
+        recordsCount: RecordsCount;
+        /** The `settings` API */
+        settings: Settings;
+        /** The `sorts` API */
+        sorts: Sorts;
+        /** The `sortsHeaders` API */
+        sortsHeaders: SortsHeaders;
+        /** The `state` API */
+        state: State;
+    }
+}
+
+//declare var dynatable: JQueryDynatable.Dynatable;