@syncfusion/ej2-grids 20.3.47-54738 → 20.3.47-54739

package/src/grid/renderer/virtual-freeze-renderer.d.ts

@@ -0,0 +1,382 @@
+import { FreezeContentRender, FreezeRender } from './freeze-renderer';
+import { ColumnFreezeContentRenderer } from './column-freeze-renderer';
+import { IGrid, IRenderer, NotifyArgs, IModelGenerator } from '../base/interface';
+import { ServiceLocator } from '../services/service-locator';
+import { VirtualContentRenderer, VirtualHeaderRenderer } from './virtual-content-renderer';
+import { FreezeRowModelGenerator } from '../services/freeze-row-model-generator';
+import { freezeTable } from '../base/enum';
+import { Row } from '../models/row';
+import { Column } from '../models/column';
+import { ColumnWidthService } from '../services/width-controller';
+/**
+ * VirtualFreezeRenderer is used to render the virtual table within the frozen and movable content table
+ *
+ * @hidden
+ */
+export declare class VirtualFreezeRenderer extends FreezeContentRender implements IRenderer {
+    protected serviceLoc: ServiceLocator;
+    rowModelGenerator: IModelGenerator<Column>;
+    constructor(parent?: IGrid, locator?: ServiceLocator);
+    protected freezeRowGenerator: FreezeRowModelGenerator;
+    /** @hidden */
+    virtualRenderer: VirtualContentRenderer;
+    protected firstPageRecords: Object[];
+    protected scrollbar: HTMLElement;
+    /** @hidden */
+    frzRows: Row<Column>[];
+    /** @hidden */
+    mvblRows: Row<Column>[];
+    /** @hidden */
+    frRows: Row<Column>[];
+    eventListener(action: string): void;
+    protected actionComplete(args: NotifyArgs): void;
+    private refreshVirtualFrozenRows;
+    private getVirtualData;
+    private setFreezeSelection;
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    renderTable(): void;
+    /**
+     * @param {HTMLElement} target - specifies the target
+     * @param {DocumentFragment} newChild - specifies the newChild
+     * @param {NotifyArgs} e - specifies the notifyargs
+     * @returns {void}
+     * @hidden
+     */
+    appendContent(target: HTMLElement, newChild: DocumentFragment, e: NotifyArgs): void;
+    /**
+     * @param {Object[]} data - specifies the data
+     * @param {NotifyArgs} notifyArgs - specifies the notifyargs
+     * @returns {Row<Column>[]} returns the row
+     * @hidden
+     */
+    generateRows(data: Object[], notifyArgs?: NotifyArgs): Row<Column>[];
+    /**
+     * @param {number} index - specifies the index
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    getRowByIndex(index: number): Element;
+    /**
+     * @param {number} index - specifies the index
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    getMovableRowByIndex(index: number): Element;
+    private collectRows;
+    /**
+     * @returns {HTMLCollection} returns the Htmlcollection
+     * @hidden
+     */
+    getMovableRows(): Row<Column>[] | HTMLCollectionOf<HTMLTableRowElement>;
+    /**
+     * @returns {HTMLCollectionOf<HTMLTableRowElement>} returns the html collection
+     * @hidden
+     */
+    getRows(): Row<Column>[] | HTMLCollectionOf<HTMLTableRowElement>;
+    /**
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    getColGroup(): Element;
+    /**
+     * @param {NotifyArgs} args - specifies the args
+     * @returns {Row<Column>[]} returns the row
+     * @hidden
+     */
+    getReorderedFrozenRows(args: NotifyArgs): Row<Column>[];
+    protected isXaxis(): boolean;
+    protected getHeaderCells(): Element[];
+    protected getVirtualFreezeHeader(): Element;
+    protected ensureFrozenCols(columns: Column[]): Column[];
+    /**
+     * @param {number} index - specifies the index
+     * @returns {object} returns the object
+     * @hidden
+     */
+    getRowObjectByIndex(index: number): Object;
+    /**
+     * Set the header colgroup element
+     *
+     * @param {Element} colGroup - specifies the colgroup
+     * @returns {Element} returns the element
+     */
+    setColGroup(colGroup: Element): Element;
+}
+/**
+ * VirtualFreezeHdrRenderer is used to render the virtual table within the frozen and movable header table
+ *
+ * @hidden
+ */
+export declare class VirtualFreezeHdrRenderer extends FreezeRender implements IRenderer {
+    protected serviceLoc: ServiceLocator;
+    constructor(parent?: IGrid, locator?: ServiceLocator);
+    virtualHdrRenderer: VirtualHeaderRenderer;
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    renderTable(): void;
+    protected rfshMovable(): void;
+}
+/**
+ * @param {NotifyArgs} args - specifies the args
+ * @param {Object[]} data - specifies the data
+ * @param {number[]}selectedIdx - specifies the selected index
+ * @param {IGrid} parent - specifies the IGrid
+ * @param {IModelGenerator} rowModelGenerator - specifies the rowModeGenerator
+ * @param {ServiceLocator} locator - specifies the locator
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the virtual renderer
+ * @param {VirtualFreezeRenderer} instance - specifies the instance
+ * @returns {void}
+ * @hidden
+ */
+export declare function renderFrozenRows(args: NotifyArgs, data: Object[], selectedIdx: number[], parent: IGrid, rowModelGenerator: IModelGenerator<Column>, locator: ServiceLocator, virtualRenderer: VirtualContentRenderer, instance: VirtualFreezeRenderer | ColumnVirtualFreezeRenderer): void;
+/**
+ * @param {Row<Column>[]} data - specifies the data
+ * @param {freezeTable} tableName -specifies the table
+ * @param {IGrid} parent - specifies the IGrid
+ * @returns {Row<Column>[]} returns the row
+ * @hidden
+ */
+export declare function splitCells(data: Row<Column>[], tableName: freezeTable, parent: IGrid): Row<Column>[];
+/**
+ * @param {freezeTable} tableName - specifies the freeze tabel
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the virtual renderer
+ * @param {IGrid} parent - specifies the IGrid
+ * @returns {Row<Column>[]} returns the row
+ * @hidden
+ */
+export declare function collectRows(tableName: freezeTable, virtualRenderer: VirtualContentRenderer, parent: IGrid): Row<Column>[];
+/**
+ * @param {object} args - specifies the args
+ * @param {string} args.uid - specifirs the uid
+ * @param {boolean} args.set - specifies the set
+ * @param {boolean} args.clearAll - specifies the boolean to clearall
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the virtual renderer
+ * @returns {void}
+ * @hidden
+ */
+export declare function setFreezeSelectionAction(args: {
+    uid: string;
+    set: boolean;
+    clearAll?: boolean;
+}, virtualRenderer: VirtualContentRenderer): void;
+/**
+ * @param {Object} args - specifies the args
+ * @param {string} args.uid - specifirs the uid
+ * @param {boolean} args.set - specifies the set
+ * @param {boolean} args.clearAll - specifies the boolean to clearall
+ * @param {Row<Column>[]} cache - specifies the cache
+ * @returns {void}
+ * @hidden
+ */
+export declare function selectFreezeRows(args: {
+    uid: string;
+    set: boolean;
+    clearAll?: boolean;
+}, cache: Row<Column>[]): void;
+/**
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the virtual renderer
+ * @param {ColumnWidthService} widthService - specifies the width service
+ * @param {HTMLElement} target - specifies the target
+ * @param {DocumentFragment} newChild - specifies the newchild
+ * @param {NotifyArgs} e - specifies the notifyargs
+ * @returns {void}
+ * @hidden
+ */
+export declare function appendContent(virtualRenderer: VirtualContentRenderer, widthService: ColumnWidthService, target: HTMLElement, newChild: DocumentFragment, e: NotifyArgs): void;
+/**
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the virtual renderer
+ * @param {object[]} data - specifies the data
+ * @param {NotifyArgs} notifyArgs - specifies the notifyargs
+ * @param {FreezeRowModelGenerator} freezeRowGenerator - specifies the freeze row generator
+ * @param {IGrid} parent - specifies the IGrid
+ * @returns {Row<Column>[]} returns the row
+ * @hidden
+ */
+export declare function generateRows(virtualRenderer: VirtualContentRenderer, data: Object[], notifyArgs: NotifyArgs, freezeRowGenerator: FreezeRowModelGenerator, parent: IGrid): Row<Column>[];
+/**
+ * @param {NotifyArgs} args -specifies the args
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the virtual renderer
+ * @param {IGrid} parent - specifies the IGrid
+ * @param {FreezeRowModelGenerator} freezeRowGenerator - specifies the freezeRowGenerator
+ * @param {Object[]} firstPageRecords - specifies the first page records
+ * @returns {Row<Column>[]} returns the row
+ * @hidden
+ */
+export declare function getReorderedFrozenRows(args: NotifyArgs, virtualRenderer: VirtualContentRenderer, parent: IGrid, freezeRowGenerator: FreezeRowModelGenerator, firstPageRecords: Object[]): Row<Column>[];
+/**
+ * @param {Row<Column>[]} rows - specifies the row
+ * @param {IGrid} parent - specifies the IGrid
+ * @param {NotifyArgs} args - specifies the notify arguments
+ * @param {FreezeRowModelGenerator} freezeRowGenerator - specifies the freezerowgenerator
+ * @returns {Row<Column>[]} returns the row
+ * @hidden
+ */
+export declare function splitReorderedRows(rows: Row<Column>[], parent: IGrid, args: NotifyArgs, freezeRowGenerator: FreezeRowModelGenerator): Row<Column>[];
+/**
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the VirtualRenderer
+ * @returns {boolean} returns the isXaxis
+ * @hidden
+ */
+export declare function isXaxis(virtualRenderer: VirtualContentRenderer): boolean;
+/**
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the virtualrenderer
+ * @param {IGrid} parent - specifies the IGrid
+ * @returns {Element[]} returns the element
+ * @hidden
+ */
+export declare function getHeaderCells(virtualRenderer: VirtualContentRenderer, parent: IGrid): Element[];
+/**
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the virtual Renderer
+ * @param {IGrid} parent - specifies the IGrid
+ * @returns {Element} returns the element
+ * @hidden
+ */
+export declare function getVirtualFreezeHeader(virtualRenderer: VirtualContentRenderer, parent: IGrid): Element;
+/**
+ * @param {Column[]} columns - specifies the columns
+ * @param {IGrid} parent - specifies the IGrid
+ * @returns {Column[]} returns the column[]
+ * @hidden
+ */
+export declare function ensureFrozenCols(columns: Column[], parent: IGrid): Column[];
+/**
+ * @param {Element} colGroup - specifies the colGroup
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the virtual renderer
+ * @param {ColumnVirtualFreezeRenderer} instance - specifies the instances
+ * @returns {Element} returns the element
+ * @hidden
+ */
+export declare function setColGroup(colGroup: Element, virtualRenderer: VirtualContentRenderer, instance: ColumnVirtualFreezeRenderer | VirtualFreezeRenderer): Element;
+/**
+ * @param {VirtualFreezeRenderer} instance - specifies the instance
+ * @param {number} index - specifies the index
+ * @returns {void}
+ * @hidden
+ */
+export declare function setCache(instance: VirtualFreezeRenderer | ColumnVirtualFreezeRenderer, index: number): void;
+/**
+ * @param {IGrid} parent - specifies the IGrid
+ * @param {VirtualContentRenderer} virtualRenderer - specifies the virtualRenderer
+ * @param {Element} scrollbar - specifies the scrollbr
+ * @param {Element} mCont - specifies the mCont
+ * @returns {void}
+ * @hidden
+ */
+export declare function setDebounce(parent: IGrid, virtualRenderer: VirtualContentRenderer, scrollbar: Element, mCont: Element): void;
+/**
+ * ColumnVirtualFreezeRenderer is used to render the virtual table within the frozen and movable content table
+ *
+ * @hidden
+ */
+export declare class ColumnVirtualFreezeRenderer extends ColumnFreezeContentRenderer implements IRenderer {
+    protected serviceLoc: ServiceLocator;
+    rowModelGenerator: IModelGenerator<Column>;
+    constructor(parent?: IGrid, locator?: ServiceLocator);
+    /** @hidden */
+    virtualRenderer: VirtualContentRenderer;
+    protected freezeRowGenerator: FreezeRowModelGenerator;
+    protected firstPageRecords: Object[];
+    protected scrollbar: HTMLElement;
+    /** @hidden */
+    frRows: Row<Column>[];
+    /** @hidden */
+    frzRows: Row<Column>[];
+    /** @hidden */
+    mvblRows: Row<Column>[];
+    protected actionComplete(args: NotifyArgs): void;
+    eventListener(action: string): void;
+    private refreshVirtualFrozenRows;
+    private setFreezeSelection;
+    private getVirtualData;
+    renderNextFrozentPart(e: NotifyArgs, tableName: freezeTable): void;
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    renderTable(): void;
+    private renderVirtualFrozenLeft;
+    private renderVirtualFrozenRight;
+    private renderVirtualFrozenLeftRight;
+    /**
+     * @param {HTMLElement} target - specifies the target
+     * @param {DocumentFragment} newChild - specifies the newchild
+     * @param {NotifyArgs} e - specifies the NotifyArgs
+     * @returns {void}
+     * @hidden
+     */
+    appendContent(target: HTMLElement, newChild: DocumentFragment, e: NotifyArgs): void;
+    /**
+     * @param {Object[]} data - specifies the data
+     * @param {NotifyArgs} e - specifies the notifyargs
+     * @returns {Row<Column>[]} returns the row
+     * @hidden
+     */
+    generateRows(data: Object[], e?: NotifyArgs): Row<Column>[];
+    /**
+     * @param {number} index - specifies the number
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    getRowByIndex(index: number): Element;
+    /**
+     * @param {number} index - specifies the index
+     * @returns {Element} - returns the element
+     * @hidden
+     */
+    getFrozenRightRowByIndex(index: number): Element;
+    private collectRows;
+    /**
+     * @param {number} index - specifies the index
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    getMovableRowByIndex(index: number): Element;
+    /**
+     * @returns {Row<Column>[]} returns the row
+     * @hidden
+     */
+    getFrozenRightRows(): Row<Column>[] | HTMLCollectionOf<HTMLTableRowElement>;
+    /**
+     * @returns {Row<Column>[]} returns the row
+     * @hidden
+     */
+    getMovableRows(): Row<Column>[] | HTMLCollectionOf<HTMLTableRowElement>;
+    /**
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    getColGroup(): Element;
+    /**
+     * @returns {Row<Column>[]} returns the row
+     * @hidden
+     */
+    getRows(): Row<Column>[] | HTMLCollectionOf<HTMLTableRowElement>;
+    /**
+     * @param {NotifyArgs} args - specifies the args
+     * @returns {Row<Column>[]} returns the row object
+     * @hidden
+     */
+    getReorderedFrozenRows(args: NotifyArgs): Row<Column>[];
+    protected getHeaderCells(): Element[];
+    protected isXaxis(): boolean;
+    protected getVirtualFreezeHeader(): Element;
+    /**
+     * @param {number} index - specifies the index
+     * @returns {object} - returns the object
+     * @hidden
+     */
+    getRowObjectByIndex(index: number): Object;
+    protected ensureFrozenCols(columns: Column[]): Column[];
+    /**
+     * Set the header colgroup element
+     *
+     * @param {Element} colGroup - specifies the colgroup
+     * @returns {Element} - returns the element
+     */
+    setColGroup(colGroup: Element): Element;
+}

