import * as React from 'react';
import { IgrDataCloneStrategy } from "./igr-data-clone-strategy";
import { IgrClipboardOptions } from "./igr-clipboard-options";
import { IgrColumnCollection } from "./igr-column-collection";
import { IgrActionStripCollection } from "./igr-action-strip-collection";
import { IgrGridToolbarCollection } from "./igr-grid-toolbar-collection";
import { IgrPaginatorCollection } from "./igr-paginator-collection";
import { IgrGridResourceStrings } from "./igr-grid-resource-strings";
import { FilteringLogic } from "./FilteringLogic";
import { IgrFilteringExpressionsTree } from "./igr-filtering-expressions-tree";
import { GridPagingMode } from "./GridPagingMode";
import { GridValidationTrigger } from "./GridValidationTrigger";
import { IgrPinningConfig } from "./igr-pinning-config";
import { FilterMode } from "./FilterMode";
import { GridSummaryPosition } from "./GridSummaryPosition";
import { GridSummaryCalculationMode } from "./GridSummaryCalculationMode";
import { IgrFilteringStrategy } from "./igr-filtering-strategy";
import { IgrGridSortingStrategy } from "./igr-grid-sorting-strategy";
import { IgrSortingOptions } from "./igr-sorting-options";
import { GridSelectionMode } from "./GridSelectionMode";
import { IgrSearchInfo } from "./igr-search-info";
import { IgrForOfState } from "./igr-for-of-state";
import { IgrOverlayOutletDirective } from "./igr-overlay-outlet-directive";
import { IgrStateCollection } from "./igr-state-collection";
import { IgrFilteringExpressionsTreeEventArgs } from "./igr-filtering-expressions-tree-event-args";
import { IgrGridScrollEventArgs } from "./igr-grid-scroll-event-args";
import { IgrGridCellEventArgs } from "./igr-grid-cell-event-args";
import { IgrGridRowEventArgs } from "./igr-grid-row-event-args";
import { IgrGridFormGroupCreatedEventArgs } from "./igr-grid-form-group-created-event-args";
import { IgrGridValidationStatusEventArgs } from "./igr-grid-validation-status-event-args";
import { IgrRowSelectionEventArgs } from "./igr-row-selection-event-args";
import { IgrColumnSelectionEventArgs } from "./igr-column-selection-event-args";
import { IgrPinColumnCancellableEventArgs } from "./igr-pin-column-cancellable-event-args";
import { IgrPinColumnEventArgs } from "./igr-pin-column-event-args";
import { IgrGridEditEventArgs } from "./igr-grid-edit-event-args";
import { IgrGridEditDoneEventArgs } from "./igr-grid-edit-done-event-args";
import { IgrColumnComponentEventArgs } from "./igr-column-component-event-args";
import { IgrColumnsAutoGeneratedEventArgs } from "./igr-columns-auto-generated-event-args";
import { IgrSortingEventArgs } from "./igr-sorting-event-args";
import { IgrSortingExpressionEventArgs } from "./igr-sorting-expression-event-args";
import { IgrFilteringEventArgs } from "./igr-filtering-event-args";
import { IgrRowDataEventArgs } from "./igr-row-data-event-args";
import { IgrRowDataCancelableEventArgs } from "./igr-row-data-cancelable-event-args";
import { IgrColumnResizeEventArgs } from "./igr-column-resize-event-args";
import { IgrGridContextMenuEventArgs } from "./igr-grid-context-menu-event-args";
import { IgrColumnVisibilityChangingEventArgs } from "./igr-column-visibility-changing-event-args";
import { IgrColumnVisibilityChangedEventArgs } from "./igr-column-visibility-changed-event-args";
import { IgrColumnMovingStartEventArgs } from "./igr-column-moving-start-event-args";
import { IgrColumnMovingEventArgs } from "./igr-column-moving-event-args";
import { IgrColumnMovingEndEventArgs } from "./igr-column-moving-end-event-args";
import { IgrGridKeydownEventArgs } from "./igr-grid-keydown-event-args";
import { IgrRowDragStartEventArgs } from "./igr-row-drag-start-event-args";
import { IgrRowDragEndEventArgs } from "./igr-row-drag-end-event-args";
import { IgrGridClipboardEventEventArgs } from "./igr-grid-clipboard-event-event-args";
import { IgrComponentArrayDataValueChangedEventArgs } from "./igr-component-array-data-value-changed-event-args";
import { IgrRowToggleEventArgs } from "./igr-row-toggle-event-args";
import { IgrPinRowEventArgs } from "./igr-pin-row-event-args";
import { IgrActiveNodeChangeEventArgs } from "./igr-active-node-change-event-args";
import { IgrGridToolbarExportEventArgs } from "./igr-grid-toolbar-export-event-args";
import { IgrGridSelectionRangeEventArgs } from "./igr-grid-selection-range-event-args";
import { IgrVoidEventArgs } from "igniteui-react";
import { IgrForOfDataChangingEventArgs } from "./igr-for-of-data-changing-event-args";
import { IgrColumn } from "./igr-column";
import { DropPosition } from "./DropPosition";
import { IgrFilteringExpressionsTreeOrFilteringOperation } from "./igr-filtering-expressions-tree-or-filtering-operation";
import { IgrCellPosition } from "./igr-cell-position";
import { IgrOverlaySettings } from "./igr-overlay-settings";
import { GridBaseDirective } from "./GridBaseDirective";
import { ReactRenderer, PortalManager } from "igniteui-react-core";
import { ContentChildrenManager } from "igniteui-react-core";
import { IgrActionStrip } from "./igr-action-strip";
import { IgrGridRowDragGhostContext } from "./igr-grid-row-drag-ghost-context";
import { IgrGridRowEditTextTemplateContext } from "./igr-grid-row-edit-text-template-context";
import { IgrGridEmptyTemplateContext } from "./igr-grid-empty-template-context";
import { IgrGridRowEditActionsTemplateContext } from "./igr-grid-row-edit-actions-template-context";
import { IgrGridRowTemplateContext } from "./igr-grid-row-template-context";
import { IgrGridTemplateContext } from "./igr-grid-template-context";
import { IgrGridHeaderTemplateContext } from "./igr-grid-header-template-context";
import { IgrGridToolbar } from "./igr-grid-toolbar";
import { IgrPaginator } from "./igr-paginator";
import { IgrHeadSelectorTemplateContext } from "./igr-head-selector-template-context";
import { IgrRowSelectorTemplateContext } from "./igr-row-selector-template-context";
import { IgrSortingExpression } from "./igr-sorting-expression";
import { IgrGridState } from "./igr-grid-state";
import { IgrGridSelectionRange } from "./igr-grid-selection-range";
export declare abstract class IgrGridBaseDirective<P extends IIgrGridBaseDirectiveProps = IIgrGridBaseDirectiveProps> extends React.Component<P & Omit<React.HTMLAttributes<HTMLElement>, keyof P>, {}> {
    protected createImplementation(): GridBaseDirective;
    protected _implementation: any;
    protected mounted: boolean;
    get nativeElement(): HTMLElement;
    /**
     * @hidden
     */
    get i(): GridBaseDirective; /**
                                 * @hidden
                                 */
    static _createFromInternal(internal: any): IgrGridBaseDirective;
    protected _renderer: ReactRenderer;
    protected _portalManager: PortalManager;
    protected onImplementationCreated(): void;
    protected _contentChildrenManager: ContentChildrenManager;
    protected _initializeAdapters(): void;
    protected _updateAdapters(): void;
    constructor(props: P & Omit<React.HTMLAttributes<HTMLElement>, keyof P>);
    componentDidMount(): void;
    shouldComponentUpdate(nextProps: any, nextState: any): boolean;
    render(): React.DetailedReactHTMLElement<{
        children: any[];
    }, HTMLElement>;
    /**
     * Gets/Sets the display time for the row adding snackbar notification.
     * @remarks
     * By default it is 6000ms.
    */
    get snackbarDisplayTime(): number;
    set snackbarDisplayTime(v: number);
    get autoGenerate(): boolean;
    set autoGenerate(v: boolean);
    get autoGenerateExclude(): string[];
    set autoGenerateExclude(v: string[]);
    /**
     * Controls whether columns moving is enabled in the grid.
    */
    get moving(): boolean;
    set moving(v: boolean);
    private _emptyGridTemplate;
    private _emptyGridTemplateAdapter;
    get emptyGridTemplate(): React.FunctionComponent<{
        dataContext: any;
    }> | React.Component<{
        dataContext: any;
    }>;
    set emptyGridTemplate(v: React.FunctionComponent<{
        dataContext: any;
    }> | React.Component<{
        dataContext: any;
    }>);
    private _addRowEmptyTemplate;
    private _addRowEmptyTemplateAdapter;
    get addRowEmptyTemplate(): React.FunctionComponent<{
        dataContext: any;
    }> | React.Component<{
        dataContext: any;
    }>;
    set addRowEmptyTemplate(v: React.FunctionComponent<{
        dataContext: any;
    }> | React.Component<{
        dataContext: any;
    }>);
    private _loadingGridTemplate;
    private _loadingGridTemplateAdapter;
    get loadingGridTemplate(): React.FunctionComponent<{
        dataContext: any;
    }> | React.Component<{
        dataContext: any;
    }>;
    set loadingGridTemplate(v: React.FunctionComponent<{
        dataContext: any;
    }> | React.Component<{
        dataContext: any;
    }>);
    /**
     * Get/Set IgxSummaryRow height
    */
    get summaryRowHeight(): number;
    set summaryRowHeight(v: number);
    get dataCloneStrategy(): IgrDataCloneStrategy;
    set dataCloneStrategy(v: IgrDataCloneStrategy);
    /**
     * Controls the copy behavior of the grid.
    */
    get clipboardOptions(): IgrClipboardOptions;
    set clipboardOptions(v: IgrClipboardOptions);
    get rowClasses(): any;
    set rowClasses(v: any);
    get rowStyles(): any;
    set rowStyles(v: any);
    get primaryKey(): string;
    set primaryKey(v: string);
    private _columnList;
    private _combinedColumnList;
    get combinedColumnList(): IgrColumn[];
    private _contentColumnList;
    get contentColumnList(): IgrColumn[];
    private _columnListAdapter;
    /**
     * @hidden @internal
    */
    get columnList(): IgrColumnCollection;
    private _actionStripComponents;
    private _actualActionStripComponents;
    get actualActionStripComponents(): IgrActionStrip[];
    private _contentActionStripComponents;
    get contentActionStripComponents(): IgrActionStrip[];
    private _actionStripComponentsAdapter;
    /**
     * @hidden @internal
    */
    get actionStripComponents(): IgrActionStripCollection;
    private _dragGhostCustomTemplate;
    private _dragGhostCustomTemplateAdapter;
    /**
     * Gets the custom template, if any, used for row drag ghost.
    */
    get dragGhostCustomTemplate(): React.FunctionComponent<{
        dataContext: IgrGridRowDragGhostContext;
    }> | React.Component<{
        dataContext: IgrGridRowDragGhostContext;
    }>;
    set dragGhostCustomTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridRowDragGhostContext;
    }> | React.Component<{
        dataContext: IgrGridRowDragGhostContext;
    }>);
    private _rowEditTextTemplate;
    private _rowEditTextTemplateAdapter;
    /**
     * Gets the row edit text template.
    */
    get rowEditTextTemplate(): React.FunctionComponent<{
        dataContext: IgrGridRowEditTextTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowEditTextTemplateContext;
    }>;
    set rowEditTextTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridRowEditTextTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowEditTextTemplateContext;
    }>);
    private _rowAddTextTemplate;
    private _rowAddTextTemplateAdapter;
    /**
     * Gets the row add text template.
    */
    get rowAddTextTemplate(): React.FunctionComponent<{
        dataContext: IgrGridEmptyTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridEmptyTemplateContext;
    }>;
    set rowAddTextTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridEmptyTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridEmptyTemplateContext;
    }>);
    private _rowEditActionsTemplate;
    private _rowEditActionsTemplateAdapter;
    /**
     * Gets the row edit actions template.
    */
    get rowEditActionsTemplate(): React.FunctionComponent<{
        dataContext: IgrGridRowEditActionsTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowEditActionsTemplateContext;
    }>;
    set rowEditActionsTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridRowEditActionsTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowEditActionsTemplateContext;
    }>);
    private _rowExpandedIndicatorTemplate;
    private _rowExpandedIndicatorTemplateAdapter;
    /**
     * Gets the row expand indicator template.
    */
    get rowExpandedIndicatorTemplate(): React.FunctionComponent<{
        dataContext: IgrGridRowTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowTemplateContext;
    }>;
    set rowExpandedIndicatorTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridRowTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowTemplateContext;
    }>);
    private _rowCollapsedIndicatorTemplate;
    private _rowCollapsedIndicatorTemplateAdapter;
    /**
     * Gets the row collapse indicator template.
    */
    get rowCollapsedIndicatorTemplate(): React.FunctionComponent<{
        dataContext: IgrGridRowTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowTemplateContext;
    }>;
    set rowCollapsedIndicatorTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridRowTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowTemplateContext;
    }>);
    private _headerExpandedIndicatorTemplate;
    private _headerExpandedIndicatorTemplateAdapter;
    /**
     * Gets the header expand indicator template.
    */
    get headerExpandedIndicatorTemplate(): React.FunctionComponent<{
        dataContext: IgrGridTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridTemplateContext;
    }>;
    set headerExpandedIndicatorTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridTemplateContext;
    }>);
    private _headerCollapsedIndicatorTemplate;
    private _headerCollapsedIndicatorTemplateAdapter;
    /**
     * Gets the row collapse indicator template.
    */
    get headerCollapsedIndicatorTemplate(): React.FunctionComponent<{
        dataContext: IgrGridTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridTemplateContext;
    }>;
    set headerCollapsedIndicatorTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridTemplateContext;
    }>);
    private _excelStyleHeaderIconTemplate;
    private _excelStyleHeaderIconTemplateAdapter;
    /**
     * Gets the excel style header icon.
    */
    get excelStyleHeaderIconTemplate(): React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>;
    set excelStyleHeaderIconTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>);
    private _sortAscendingHeaderIconTemplate;
    private _sortAscendingHeaderIconTemplateAdapter;
    /**
     * The custom template, if any, that should be used when rendering a header sorting indicator when columns are sorted in asc order.
    */
    get sortAscendingHeaderIconTemplate(): React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>;
    set sortAscendingHeaderIconTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>);
    private _sortDescendingHeaderIconTemplate;
    private _sortDescendingHeaderIconTemplateAdapter;
    /**
     * The custom template, if any, that should be used when rendering a header sorting indicator when columns are sorted in desc order.
    */
    get sortDescendingHeaderIconTemplate(): React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>;
    set sortDescendingHeaderIconTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>);
    private _sortHeaderIconTemplate;
    private _sortHeaderIconTemplateAdapter;
    /**
     * Gets custom template, if any, that should be used when rendering a header sorting indicator when columns are not sorted.
    */
    get sortHeaderIconTemplate(): React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>;
    set sortHeaderIconTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>);
    private _toolbar;
    private _actualToolbar;
    get actualToolbar(): IgrGridToolbar[];
    private _contentToolbar;
    get contentToolbar(): IgrGridToolbar[];
    private _toolbarAdapter;
    /**
     * @hidden @internal
    */
    get toolbar(): IgrGridToolbarCollection;
    private _paginationComponents;
    private _actualPaginationComponents;
    get actualPaginationComponents(): IgrPaginator[];
    private _contentPaginationComponents;
    get contentPaginationComponents(): IgrPaginator[];
    private _paginationComponentsAdapter;
    /**
     * @hidden @internal
    */
    get paginationComponents(): IgrPaginatorCollection;
    /**
     * Gets/Sets the resource strings.
     * @remarks
     * By default it uses EN resources.
    */
    get resourceStrings(): IgrGridResourceStrings;
    set resourceStrings(v: IgrGridResourceStrings);
    get filteringLogic(): FilteringLogic;
    set filteringLogic(v: FilteringLogic);
    get filteringExpressionsTree(): IgrFilteringExpressionsTree;
    set filteringExpressionsTree(v: IgrFilteringExpressionsTree);
    /**
     * Gets/Sets the advanced filtering state.
     * @example
     * ```typescript
     * let advancedFilteringExpressionsTree = this.grid.advancedFilteringExpressionsTree;
     * this.grid.advancedFilteringExpressionsTree = logic;
     * ```
    */
    get advancedFilteringExpressionsTree(): IgrFilteringExpressionsTree;
    set advancedFilteringExpressionsTree(v: IgrFilteringExpressionsTree);
    /**
     * Gets/Sets the locale.
     * @remarks
     * If not set, returns browser's language.
    */
    get locale(): string;
    set locale(v: string);
    get pagingMode(): GridPagingMode;
    set pagingMode(v: GridPagingMode);
    /**
     * Gets/Sets if the row selectors are hidden.
     * @remarks
     * By default row selectors are shown
    */
    get hideRowSelectors(): boolean;
    set hideRowSelectors(v: boolean);
    get rowDraggable(): boolean;
    set rowDraggable(v: boolean);
    get validationTrigger(): GridValidationTrigger;
    set validationTrigger(v: GridValidationTrigger);
    get rowEditable(): boolean;
    set rowEditable(v: boolean);
    get height(): string;
    set height(v: string);
    /**
     * Gets/Sets the width of the grid.
     * @example
     * ```typescript
     * let gridWidth = this.grid.width;
     * ```
    */
    get width(): string;
    set width(v: string);
    get rowHeight(): number;
    set rowHeight(v: number);
    get columnWidth(): string;
    set columnWidth(v: string);
    get emptyGridMessage(): string;
    set emptyGridMessage(v: string);
    get isLoading(): boolean;
    set isLoading(v: boolean);
    /**
     * Gets/Sets whether the columns should be auto-generated once again after the initialization of the grid
     * @deprecated Column re-creation now relies on `autoGenerate` instead.
    */
    get shouldGenerate(): boolean;
    set shouldGenerate(v: boolean);
    get emptyFilteredGridMessage(): string;
    set emptyFilteredGridMessage(v: string);
    get pinning(): IgrPinningConfig;
    set pinning(v: IgrPinningConfig);
    get allowFiltering(): boolean;
    set allowFiltering(v: boolean);
    get allowAdvancedFiltering(): boolean;
    set allowAdvancedFiltering(v: boolean);
    get filterMode(): FilterMode;
    set filterMode(v: FilterMode);
    get summaryPosition(): GridSummaryPosition;
    set summaryPosition(v: GridSummaryPosition);
    get summaryCalculationMode(): GridSummaryCalculationMode;
    set summaryCalculationMode(v: GridSummaryCalculationMode);
    get showSummaryOnCollapse(): boolean;
    set showSummaryOnCollapse(v: boolean);
    get filterStrategy(): IgrFilteringStrategy;
    set filterStrategy(v: IgrFilteringStrategy);
    get sortStrategy(): IgrGridSortingStrategy;
    set sortStrategy(v: IgrGridSortingStrategy);
    get sortingOptions(): IgrSortingOptions;
    set sortingOptions(v: IgrSortingOptions);
    get selectedRows(): any[];
    set selectedRows(v: any[]);
    private _headSelectorTemplate;
    private _headSelectorTemplateAdapter;
    /**
     * Gets the header row selector template.
    */
    get headSelectorTemplate(): React.FunctionComponent<{
        dataContext: IgrHeadSelectorTemplateContext;
    }> | React.Component<{
        dataContext: IgrHeadSelectorTemplateContext;
    }>;
    set headSelectorTemplate(v: React.FunctionComponent<{
        dataContext: IgrHeadSelectorTemplateContext;
    }> | React.Component<{
        dataContext: IgrHeadSelectorTemplateContext;
    }>);
    private _rowSelectorTemplate;
    private _rowSelectorTemplateAdapter;
    /**
     * Gets the row selector template.
    */
    get rowSelectorTemplate(): React.FunctionComponent<{
        dataContext: IgrRowSelectorTemplateContext;
    }> | React.Component<{
        dataContext: IgrRowSelectorTemplateContext;
    }>;
    set rowSelectorTemplate(v: React.FunctionComponent<{
        dataContext: IgrRowSelectorTemplateContext;
    }> | React.Component<{
        dataContext: IgrRowSelectorTemplateContext;
    }>);
    private _dragIndicatorIconTemplate;
    private _dragIndicatorIconTemplateAdapter;
    /**
     * The custom template, if any, that should be used when rendering the row drag indicator icon
    */
    get dragIndicatorIconTemplate(): React.FunctionComponent<{
        dataContext: IgrGridEmptyTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridEmptyTemplateContext;
    }>;
    set dragIndicatorIconTemplate(v: React.FunctionComponent<{
        dataContext: IgrGridEmptyTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridEmptyTemplateContext;
    }>);
    get sortingExpressions(): IgrSortingExpression[];
    set sortingExpressions(v: IgrSortingExpression[]);
    /**
     * Gets the number of hidden columns.
     * @example
     * ```typescript
     * const hiddenCol = this.grid.hiddenColumnsCount;
     * ``
    */
    get hiddenColumnsCount(): number;
    /**
     * Gets the number of pinned columns.
    */
    get pinnedColumnsCount(): number;
    get batchEditing(): boolean;
    set batchEditing(v: boolean);
    /**
     * Gets/Sets cell selection mode.
     * @remarks
     * By default the cell selection mode is multiple
     * selectionMode: GridSelectionMode
    */
    get cellSelection(): GridSelectionMode;
    set cellSelection(v: GridSelectionMode);
    /**
     * Gets/Sets row selection mode
     * @remarks
     * By default the row selection mode is 'none'
     * Note that in IgxGrid and IgxHierarchicalGrid 'multipleCascade' behaves like 'multiple'
    */
    get rowSelection(): GridSelectionMode;
    set rowSelection(v: GridSelectionMode);
    /**
     * Gets/Sets column selection mode
     * @remarks
     * By default the row selection mode is none
     * selectionMode: GridSelectionMode
    */
    get columnSelection(): GridSelectionMode;
    set columnSelection(v: GridSelectionMode);
    /**
     * Represents the last search information.
    */
    get lastSearchInfo(): IgrSearchInfo;
    /**
     * Returns an array of objects containing the filtered data.
     * @example
     * ```typescript
     * let filteredData = this.grid.filteredData;
     * ```
    */
    get filteredData(): any;
    /**
     * Returns an array containing the filtered sorted data.
     * @example
     * ```typescript
     * const filteredSortedData = this.grid1.filteredSortedData;
     * ```
    */
    get filteredSortedData(): any[];
    /**
     * Returns the state of the grid virtualization.
     * @remarks
     * Includes the start index and how many records are rendered.
     * @example
     * ```typescript
     * const gridVirtState = this.grid1.virtualizationState;
     * ```
    */
    get virtualizationState(): IgrForOfState;
    /**
     * Gets/Sets the outlet used to attach the grid's overlays to.
     * @remarks
     * If set, returns the outlet defined outside the grid. Otherwise returns the grid's internal outlet directive.
    */
    get outlet(): IgrOverlayOutletDirective;
    set outlet(v: IgrOverlayOutletDirective);
    /**
     * Gets the default row height.
     * @example
     * ```typescript
     * const rowHeigh = this.grid.defaultRowHeight;
     * ```
    */
    get defaultRowHeight(): number;
    /**
     * Returns the `IgxGridHeaderGroupComponent`'s minimum allowed width.
     * @remarks
     * Used internally for restricting header group component width.
     * The values below depend on the header cell default right/left padding values.
    */
    get defaultHeaderGroupMinWidth(): number;
    /**
     * Gets an array of `IgxColumnComponent`s.
     * @example
     * ```typescript
     * const colums = this.grid.columns.
     * ```
    */
    get columns(): IgrColumn[];
    /**
     * Gets an array of the pinned `IgxColumnComponent`s.
     * @example
     * ```typescript
     * const pinnedColumns = this.grid.pinnedColumns.
     * ```
    */
    get pinnedColumns(): IgrColumn[];
    /**
     * Gets an array of unpinned `IgxColumnComponent`s.
     * @example
     * ```typescript
     * const unpinnedColumns = this.grid.unpinnedColumns.
     * ```
    */
    get unpinnedColumns(): IgrColumn[];
    /**
     * Returns an array of visible `IgxColumnComponent`s.
     * @example
     * ```typescript
     * const visibleColumns = this.grid.visibleColumns.
     * ```
    */
    get visibleColumns(): IgrColumn[];
    /**
     * Returns the total number of records.
     * @remarks
     * Only functions when paging is enabled.
     * @example
     * ```typescript
     * const totalRecords = this.grid.totalRecords;
     * ```
    */
    get totalRecords(): number;
    set totalRecords(v: number);
    /**
     * Returns the currently transformed paged/filtered/sorted/grouped/pinned/unpinned row data, displayed in the grid.
     * @example
     * ```typescript
     * const dataView = this.grid.dataView;
     * ```
    */
    get dataView(): any[];
    /**
     * Gets/Sets whether clicking over a row should select/deselect it
     * @remarks
     * By default it is set to true
     * enabled: boolean
    */
    get selectRowOnClick(): boolean;
    set selectRowOnClick(v: boolean);
    private _actualColumnList;
    get actualColumnList(): IgrColumnCollection;
    set actualColumnList(v: IgrColumnCollection);
    private _stateComponents;
    private _actualStateComponents;
    get actualStateComponents(): IgrGridState[];
    private _contentStateComponents;
    get contentStateComponents(): IgrGridState[];
    private _stateComponentsAdapter;
    /**
     * @hidden @internal
    */
    get stateComponents(): IgrStateCollection;
    findByName(name: string): any;
    protected __p: string;
    protected _hasUserValues: Set<string>;
    protected get hasUserValues(): Set<string>;
    protected __m(propertyName: string): void;
    protected _stylingContainer: any;
    protected _stylingParent: any;
    protected _inStyling: boolean;
    protected _styling(container: any, component: any, parent?: any): void;
    setNativeElement(element: any): void;
    /**
     * Returns whether the record is pinned or not.
     * rowIndex Index of the record in the `filteredSortedData` collection.
    
    * @param rowIndex  * Index of the record in the `filteredSortedData` collection.
    */
    isRecordPinnedByIndex(rowIndex: number): void;
    /**
     * Toggles the specified column's visibility.
     * @example
     * ```typescript
     * this.grid1.toggleColumnVisibility({
     * column: this.grid1.columns[0],
     * newValue: true
     * });
     * ```
    
    */
    toggleColumnVisibility(args: IgrColumnVisibilityChangedEventArgs): void;
    /**
     * Expands all rows.
     * @example
     * ```typescript
     * this.grid.expandAll();
     * ```
    
    */
    expandAll(): void;
    /**
     * Collapses all rows.
     * @example
     * ```typescript
     * this.grid.collapseAll();
     * ```
    
    */
    collapseAll(): void;
    /**
     * Expands the row by its id.
     * @remarks
     * ID is either the primaryKey value or the data record instance.
     * @example
     * ```typescript
     * this.grid.expandRow(rowID);
     * ```
     * rowID The row id - primaryKey value or the data record instance.
    
    * @param rowID  * The row id - primaryKey value or the data record instance.
    */
    expandRow(rowID: any): void;
    /**
     * Collapses the row by its id.
     * @remarks
     * ID is either the primaryKey value or the data record instance.
     * @example
     * ```typescript
     * this.grid.collapseRow(rowID);
     * ```
     * rowID The row id - primaryKey value or the data record instance.
    
    * @param rowID  * The row id - primaryKey value or the data record instance.
    */
    collapseRow(rowID: any): void;
    /**
     * Toggles the row by its id.
     * @remarks
     * ID is either the primaryKey value or the data record instance.
     * @example
     * ```typescript
     * this.grid.toggleRow(rowID);
     * ```
     * rowID The row id - primaryKey value or the data record instance.
    
    * @param rowID  * The row id - primaryKey value or the data record instance.
    */
    toggleRow(rowID: any): void;
    /**
     * Gets the `width` to be set on `IgxGridHeaderGroupComponent`.
    
    */
    getHeaderGroupWidth(column: IgrColumn): string;
    /**
     * Returns the `IgxColumnComponent` by field name.
     * @example
     * ```typescript
     * const myCol = this.grid1.getColumnByName("ID");
     * ```
     * name
    
    * @param   * name
    */
    getColumnByName(name: string): IgrColumn;
    getColumnByVisibleIndex(index: number): IgrColumn;
    /**
     * Recalculates all widths of columns that have size set to `auto`.
     * @example
     * ```typescript
     * this.grid1.recalculateAutoSizes();
     * ```
    
    */
    recalculateAutoSizes(): void;
    moveColumn(column: IgrColumn, target: IgrColumn, pos: DropPosition): void;
    /**
     * Triggers change detection for the `IgxGridComponent`.
     * Calling markForCheck also triggers the grid pipes explicitly, resulting in all updates being processed.
     * May degrade performance if used when not needed, or if misused:
     * ```typescript
     * // DON'Ts:
     * // don't call markForCheck from inside a loop
     * // don't call markForCheck when a primitive has changed
     * grid.data.forEach(rec => {
     * rec = newValue;
     * grid.markForCheck();
     * });
     * // DOs
     * // call markForCheck after updating a nested property
     * grid.data.forEach(rec => {
     * rec.nestedProp1.nestedProp2 = newValue;
     * });
     * grid.markForCheck();
     * ```
     * @example
     * ```typescript
     * grid.markForCheck();
     * ```
    
    */
    markForCheck(): void;
    /**
     * Removes the `IgxGridRowComponent` and the corresponding data record by primary key.
     * @remarks
     * Requires that the `primaryKey` property is set.
     * The method accept rowSelector as a parameter, which is the rowID.
     * @example
     * ```typescript
     * this.grid1.deleteRow(0);
     * ```
     * rowSelector
    
    * @param   * rowSelector
    */
    deleteRow(rowSelector: any): any;
    updateCell(value: any, rowSelector: any, column: string): void;
    updateRow(value: any, rowSelector: any): void;
    /**
     * Returns the data that is contained in the row component.
     * @remarks
     * If the primary key is not specified the row selector match the row data.
     * @example
     * ```typescript
     * const data = grid.getRowData(94741);
     * ```
     * rowSelector correspond to rowID
    
    * @param rowSelector  * correspond to rowID
    */
    getRowData(rowSelector: any): any;
    sort(expression: IgrSortingExpression[]): void;
    filter(name: string, value: any, conditionOrExpressionTree: IgrFilteringExpressionsTreeOrFilteringOperation, ignoreCase?: boolean): void;
    filterGlobal(value: any, condition: any, ignoreCase: any): void;
    enableSummaries(rest: any[]): void;
    disableSummaries(rest: any[]): void;
    /**
     * If name is provided, clears the filtering state of the corresponding `IgxColumnComponent`.
     * @remarks
     * Otherwise clears the filtering state of all `IgxColumnComponent`s.
     * @example
     * ```typescript
     * this.grid.clearFilter();
     * ```
     * name
    
    * @param   * name
    */
    clearFilter(name: string): void;
    /**
     * If name is provided, clears the sorting state of the corresponding `IgxColumnComponent`.
     * @remarks
     * otherwise clears the sorting state of all `IgxColumnComponent`.
     * @example
     * ```typescript
     * this.grid.clearSort();
     * ```
     * name
    
    * @param   * name
    */
    clearSort(name: string): void;
    pinColumn(columnName: string, index?: number): boolean;
    unpinColumn(columnName: string, index?: number): boolean;
    /**
     * Recalculates grid width/height dimensions.
     * @remarks
     * Should be run when changing DOM elements dimentions manually that affect the grid's size.
     * @example
     * ```typescript
     * this.grid.reflow();
     * ```
    
    */
    reflow(): void;
    findNext(text: string, caseSensitive?: boolean, exactMatch?: boolean): number;
    findPrev(text: string, caseSensitive?: boolean, exactMatch?: boolean): number;
    refreshSearch(updateActiveInfo?: boolean, endEdit?: boolean): number;
    /**
     * Removes all the highlights in the cell.
     * @example
     * ```typescript
     * this.grid.clearSearch();
     * ```
    
    */
    clearSearch(): void;
    /**
     * Gets calculated width of the pinned area.
     * @example
     * ```typescript
     * const pinnedWidth = this.grid.getPinnedWidth();
     * ```
     * takeHidden If we should take into account the hidden columns in the pinned area.
    
    * @param takeHidden  * If we should take into account the hidden columns in the pinned area.
    */
    getPinnedWidth(takeHidden?: boolean): void;
    selectRows(rowIDs: any[], clearCurrentSelection?: boolean): void;
    deselectRows(rowIDs: any[]): void;
    /**
     * Selects all rows
     * @remarks
     * By default if filtering is in place, selectAllRows() and deselectAllRows() select/deselect all filtered rows.
     * If you set the parameter onlyFilterData to false that will select all rows in the grid exept deleted rows.
     * @example
     * ```typescript
     * this.grid.selectAllRows();
     * this.grid.selectAllRows(false);
     * ```
     * onlyFilterData
    
    * @param   * onlyFilterData
    */
    selectAllRows(onlyFilterData?: boolean): void;
    /**
     * Deselects all rows
     * @remarks
     * By default if filtering is in place, selectAllRows() and deselectAllRows() select/deselect all filtered rows.
     * If you set the parameter onlyFilterData to false that will deselect all rows in the grid exept deleted rows.
     * @example
     * ```typescript
     * this.grid.deselectAllRows();
     * ```
     * onlyFilterData
    
    * @param   * onlyFilterData
    */
    deselectAllRows(onlyFilterData?: boolean): void;
    /**
     * Deselect selected cells.
     * @example
     * ```typescript
     * this.grid.clearCellSelection();
     * ```
    
    */
    clearCellSelection(): void;
    selectRange(arg: IgrGridSelectionRange[]): void;
    /**
     * Get the currently selected ranges in the grid.
    
    */
    getSelectedRanges(): IgrGridSelectionRange[];
    getSelectedData(formatters?: boolean, headers?: boolean): void;
    /**
     * Get current selected columns.
     * @example
     * Returns an array with selected columns
     * ```typescript
     * const selectedColumns = this.grid.selectedColumns();
     * ```
    
    */
    selectedColumns(): IgrColumn[];
    selectColumns(columns: string[], clearCurrentSelection?: boolean): void;
    deselectColumns(columns: string[]): void;
    /**
     * Deselects all columns
     * @example
     * ```typescript
     * this.grid.deselectAllColumns();
     * ```
    
    */
    deselectAllColumns(): void;
    /**
     * Selects all columns
     * @example
     * ```typescript
     * this.grid.deselectAllColumns();
     * ```
    
    */
    selectAllColumns(): void;
    getSelectedColumnsData(formatters?: boolean, headers?: boolean): void;
    navigateTo(rowIndex: number, visibleColIndex: number, cb: any): void;
    getNextCell(currRowIndex: number, curVisibleColIndex: number, callback: any): IgrCellPosition;
    getPreviousCell(currRowIndex: number, curVisibleColIndex: number, callback: any): IgrCellPosition;
    /**
     * Opens the advanced filtering dialog.
    
    */
    openAdvancedFilteringDialog(overlaySettings: IgrOverlaySettings): void;
    /**
     * Closes the advanced filtering dialog.
     * applyChanges indicates whether the changes should be applied
    
    * @param applyChanges  * indicates whether the changes should be applied
    */
    closeAdvancedFilteringDialog(applyChanges: boolean): void;
    endEdit(commit: boolean, evt: any): boolean;
    beginAddRowById(rowID: any, asChild?: boolean): void;
    private _filteringExpressionsTreeChange;
    private _filteringExpressionsTreeChange_wrapped;
    get filteringExpressionsTreeChange(): (s: IgrGridBaseDirective, e: IgrFilteringExpressionsTreeEventArgs) => void;
    set filteringExpressionsTreeChange(ev: (s: IgrGridBaseDirective, e: IgrFilteringExpressionsTreeEventArgs) => void);
    private _advancedFilteringExpressionsTreeChange;
    private _advancedFilteringExpressionsTreeChange_wrapped;
    get advancedFilteringExpressionsTreeChange(): (s: IgrGridBaseDirective, e: IgrFilteringExpressionsTreeEventArgs) => void;
    set advancedFilteringExpressionsTreeChange(ev: (s: IgrGridBaseDirective, e: IgrFilteringExpressionsTreeEventArgs) => void);
    private _gridScroll;
    private _gridScroll_wrapped;
    get gridScroll(): (s: IgrGridBaseDirective, e: IgrGridScrollEventArgs) => void;
    set gridScroll(ev: (s: IgrGridBaseDirective, e: IgrGridScrollEventArgs) => void);
    private _cellClick;
    private _cellClick_wrapped;
    get cellClick(): (s: IgrGridBaseDirective, e: IgrGridCellEventArgs) => void;
    set cellClick(ev: (s: IgrGridBaseDirective, e: IgrGridCellEventArgs) => void);
    private _rowClick;
    private _rowClick_wrapped;
    get rowClick(): (s: IgrGridBaseDirective, e: IgrGridRowEventArgs) => void;
    set rowClick(ev: (s: IgrGridBaseDirective, e: IgrGridRowEventArgs) => void);
    private _formGroupCreated;
    private _formGroupCreated_wrapped;
    get formGroupCreated(): (s: IgrGridBaseDirective, e: IgrGridFormGroupCreatedEventArgs) => void;
    set formGroupCreated(ev: (s: IgrGridBaseDirective, e: IgrGridFormGroupCreatedEventArgs) => void);
    private _validationStatusChange;
    private _validationStatusChange_wrapped;
    get validationStatusChange(): (s: IgrGridBaseDirective, e: IgrGridValidationStatusEventArgs) => void;
    set validationStatusChange(ev: (s: IgrGridBaseDirective, e: IgrGridValidationStatusEventArgs) => void);
    private _selected;
    private _selected_wrapped;
    get selected(): (s: IgrGridBaseDirective, e: IgrGridCellEventArgs) => void;
    set selected(ev: (s: IgrGridBaseDirective, e: IgrGridCellEventArgs) => void);
    private _rowSelectionChanging;
    private _rowSelectionChanging_wrapped;
    get rowSelectionChanging(): (s: IgrGridBaseDirective, e: IgrRowSelectionEventArgs) => void;
    set rowSelectionChanging(ev: (s: IgrGridBaseDirective, e: IgrRowSelectionEventArgs) => void);
    private _columnSelectionChanging;
    private _columnSelectionChanging_wrapped;
    get columnSelectionChanging(): (s: IgrGridBaseDirective, e: IgrColumnSelectionEventArgs) => void;
    set columnSelectionChanging(ev: (s: IgrGridBaseDirective, e: IgrColumnSelectionEventArgs) => void);
    private _columnPin;
    private _columnPin_wrapped;
    /**
     * Emitted before `IgxColumnComponent` is pinned.
     * @remarks
     * The index at which to insert the column may be changed through the `insertAtIndex` property.
     * @example
     * ```typescript
     * public columnPinning(event) {
     * if (event.column.field === "Name") {
     * event.insertAtIndex = 0;
     * }
     * }
     * ```
    */
    get columnPin(): (s: IgrGridBaseDirective, e: IgrPinColumnCancellableEventArgs) => void;
    set columnPin(ev: (s: IgrGridBaseDirective, e: IgrPinColumnCancellableEventArgs) => void);
    private _columnPinned;
    private _columnPinned_wrapped;
    /**
     * Emitted after `IgxColumnComponent` is pinned.
     * @remarks
     * The index that the column is inserted at may be changed through the `insertAtIndex` property.
     * @example
     * ```typescript
     * public columnPinning(event) {
     * if (event.column.field === "Name") {
     * event.insertAtIndex = 0;
     * }
     * }
     * ```
    */
    get columnPinned(): (s: IgrGridBaseDirective, e: IgrPinColumnEventArgs) => void;
    set columnPinned(ev: (s: IgrGridBaseDirective, e: IgrPinColumnEventArgs) => void);
    private _cellEditEnter;
    private _cellEditEnter_wrapped;
    get cellEditEnter(): (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void;
    set cellEditEnter(ev: (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void);
    private _cellEditExit;
    private _cellEditExit_wrapped;
    get cellEditExit(): (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void;
    set cellEditExit(ev: (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void);
    private _cellEdit;
    private _cellEdit_wrapped;
    get cellEdit(): (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void;
    set cellEdit(ev: (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void);
    private _cellEditDone;
    private _cellEditDone_wrapped;
    get cellEditDone(): (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void;
    set cellEditDone(ev: (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void);
    private _rowEditEnter;
    private _rowEditEnter_wrapped;
    get rowEditEnter(): (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void;
    set rowEditEnter(ev: (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void);
    private _rowEdit;
    private _rowEdit_wrapped;
    get rowEdit(): (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void;
    set rowEdit(ev: (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void);
    private _rowEditDone;
    private _rowEditDone_wrapped;
    get rowEditDone(): (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void;
    set rowEditDone(ev: (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void);
    private _rowEditExit;
    private _rowEditExit_wrapped;
    get rowEditExit(): (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void;
    set rowEditExit(ev: (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void);
    private _columnInit;
    private _columnInit_wrapped;
    get columnInit(): (s: IgrGridBaseDirective, e: IgrColumnComponentEventArgs) => void;
    set columnInit(ev: (s: IgrGridBaseDirective, e: IgrColumnComponentEventArgs) => void);
    private _columnsAutogenerated;
    private _columnsAutogenerated_wrapped;
    /**
     * @hidden @internal
    */
    get columnsAutogenerated(): (s: IgrGridBaseDirective, e: IgrColumnsAutoGeneratedEventArgs) => void;
    set columnsAutogenerated(ev: (s: IgrGridBaseDirective, e: IgrColumnsAutoGeneratedEventArgs) => void);
    private _sorting;
    private _sorting_wrapped;
    get sorting(): (s: IgrGridBaseDirective, e: IgrSortingEventArgs) => void;
    set sorting(ev: (s: IgrGridBaseDirective, e: IgrSortingEventArgs) => void);
    private _sortingDone;
    private _sortingDone_wrapped;
    get sortingDone(): (s: IgrGridBaseDirective, e: IgrSortingExpressionEventArgs) => void;
    set sortingDone(ev: (s: IgrGridBaseDirective, e: IgrSortingExpressionEventArgs) => void);
    private _filtering;
    private _filtering_wrapped;
    get filtering(): (s: IgrGridBaseDirective, e: IgrFilteringEventArgs) => void;
    set filtering(ev: (s: IgrGridBaseDirective, e: IgrFilteringEventArgs) => void);
    private _filteringDone;
    private _filteringDone_wrapped;
    get filteringDone(): (s: IgrGridBaseDirective, e: IgrFilteringExpressionsTreeEventArgs) => void;
    set filteringDone(ev: (s: IgrGridBaseDirective, e: IgrFilteringExpressionsTreeEventArgs) => void);
    private _rowAdded;
    private _rowAdded_wrapped;
    get rowAdded(): (s: IgrGridBaseDirective, e: IgrRowDataEventArgs) => void;
    set rowAdded(ev: (s: IgrGridBaseDirective, e: IgrRowDataEventArgs) => void);
    private _rowDeleted;
    private _rowDeleted_wrapped;
    get rowDeleted(): (s: IgrGridBaseDirective, e: IgrRowDataEventArgs) => void;
    set rowDeleted(ev: (s: IgrGridBaseDirective, e: IgrRowDataEventArgs) => void);
    private _rowDelete;
    private _rowDelete_wrapped;
    get rowDelete(): (s: IgrGridBaseDirective, e: IgrRowDataCancelableEventArgs) => void;
    set rowDelete(ev: (s: IgrGridBaseDirective, e: IgrRowDataCancelableEventArgs) => void);
    private _rowAdd;
    private _rowAdd_wrapped;
    get rowAdd(): (s: IgrGridBaseDirective, e: IgrRowDataCancelableEventArgs) => void;
    set rowAdd(ev: (s: IgrGridBaseDirective, e: IgrRowDataCancelableEventArgs) => void);
    private _columnResized;
    private _columnResized_wrapped;
    get columnResized(): (s: IgrGridBaseDirective, e: IgrColumnResizeEventArgs) => void;
    set columnResized(ev: (s: IgrGridBaseDirective, e: IgrColumnResizeEventArgs) => void);
    private _contextMenu;
    private _contextMenu_wrapped;
    get contextMenu(): (s: IgrGridBaseDirective, e: IgrGridContextMenuEventArgs) => void;
    set contextMenu(ev: (s: IgrGridBaseDirective, e: IgrGridContextMenuEventArgs) => void);
    private _doubleClick;
    private _doubleClick_wrapped;
    get doubleClick(): (s: IgrGridBaseDirective, e: IgrGridCellEventArgs) => void;
    set doubleClick(ev: (s: IgrGridBaseDirective, e: IgrGridCellEventArgs) => void);
    private _columnVisibilityChanging;
    private _columnVisibilityChanging_wrapped;
    get columnVisibilityChanging(): (s: IgrGridBaseDirective, e: IgrColumnVisibilityChangingEventArgs) => void;
    set columnVisibilityChanging(ev: (s: IgrGridBaseDirective, e: IgrColumnVisibilityChangingEventArgs) => void);
    private _columnVisibilityChanged;
    private _columnVisibilityChanged_wrapped;
    get columnVisibilityChanged(): (s: IgrGridBaseDirective, e: IgrColumnVisibilityChangedEventArgs) => void;
    set columnVisibilityChanged(ev: (s: IgrGridBaseDirective, e: IgrColumnVisibilityChangedEventArgs) => void);
    private _columnMovingStart;
    private _columnMovingStart_wrapped;
    get columnMovingStart(): (s: IgrGridBaseDirective, e: IgrColumnMovingStartEventArgs) => void;
    set columnMovingStart(ev: (s: IgrGridBaseDirective, e: IgrColumnMovingStartEventArgs) => void);
    private _columnMoving;
    private _columnMoving_wrapped;
    get columnMoving(): (s: IgrGridBaseDirective, e: IgrColumnMovingEventArgs) => void;
    set columnMoving(ev: (s: IgrGridBaseDirective, e: IgrColumnMovingEventArgs) => void);
    private _columnMovingEnd;
    private _columnMovingEnd_wrapped;
    get columnMovingEnd(): (s: IgrGridBaseDirective, e: IgrColumnMovingEndEventArgs) => void;
    set columnMovingEnd(ev: (s: IgrGridBaseDirective, e: IgrColumnMovingEndEventArgs) => void);
    private _gridKeydown;
    private _gridKeydown_wrapped;
    get gridKeydown(): (s: IgrGridBaseDirective, e: IgrGridKeydownEventArgs) => void;
    set gridKeydown(ev: (s: IgrGridBaseDirective, e: IgrGridKeydownEventArgs) => void);
    private _rowDragStart;
    private _rowDragStart_wrapped;
    /**
     * Emitted when start dragging a row.
     * @remarks
     * Return the dragged row.
    */
    get rowDragStart(): (s: IgrGridBaseDirective, e: IgrRowDragStartEventArgs) => void;
    set rowDragStart(ev: (s: IgrGridBaseDirective, e: IgrRowDragStartEventArgs) => void);
    private _rowDragEnd;
    private _rowDragEnd_wrapped;
    /**
     * Emitted when dropping a row.
     * @remarks
     * Return the dropped row.
    */
    get rowDragEnd(): (s: IgrGridBaseDirective, e: IgrRowDragEndEventArgs) => void;
    set rowDragEnd(ev: (s: IgrGridBaseDirective, e: IgrRowDragEndEventArgs) => void);
    private _gridCopy;
    private _gridCopy_wrapped;
    /**
     * Emitted when a copy operation is executed.
     * @remarks
     * Fired only if copy behavior is enabled through the [`clipboardOptions`]{@link IgxGridBaseDirective#clipboardOptions}.
    */
    get gridCopy(): (s: IgrGridBaseDirective, e: IgrGridClipboardEventEventArgs) => void;
    set gridCopy(ev: (s: IgrGridBaseDirective, e: IgrGridClipboardEventEventArgs) => void);
    private _selectedRowsChange;
    private _selectedRowsChange_wrapped;
    /**
     * @hidden @internal
    */
    get selectedRowsChange(): (s: IgrGridBaseDirective, e: IgrComponentArrayDataValueChangedEventArgs) => void;
    set selectedRowsChange(ev: (s: IgrGridBaseDirective, e: IgrComponentArrayDataValueChangedEventArgs) => void);
    private _rowToggle;
    private _rowToggle_wrapped;
    get rowToggle(): (s: IgrGridBaseDirective, e: IgrRowToggleEventArgs) => void;
    set rowToggle(ev: (s: IgrGridBaseDirective, e: IgrRowToggleEventArgs) => void);
    private _rowPinning;
    private _rowPinning_wrapped;
    get rowPinning(): (s: IgrGridBaseDirective, e: IgrPinRowEventArgs) => void;
    set rowPinning(ev: (s: IgrGridBaseDirective, e: IgrPinRowEventArgs) => void);
    private _rowPinned;
    private _rowPinned_wrapped;
    get rowPinned(): (s: IgrGridBaseDirective, e: IgrPinRowEventArgs) => void;
    set rowPinned(ev: (s: IgrGridBaseDirective, e: IgrPinRowEventArgs) => void);
    private _activeNodeChange;
    private _activeNodeChange_wrapped;
    get activeNodeChange(): (s: IgrGridBaseDirective, e: IgrActiveNodeChangeEventArgs) => void;
    set activeNodeChange(ev: (s: IgrGridBaseDirective, e: IgrActiveNodeChangeEventArgs) => void);
    private _sortingExpressionsChange;
    private _sortingExpressionsChange_wrapped;
    get sortingExpressionsChange(): (s: IgrGridBaseDirective, e: IgrSortingExpressionEventArgs) => void;
    set sortingExpressionsChange(ev: (s: IgrGridBaseDirective, e: IgrSortingExpressionEventArgs) => void);
    private _toolbarExporting;
    private _toolbarExporting_wrapped;
    /**
     * Emitted when an export process is initiated by the user.
     * @example
     * ```typescript
     * toolbarExporting(event: IGridToolbarExportEventArgs){
     * const toolbarExporting = event;
     * }
     * ```
    */
    get toolbarExporting(): (s: IgrGridBaseDirective, e: IgrGridToolbarExportEventArgs) => void;
    set toolbarExporting(ev: (s: IgrGridBaseDirective, e: IgrGridToolbarExportEventArgs) => void);
    private _rangeSelected;
    private _rangeSelected_wrapped;
    /**
     * Emitted when making a range selection.
     * @remarks
     * Range selection can be made either through drag selection or through keyboard selection.
    */
    get rangeSelected(): (s: IgrGridBaseDirective, e: IgrGridSelectionRangeEventArgs) => void;
    set rangeSelected(ev: (s: IgrGridBaseDirective, e: IgrGridSelectionRangeEventArgs) => void);
    private _rendered;
    private _rendered_wrapped;
    /**
     * Emitted after the ngAfterViewInit hook. At this point the grid exists in the DOM
    */
    get rendered(): (s: IgrGridBaseDirective, e: IgrVoidEventArgs) => void;
    set rendered(ev: (s: IgrGridBaseDirective, e: IgrVoidEventArgs) => void);
    private _dataChanging;
    private _dataChanging_wrapped;
    get dataChanging(): (s: IgrGridBaseDirective, e: IgrForOfDataChangingEventArgs) => void;
    set dataChanging(ev: (s: IgrGridBaseDirective, e: IgrForOfDataChangingEventArgs) => void);
    private _dataChanged;
    private _dataChanged_wrapped;
    get dataChanged(): (s: IgrGridBaseDirective, e: IgrVoidEventArgs) => void;
    set dataChanged(ev: (s: IgrGridBaseDirective, e: IgrVoidEventArgs) => void);
}
export interface IIgrGridBaseDirectiveProps {
    children?: React.ReactNode;
    id?: string | undefined;
    className?: string | undefined;
    style?: React.CSSProperties | undefined;
    /**
     * Gets/Sets the display time for the row adding snackbar notification.
     * @remarks
     * By default it is 6000ms.
    */
    snackbarDisplayTime?: number | string;
    autoGenerate?: boolean | string;
    autoGenerateExclude?: string[];
    /**
     * Controls whether columns moving is enabled in the grid.
    */
    moving?: boolean | string;
    emptyGridTemplate?: React.FunctionComponent<{
        dataContext: any;
    }> | React.Component<{
        dataContext: any;
    }>;
    addRowEmptyTemplate?: React.FunctionComponent<{
        dataContext: any;
    }> | React.Component<{
        dataContext: any;
    }>;
    loadingGridTemplate?: React.FunctionComponent<{
        dataContext: any;
    }> | React.Component<{
        dataContext: any;
    }>;
    /**
     * Get/Set IgxSummaryRow height
    */
    summaryRowHeight?: number | string;
    dataCloneStrategy?: IgrDataCloneStrategy;
    /**
     * Controls the copy behavior of the grid.
    */
    clipboardOptions?: IgrClipboardOptions;
    rowClasses?: any;
    rowStyles?: any;
    primaryKey?: string;
    /**
     * Gets the custom template, if any, used for row drag ghost.
    */
    dragGhostCustomTemplate?: React.FunctionComponent<{
        dataContext: IgrGridRowDragGhostContext;
    }> | React.Component<{
        dataContext: IgrGridRowDragGhostContext;
    }>;
    /**
     * Gets the row edit text template.
    */
    rowEditTextTemplate?: React.FunctionComponent<{
        dataContext: IgrGridRowEditTextTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowEditTextTemplateContext;
    }>;
    /**
     * Gets the row add text template.
    */
    rowAddTextTemplate?: React.FunctionComponent<{
        dataContext: IgrGridEmptyTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridEmptyTemplateContext;
    }>;
    /**
     * Gets the row edit actions template.
    */
    rowEditActionsTemplate?: React.FunctionComponent<{
        dataContext: IgrGridRowEditActionsTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowEditActionsTemplateContext;
    }>;
    /**
     * Gets the row expand indicator template.
    */
    rowExpandedIndicatorTemplate?: React.FunctionComponent<{
        dataContext: IgrGridRowTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowTemplateContext;
    }>;
    /**
     * Gets the row collapse indicator template.
    */
    rowCollapsedIndicatorTemplate?: React.FunctionComponent<{
        dataContext: IgrGridRowTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridRowTemplateContext;
    }>;
    /**
     * Gets the header expand indicator template.
    */
    headerExpandedIndicatorTemplate?: React.FunctionComponent<{
        dataContext: IgrGridTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridTemplateContext;
    }>;
    /**
     * Gets the row collapse indicator template.
    */
    headerCollapsedIndicatorTemplate?: React.FunctionComponent<{
        dataContext: IgrGridTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridTemplateContext;
    }>;
    /**
     * Gets the excel style header icon.
    */
    excelStyleHeaderIconTemplate?: React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>;
    /**
     * The custom template, if any, that should be used when rendering a header sorting indicator when columns are sorted in asc order.
    */
    sortAscendingHeaderIconTemplate?: React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>;
    /**
     * The custom template, if any, that should be used when rendering a header sorting indicator when columns are sorted in desc order.
    */
    sortDescendingHeaderIconTemplate?: React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>;
    /**
     * Gets custom template, if any, that should be used when rendering a header sorting indicator when columns are not sorted.
    */
    sortHeaderIconTemplate?: React.FunctionComponent<{
        dataContext: IgrGridHeaderTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridHeaderTemplateContext;
    }>;
    /**
     * Gets/Sets the resource strings.
     * @remarks
     * By default it uses EN resources.
    */
    resourceStrings?: IgrGridResourceStrings;
    filteringLogic?: FilteringLogic | string;
    filteringExpressionsTree?: IgrFilteringExpressionsTree;
    /**
     * Gets/Sets the advanced filtering state.
     * @example
     * ```typescript
     * let advancedFilteringExpressionsTree = this.grid.advancedFilteringExpressionsTree;
     * this.grid.advancedFilteringExpressionsTree = logic;
     * ```
    */
    advancedFilteringExpressionsTree?: IgrFilteringExpressionsTree;
    /**
     * Gets/Sets the locale.
     * @remarks
     * If not set, returns browser's language.
    */
    locale?: string;
    pagingMode?: GridPagingMode | string;
    /**
     * Gets/Sets if the row selectors are hidden.
     * @remarks
     * By default row selectors are shown
    */
    hideRowSelectors?: boolean | string;
    rowDraggable?: boolean | string;
    validationTrigger?: GridValidationTrigger | string;
    rowEditable?: boolean | string;
    height?: string;
    /**
     * Gets/Sets the width of the grid.
     * @example
     * ```typescript
     * let gridWidth = this.grid.width;
     * ```
    */
    width?: string;
    rowHeight?: number | string;
    columnWidth?: string;
    emptyGridMessage?: string;
    isLoading?: boolean | string;
    /**
     * Gets/Sets whether the columns should be auto-generated once again after the initialization of the grid
    */
    shouldGenerate?: boolean | string;
    emptyFilteredGridMessage?: string;
    pinning?: IgrPinningConfig;
    allowFiltering?: boolean | string;
    allowAdvancedFiltering?: boolean | string;
    filterMode?: FilterMode | string;
    summaryPosition?: GridSummaryPosition | string;
    summaryCalculationMode?: GridSummaryCalculationMode | string;
    showSummaryOnCollapse?: boolean | string;
    filterStrategy?: IgrFilteringStrategy;
    sortStrategy?: IgrGridSortingStrategy;
    sortingOptions?: IgrSortingOptions;
    selectedRows?: any[];
    /**
     * Gets the header row selector template.
    */
    headSelectorTemplate?: React.FunctionComponent<{
        dataContext: IgrHeadSelectorTemplateContext;
    }> | React.Component<{
        dataContext: IgrHeadSelectorTemplateContext;
    }>;
    /**
     * Gets the row selector template.
    */
    rowSelectorTemplate?: React.FunctionComponent<{
        dataContext: IgrRowSelectorTemplateContext;
    }> | React.Component<{
        dataContext: IgrRowSelectorTemplateContext;
    }>;
    /**
     * The custom template, if any, that should be used when rendering the row drag indicator icon
    */
    dragIndicatorIconTemplate?: React.FunctionComponent<{
        dataContext: IgrGridEmptyTemplateContext;
    }> | React.Component<{
        dataContext: IgrGridEmptyTemplateContext;
    }>;
    sortingExpressions?: IgrSortingExpression[];
    batchEditing?: boolean | string;
    /**
     * Gets/Sets cell selection mode.
     * @remarks
     * By default the cell selection mode is multiple
     * selectionMode: GridSelectionMode
    */
    cellSelection?: GridSelectionMode | string;
    /**
     * Gets/Sets row selection mode
     * @remarks
     * By default the row selection mode is 'none'
     * Note that in IgxGrid and IgxHierarchicalGrid 'multipleCascade' behaves like 'multiple'
    */
    rowSelection?: GridSelectionMode | string;
    /**
     * Gets/Sets column selection mode
     * @remarks
     * By default the row selection mode is none
     * selectionMode: GridSelectionMode
    */
    columnSelection?: GridSelectionMode | string;
    /**
     * Gets/Sets the outlet used to attach the grid's overlays to.
     * @remarks
     * If set, returns the outlet defined outside the grid. Otherwise returns the grid's internal outlet directive.
    */
    outlet?: IgrOverlayOutletDirective;
    /**
     * Returns the total number of records.
     * @remarks
     * Only functions when paging is enabled.
     * @example
     * ```typescript
     * const totalRecords = this.grid.totalRecords;
     * ```
    */
    totalRecords?: number | string;
    /**
     * Gets/Sets whether clicking over a row should select/deselect it
     * @remarks
     * By default it is set to true
     * enabled: boolean
    */
    selectRowOnClick?: boolean | string;
    filteringExpressionsTreeChange?: (s: IgrGridBaseDirective, e: IgrFilteringExpressionsTreeEventArgs) => void;
    advancedFilteringExpressionsTreeChange?: (s: IgrGridBaseDirective, e: IgrFilteringExpressionsTreeEventArgs) => void;
    gridScroll?: (s: IgrGridBaseDirective, e: IgrGridScrollEventArgs) => void;
    cellClick?: (s: IgrGridBaseDirective, e: IgrGridCellEventArgs) => void;
    rowClick?: (s: IgrGridBaseDirective, e: IgrGridRowEventArgs) => void;
    formGroupCreated?: (s: IgrGridBaseDirective, e: IgrGridFormGroupCreatedEventArgs) => void;
    validationStatusChange?: (s: IgrGridBaseDirective, e: IgrGridValidationStatusEventArgs) => void;
    selected?: (s: IgrGridBaseDirective, e: IgrGridCellEventArgs) => void;
    rowSelectionChanging?: (s: IgrGridBaseDirective, e: IgrRowSelectionEventArgs) => void;
    columnSelectionChanging?: (s: IgrGridBaseDirective, e: IgrColumnSelectionEventArgs) => void;
    /**
     * Emitted before `IgxColumnComponent` is pinned.
     * @remarks
     * The index at which to insert the column may be changed through the `insertAtIndex` property.
     * @example
     * ```typescript
     * public columnPinning(event) {
     * if (event.column.field === "Name") {
     * event.insertAtIndex = 0;
     * }
     * }
     * ```
    */
    columnPin?: (s: IgrGridBaseDirective, e: IgrPinColumnCancellableEventArgs) => void;
    /**
     * Emitted after `IgxColumnComponent` is pinned.
     * @remarks
     * The index that the column is inserted at may be changed through the `insertAtIndex` property.
     * @example
     * ```typescript
     * public columnPinning(event) {
     * if (event.column.field === "Name") {
     * event.insertAtIndex = 0;
     * }
     * }
     * ```
    */
    columnPinned?: (s: IgrGridBaseDirective, e: IgrPinColumnEventArgs) => void;
    cellEditEnter?: (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void;
    cellEditExit?: (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void;
    cellEdit?: (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void;
    cellEditDone?: (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void;
    rowEditEnter?: (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void;
    rowEdit?: (s: IgrGridBaseDirective, e: IgrGridEditEventArgs) => void;
    rowEditDone?: (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void;
    rowEditExit?: (s: IgrGridBaseDirective, e: IgrGridEditDoneEventArgs) => void;
    columnInit?: (s: IgrGridBaseDirective, e: IgrColumnComponentEventArgs) => void;
    /**
     * @hidden @internal
    */
    columnsAutogenerated?: (s: IgrGridBaseDirective, e: IgrColumnsAutoGeneratedEventArgs) => void;
    sorting?: (s: IgrGridBaseDirective, e: IgrSortingEventArgs) => void;
    sortingDone?: (s: IgrGridBaseDirective, e: IgrSortingExpressionEventArgs) => void;
    filtering?: (s: IgrGridBaseDirective, e: IgrFilteringEventArgs) => void;
    filteringDone?: (s: IgrGridBaseDirective, e: IgrFilteringExpressionsTreeEventArgs) => void;
    rowAdded?: (s: IgrGridBaseDirective, e: IgrRowDataEventArgs) => void;
    rowDeleted?: (s: IgrGridBaseDirective, e: IgrRowDataEventArgs) => void;
    rowDelete?: (s: IgrGridBaseDirective, e: IgrRowDataCancelableEventArgs) => void;
    rowAdd?: (s: IgrGridBaseDirective, e: IgrRowDataCancelableEventArgs) => void;
    columnResized?: (s: IgrGridBaseDirective, e: IgrColumnResizeEventArgs) => void;
    contextMenu?: (s: IgrGridBaseDirective, e: IgrGridContextMenuEventArgs) => void;
    doubleClick?: (s: IgrGridBaseDirective, e: IgrGridCellEventArgs) => void;
    columnVisibilityChanging?: (s: IgrGridBaseDirective, e: IgrColumnVisibilityChangingEventArgs) => void;
    columnVisibilityChanged?: (s: IgrGridBaseDirective, e: IgrColumnVisibilityChangedEventArgs) => void;
    columnMovingStart?: (s: IgrGridBaseDirective, e: IgrColumnMovingStartEventArgs) => void;
    columnMoving?: (s: IgrGridBaseDirective, e: IgrColumnMovingEventArgs) => void;
    columnMovingEnd?: (s: IgrGridBaseDirective, e: IgrColumnMovingEndEventArgs) => void;
    gridKeydown?: (s: IgrGridBaseDirective, e: IgrGridKeydownEventArgs) => void;
    /**
     * Emitted when start dragging a row.
     * @remarks
     * Return the dragged row.
    */
    rowDragStart?: (s: IgrGridBaseDirective, e: IgrRowDragStartEventArgs) => void;
    /**
     * Emitted when dropping a row.
     * @remarks
     * Return the dropped row.
    */
    rowDragEnd?: (s: IgrGridBaseDirective, e: IgrRowDragEndEventArgs) => void;
    /**
     * Emitted when a copy operation is executed.
     * @remarks
     * Fired only if copy behavior is enabled through the [`clipboardOptions`]{@link IgxGridBaseDirective#clipboardOptions}.
    */
    gridCopy?: (s: IgrGridBaseDirective, e: IgrGridClipboardEventEventArgs) => void;
    /**
     * @hidden @internal
    */
    selectedRowsChange?: (s: IgrGridBaseDirective, e: IgrComponentArrayDataValueChangedEventArgs) => void;
    rowToggle?: (s: IgrGridBaseDirective, e: IgrRowToggleEventArgs) => void;
    rowPinning?: (s: IgrGridBaseDirective, e: IgrPinRowEventArgs) => void;
    rowPinned?: (s: IgrGridBaseDirective, e: IgrPinRowEventArgs) => void;
    activeNodeChange?: (s: IgrGridBaseDirective, e: IgrActiveNodeChangeEventArgs) => void;
    sortingExpressionsChange?: (s: IgrGridBaseDirective, e: IgrSortingExpressionEventArgs) => void;
    /**
     * Emitted when an export process is initiated by the user.
     * @example
     * ```typescript
     * toolbarExporting(event: IGridToolbarExportEventArgs){
     * const toolbarExporting = event;
     * }
     * ```
    */
    toolbarExporting?: (s: IgrGridBaseDirective, e: IgrGridToolbarExportEventArgs) => void;
    /**
     * Emitted when making a range selection.
     * @remarks
     * Range selection can be made either through drag selection or through keyboard selection.
    */
    rangeSelected?: (s: IgrGridBaseDirective, e: IgrGridSelectionRangeEventArgs) => void;
    /**
     * Emitted after the ngAfterViewInit hook. At this point the grid exists in the DOM
    */
    rendered?: (s: IgrGridBaseDirective, e: IgrVoidEventArgs) => void;
    dataChanging?: (s: IgrGridBaseDirective, e: IgrForOfDataChangingEventArgs) => void;
    dataChanged?: (s: IgrGridBaseDirective, e: IgrVoidEventArgs) => void;
}