package/src/grid/renderer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Models
+ */
+export * from './renderer/header-renderer';
+export * from './renderer/content-renderer';
+export * from './renderer/row-renderer';
+export * from './renderer/cell-renderer';
+export * from './renderer/header-cell-renderer';
+export * from './renderer/filter-cell-renderer';
+export * from './renderer/stacked-cell-renderer';
+export * from './renderer/render';
+export * from './renderer/filter-cell-renderer';
+export * from './renderer/indent-cell-renderer';
+export * from './renderer/caption-cell-renderer';
+export * from './renderer/batch-edit-renderer';
+export * from './renderer/dialog-edit-renderer';
+export * from './renderer/inline-edit-renderer';
+export * from './renderer/edit-renderer';
+export * from './renderer/boolean-edit-cell';
+export * from './renderer/default-edit-cell';
+export * from './renderer/dropdown-edit-cell';
+export * from './renderer/numeric-edit-cell';
+export * from './renderer/datepicker-edit-cell';
+export * from './renderer/command-column-renderer';
+export * from './renderer/freeze-renderer';
+export * from './renderer/string-filter-ui';
+export * from './renderer/number-filter-ui';
+export * from './renderer/date-filter-ui';
+export * from './renderer/boolean-filter-ui';
+export * from './renderer/filter-menu-operator';
+export * from './renderer/autocomplete-edit-cell';
+export * from './renderer/combobox-edit-cell';
+export * from './renderer/multiselect-edit-cell';
+export * from './renderer/timepicker-edit-cell';
+export * from './renderer/toggleswitch-edit-cell';
+export * from './renderer/inputmask-edit-cell';
+export * from './renderer/virtual-content-renderer';
+export * from './renderer/virtual-freeze-renderer';
+export * from './renderer/group-lazy-load-renderer';
+export * from './renderer/column-freeze-renderer';
+export * from './renderer/responsive-dialog-renderer';
+export * from './renderer/edit-cell-base';

package/src/grid/reorder.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Reorder export
+ */
+export * from './actions/reorder';

package/src/grid/resize.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Resize export
+ */
+export * from './actions/resize';

package/src/grid/row-reorder.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Row reorder export
+ */
+export * from './actions/row-reorder';

package/src/grid/selection.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Selection export
+ */
+export * from './actions/selection';

package/src/grid/services/aria-service.d.ts

@@ -0,0 +1,34 @@
+import { SortDirection } from '../base/enum';
+/**
+ * AriaService
+ *
+ * @hidden
+ */
+export declare class AriaService {
+    setOptions(target: HTMLElement, options: IAriaOptions<boolean>): void;
+    setExpand(target: HTMLElement, expand: boolean): void;
+    setSort(target: HTMLElement, direction?: SortDirection | 'none' | boolean): void;
+    setBusy(target: HTMLElement, isBusy: boolean): void;
+    setGrabbed(target: HTMLElement, isGrabbed: boolean, remove?: boolean): void;
+    setDropTarget(target: HTMLElement, isTarget: boolean): void;
+}
+/**
+ * @hidden
+ */
+export interface IAriaOptions<T> {
+    role?: string;
+    datarole?: string;
+    expand?: T;
+    collapse?: T;
+    selected?: T;
+    multiselectable?: T;
+    sort?: T | 'none';
+    busy?: T;
+    invalid?: T;
+    grabbed?: T;
+    dropeffect?: T;
+    haspopup?: T;
+    level?: T;
+    colcount?: string;
+    rowcount?: string;
+}

package/src/grid/services/cell-render-factory.d.ts

@@ -0,0 +1,14 @@
+import { ICellRenderer } from '../base/interface';
+import { CellType } from '../base/enum';
+/**
+ * CellRendererFactory
+ *
+ * @hidden
+ */
+export declare class CellRendererFactory {
+    cellRenderMap: {
+        [c: string]: ICellRenderer<{}>;
+    };
+    addCellRenderer(name: string | CellType, type: ICellRenderer<{}>): void;
+    getCellRenderer(name: string | CellType): ICellRenderer<{}>;
+}

package/src/grid/services/focus-strategy.d.ts

@@ -0,0 +1,192 @@
+import { KeyboardEventArgs } from '@syncfusion/ej2-base';
+import { IGrid, IFocus, FocusInfo, FocusedContainer, IIndex, CellFocusArgs, SwapInfo } from '../base/interface';
+import { Row } from '../models/row';
+import { Cell } from '../models/cell';
+import { Column } from '../models/column';
+import { NotifyArgs } from '../base/interface';
+/**
+ * FocusStrategy class
+ *
+ * @hidden
+ */
+export declare class FocusStrategy {
+    parent: IGrid;
+    currentInfo: FocusInfo;
+    oneTime: boolean;
+    swap: SwapInfo;
+    content: IFocus;
+    header: IFocus;
+    active: IFocus;
+    fContent: IFocus;
+    fHeader: IFocus;
+    frContent: IFocus;
+    frHeader: IFocus;
+    /** @hidden */
+    isInfiniteScroll: boolean;
+    private forget;
+    private skipFocus;
+    private focusByClick;
+    private passiveHandler;
+    private prevIndexes;
+    private focusedColumnUid;
+    private refMatrix;
+    private rowModelGen;
+    private activeKey;
+    private empty;
+    private actions;
+    private isVirtualScroll;
+    private evtHandlers;
+    constructor(parent: IGrid);
+    protected focusCheck(e: Event): void;
+    protected onFocus(e?: FocusEvent): void;
+    protected passiveFocus(e: FocusEvent): void;
+    protected onBlur(e?: FocusEvent): void;
+    /**
+     * @returns {void}
+     * @hidden */
+    setFirstFocusableTabIndex(): void;
+    private setLastContentCellTabIndex;
+    onClick(e: Event | {
+        target: Element;
+    }, force?: boolean): void;
+    protected onKeyPress(e: KeyboardEventArgs): void;
+    private setLastContentCellActive;
+    private focusOutFromChildGrid;
+    private focusOutFromHeader;
+    private allowToPaging;
+    private skipOn;
+    private focusVirtualElement;
+    getFocusedElement(): HTMLElement;
+    getContent(): IFocus;
+    setActive(content: boolean, isFrozen?: boolean, isFrozenRight?: boolean): void;
+    setFocusedElement(element: HTMLElement, e?: KeyboardEventArgs): void;
+    focus(e?: KeyboardEventArgs | FocusEvent): void;
+    protected removeFocus(e?: FocusEvent): void;
+    /**
+     * @returns {void}
+     * @hidden */
+    addOutline(): void;
+    /**
+     * @returns {void}
+     * @hidden */
+    focusHeader(): void;
+    /**
+     * @returns {void}
+     * @hidden */
+    focusContent(): void;
+    private resetFocus;
+    protected addFocus(info: FocusInfo, e?: KeyboardEventArgs | FocusEvent): void;
+    protected refreshMatrix(content?: boolean): Function;
+    addEventListener(): void;
+    filterfocus(): void;
+    removeEventListener(): void;
+    destroy(): void;
+    restoreFocus(): void;
+    restoreFocusWithAction(e: NotifyArgs): void;
+    clearOutline(): void;
+    clearIndicator(): void;
+    getPrevIndexes(): IIndex;
+    forgetPrevious(): void;
+    setActiveByKey(action: string, active: IFocus): void;
+    internalCellFocus(e: CellFocusArgs): void;
+}
+/**
+ * Create matrix from row collection which act as mental model for cell navigation
+ *
+ * @hidden
+ */
+export declare class Matrix {
+    matrix: number[][];
+    current: number[];
+    columns: number;
+    rows: number;
+    set(rowIndex: number, columnIndex: number, allow?: boolean): void;
+    get(rowIndex: number, columnIndex: number, navigator: number[], action?: string, validator?: Function): number[];
+    first(vector: number[], index: number, navigator: number[], moveTo?: boolean, action?: string): number;
+    select(rowIndex: number, columnIndex: number): void;
+    generate(rows: Row<Column>[], selector: Function, isRowTemplate?: boolean): number[][];
+    columnsCount(rowColumns: Column[], currentColumnCount: number): number;
+    inValid(value: number): boolean;
+}
+/**
+ * @hidden
+ */
+export declare class ContentFocus implements IFocus {
+    matrix: Matrix;
+    parent: IGrid;
+    keyActions: {
+        [x: string]: number[];
+    };
+    lastIdxCell: boolean;
+    target: HTMLElement;
+    indexesByKey: (action: string) => number[];
+    constructor(parent: IGrid);
+    getTable(): HTMLTableElement;
+    onKeyPress(e: KeyboardEventArgs): void | boolean;
+    private editNextRow;
+    getCurrentFromAction(action: string, navigator?: number[], isPresent?: boolean, e?: KeyboardEventArgs): number[];
+    onClick(e: Event, force?: boolean): void | boolean;
+    getFocusInfo(): FocusInfo;
+    getFocusable(element: HTMLElement): HTMLElement;
+    selector(row: Row<Column>, cell: Cell<Column>, isRowTemplate?: boolean): boolean;
+    nextRowFocusValidate(index: number): number;
+    previousRowFocusValidate(index: number): number;
+    jump(action: string, current: number[]): SwapInfo;
+    getNextCurrent(previous?: number[], swap?: SwapInfo, active?: IFocus, action?: string): number[];
+    generateRows(rows?: Row<Column>[], optionals?: Object): void;
+    getInfo(e?: KeyboardEventArgs): FocusedContainer;
+    validator(): Function;
+    protected shouldFocusChange(e: KeyboardEventArgs): boolean;
+    protected getGridSeletion(): boolean;
+}
+/**
+ * @hidden
+ */
+export declare class HeaderFocus extends ContentFocus implements IFocus {
+    constructor(parent: IGrid);
+    getTable(): HTMLTableElement;
+    onClick(e: Event): void | boolean;
+    getFocusInfo(): FocusInfo;
+    selector(row: Row<Column>, cell: Cell<Column>): boolean;
+    jump(action: string, current: number[]): SwapInfo;
+    getNextCurrent(previous?: number[], swap?: SwapInfo, active?: IFocus, action?: string): number[];
+    generateRows(rows?: Row<Column>[]): void;
+    private checkFilterColumn;
+    getInfo(e?: KeyboardEventArgs): FocusedContainer;
+    validator(): Function;
+    protected shouldFocusChange(e: KeyboardEventArgs): boolean;
+    getHeaderType(): string;
+}
+export declare class FixedContentFocus extends ContentFocus {
+    getTable(): HTMLTableElement;
+    jump(action: string, current: number[]): SwapInfo;
+    getNextCurrent(previous?: number[], swap?: SwapInfo, active?: IFocus, action?: string): number[];
+}
+export declare class FixedHeaderFocus extends HeaderFocus {
+    jump(action: string, current: number[]): SwapInfo;
+    getTable(): HTMLTableElement;
+    getNextCurrent(previous?: number[], swap?: SwapInfo, active?: IFocus, action?: string): number[];
+    getHeaderType(): string;
+}
+/** @hidden */
+export declare class SearchBox {
+    searchBox: HTMLElement;
+    constructor(searchBox: HTMLElement);
+    searchFocus(args: {
+        target: HTMLInputElement;
+    }): void;
+    protected searchBlur(args: Event & FocusEvent): void;
+    wireEvent(): void;
+    unWireEvent(): void;
+}
+export declare class FixedRightContentFocus extends ContentFocus {
+    getTable(): HTMLTableElement;
+    jump(action: string, current: number[]): SwapInfo;
+    getNextCurrent(previous?: number[], swap?: SwapInfo, active?: IFocus, action?: string): number[];
+}
+export declare class FixedRightHeaderFocus extends HeaderFocus {
+    jump(action: string, current: number[]): SwapInfo;
+    getTable(): HTMLTableElement;
+    getNextCurrent(previous?: number[], swap?: SwapInfo, active?: IFocus, action?: string): number[];
+    getHeaderType(): string;
+}