import * as i0 from '@angular/core';
import { EventEmitter, InjectionToken, QueryList, ElementRef, TemplateRef, ChangeDetectorRef, ViewContainerRef, DoCheck, IterableDiffer, OnDestroy, AfterViewInit, OnInit, AfterContentInit, IterableDiffers, PipeTransform, EnvironmentInjector, Injector, NgZone, OnChanges, SimpleChanges } from '@angular/core';
import * as igniteui_angular_core from 'igniteui-angular/core';
import { IBaseEventArgs, GridTypeBase, GridColumnDataType, ColumnType, CancelableEventArgs, IFilteringExpressionsTree, ISortingExpression, IGroupingExpression, TransactionService, Transaction, State, SortingDirection, IDataCloneStrategy, IGridMergeStrategy, IGridResourceStrings, ɵSize as _Size, IgxSummaryResult, IGroupByRecord, ITreeGridRecord, IPathSegment, ColumnPinningPosition, FilteringExpressionsTree, GridSummaryCalculationMode, IGridSortingStrategy, IGridGroupingStrategy, FilteringLogic, IFilteringStrategy, ISortingOptions, IGroupByExpandState, IgxOverlayOutletDirective, OverlaySettings, IFilteringExpression, IgxOverlayService, IFilteringOperation, PlatformUtil, IgxFilteringOperand, ISortingStrategy, IColumnPipeArgs, IColumnEditorOptions, MRLColumnSizeInfo, MRLResizeColumnInfo, FieldType, IgxFilterItem, trackByIdentity, IgxActionStripToken, IPagingState, IGroupingState, FilteringStrategy, PositionSettings, ConnectedPositioningStrategy, Point } from 'igniteui-angular/core';
import { IBaseSearchInfo, IgxGridForOfDirective, IForOfState, IgxToggleDirective, IgxForOfDirective, IDragStartEventArgs, IgxButtonDirective, IgxDropDirective, IgxDragDirective, ToggleViewCancelableEventArgs, ToggleViewEventArgs, IgxTooltipDirective, IgxTextHighlightDirective } from 'igniteui-angular/directives';
import { Subject, Observable, Subscription } from 'rxjs';
import * as _angular_forms from '@angular/forms';
import { FormGroup, ValidationErrors, FormControl, RequiredValidator, MinValidator, MaxValidator, EmailValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, Validator } from '@angular/forms';
import { IgxPaginatorComponent } from 'igniteui-angular/paginator';
import { IgxCheckboxComponent, IChangeCheckboxEventArgs } from 'igniteui-angular/checkbox';
import * as igniteui_angular_grids_core from 'igniteui-angular/grids/core';
import { IgxChipsAreaComponent, IgxChipComponent, IBaseChipEventArgs, IChipsAreaReorderEventArgs } from 'igniteui-angular/chips';
import { IgxQueryBuilderComponent } from 'igniteui-angular/query-builder';
import { IgxSelectComponent } from 'igniteui-angular/select';
import { IgxInputDirective } from 'igniteui-angular/input-group';
import { IgxButtonGroupComponent } from 'igniteui-angular/button-group';
import { IgxDropDownComponent, ISelectionEventArgs } from 'igniteui-angular/drop-down';
import { IgxListComponent } from 'igniteui-angular/list';
import { IgxTreeComponent, ITreeNodeSelectionEvent } from 'igniteui-angular/tree';
import { IgxIconService, IgxIconComponent } from 'igniteui-angular/icon';
import { IgxDatePickerComponent } from 'igniteui-angular/date-picker';
import { IgxTimePickerComponent } from 'igniteui-angular/time-picker';
import { jsPDF } from 'jspdf';

/**
 * Enumeration representing different filter modes for grid filtering.
 * - quickFilter: Default mode with a filter row UI between the column headers and the first row of records.
 * - excelStyleFilter: Filter mode where an Excel-style filter is used.
 */
declare const FilterMode: {
    readonly quickFilter: "quickFilter";
    readonly excelStyleFilter: "excelStyleFilter";
};
type FilterMode = (typeof FilterMode)[keyof typeof FilterMode];
/**
 * Enumeration representing the position of grid summary rows.
 * - top: Default value; Summary rows are displayed at the top of the grid.
 * - bottom: Summary rows are displayed at the bottom of the grid.
 */
declare const GridSummaryPosition: {
    readonly top: "top";
    readonly bottom: "bottom";
};
type GridSummaryPosition = (typeof GridSummaryPosition)[keyof typeof GridSummaryPosition];
/**
 * Type representing the triggers for grid cell validation.
 * - 'change': Validation is triggered when the cell value changes.
 * - 'blur': Validation is triggered when the cell loses focus.
 */
type GridValidationTrigger = 'change' | 'blur';
/**
 * Type representing the type of the target object (elements of the grid) for keydown (fired when a key is pressed) events in the grid.
 * - 'dataCell': Represents a data cell within the grid. It contains and displays individual data values
 * - 'summaryCell': Summary cells display aggregated/summarized data at the bottom of the grid. They provide insights like total record count, min/max values, etc.
 * - 'groupRow': Group row within the grid. Group rows are used to group related data rows by columns. Contains the related group expression, level, sub-records and group value.
 * - 'hierarchicalRow': Hierarchical rows are similar to group rows, but represent a more complex hierarchical structure, allowing for nested grouping
 * - 'headerCell': Represents a header cell within the grid. Header cells are used to display column headers, providing context and labels for the columns.
 * - 'masterDetailRow': Represents a grid row that can be expanded in order to show additional information
 */
type GridKeydownTargetType = 'dataCell' | 'summaryCell' | 'groupRow' | 'hierarchicalRow' | 'headerCell' | 'masterDetailRow';
/**
 * Enumeration representing different selection modes for the grid elements if can be selected.
 * - 'none': No selection is allowed. Default row and column selection mode.
 * - 'single': Only one element can be selected at a time. Selecting a new one will deselect the previously selected one.
 * - 'multiple': Default cell selection mode. More than one element can be selected at a time.
 * - 'multipleCascade': Similar to multiple selection. It is used in hierarchical or tree grids. Allows selection not only to an individual item but also all its related or nested items in a single action
 */
declare const GridSelectionMode: {
    readonly none: "none";
    readonly single: "single";
    readonly multiple: "multiple";
    readonly multipleCascade: "multipleCascade";
};
type GridSelectionMode = (typeof GridSelectionMode)[keyof typeof GridSelectionMode];
/**
 * Enumeration representing different cell merging modes for the grid elements.
 * - 'never': Never merge cells.
 * - 'always': Always merge adjacent cells based on merge strategy.
 * - 'onSort': Only merge cells in column that are sorted.
 */
declare const GridCellMergeMode: {
    readonly always: "always";
    readonly onSort: "onSort";
};
type GridCellMergeMode = (typeof GridCellMergeMode)[keyof typeof GridCellMergeMode];
/** Enumeration representing different column display order options. */
declare const ColumnDisplayOrder: {
    readonly Alphabetical: "Alphabetical";
    readonly DisplayOrder: "DisplayOrder";
};
type ColumnDisplayOrder = (typeof ColumnDisplayOrder)[keyof typeof ColumnDisplayOrder];
/**
 * Enumeration representing the possible positions for pinning rows.
 * - Top: Rows are pinned to the top of the grid.
 * - Bottom: Rows are pinned to the bottom of the grid.
 */
declare enum RowPinningPosition {
    Top = 0,
    Bottom = 1
}
/**
 * Enumeration representing different paging modes for the grid.
 * - Local: The grid will use local data to extract pages during paging.
 * - Remote: The grid will expect pages to be delivered from a remote location and will only raise events during paging interactions.
 */
declare const GridPagingMode: {
    readonly Local: "local";
    readonly Remote: "remote";
};
type GridPagingMode = (typeof GridPagingMode)[keyof typeof GridPagingMode];

declare abstract class IgxExporterOptionsBase {
    protected _fileExtension: string;
    /**
     * Specifies whether hidden columns should be exported.
     * ```typescript
     * let ignoreColumnsVisibility = this.exportOptions.ignoreColumnsVisibility;
     * this.exportOptions.ignoreColumnsVisibility = true;
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    ignoreColumnsVisibility: boolean;
    /**
     * Specifies whether filtered out rows should be exported.
     * ```typescript
     * let ignoreFiltering = this.exportOptions.ignoreFiltering;
     * this.exportOptions.ignoreFiltering = true;
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    ignoreFiltering: boolean;
    /**
     * Specifies if the exporter should ignore the current column order in the IgxGrid.
     * ```typescript
     * let ignoreColumnsOrder = this.exportOptions.ignoreColumnsOrder;
     * this.exportOptions.ignoreColumnsOrder = true;
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    ignoreColumnsOrder: boolean;
    /**
     * Specifies whether the exported data should be sorted as in the provided IgxGrid.
     * When you export grouped data, setting ignoreSorting to true will cause
     * the grouping to fail because it relies on the sorting of the records.
     * ```typescript
     * let ignoreSorting = this.exportOptions.ignoreSorting;
     * this.exportOptions.ignoreSorting = true;
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    ignoreSorting: boolean;
    /**
     * Specifies whether the exported data should be grouped as in the provided IgxGrid.
     * ```typescript
     * let ignoreGrouping = this.exportOptions.ignoreGrouping;
     * this.exportOptions.ignoreGrouping = true;
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    ignoreGrouping: boolean;
    /**
     * Specifies whether the exported data should include multi column headers as in the provided IgxGrid.
     * ```typescript
     * let ignoreMultiColumnHeaders = this.exportOptions.ignoreMultiColumnHeaders;
     * this.exportOptions.ignoreMultiColumnHeaders = true;
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    ignoreMultiColumnHeaders: boolean;
    /**
     * Specifies whether the exported data should include column summaries.
     * ```typescript
     * let exportSummaries = this.exportOptions.exportSummaries;
     * this.exportOptions.exportSummaries = true;
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    exportSummaries: boolean;
    /**
     * Specifies whether the exported data should have frozen headers.
     * ```typescript
     * let freezeHeaders = this.exportOptions.freezeHeaders;
     * this.exportOptions.freezeHeaders = true;
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    freezeHeaders: boolean;
    /**
     * Specifies whether the headers should be exported if there is no data.
     * ```typescript
     * let alwaysExportHeaders = this.exportOptions.alwaysExportHeaders;
     * this.exportOptions.alwaysExportHeaders = false;
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    alwaysExportHeaders: boolean;
    private _fileName;
    constructor(fileName: string, _fileExtension: string);
    private setFileName;
    /**
     * Gets the file name which will be used for the exporting operation.
     * ```typescript
     * let fileName = this.exportOptions.fileName;
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    get fileName(): string;
    /**
     * Sets the file name which will be used for the exporting operation.
     * ```typescript
     * this.exportOptions.fileName = 'exportedData01';
     * ```
     *
     * @memberof IgxExporterOptionsBase
     */
    set fileName(value: string);
}

declare enum ExportRecordType {
    GroupedRecord = "GroupedRecord",
    TreeGridRecord = "TreeGridRecord",
    DataRecord = "DataRecord",
    HierarchicalGridRecord = "HierarchicalGridRecord",
    HeaderRecord = "HeaderRecord",
    SummaryRecord = "SummaryRecord",
    PivotGridRecord = "PivotGridRecord"
}
declare enum ExportHeaderType {
    RowHeader = "RowHeader",
    ColumnHeader = "ColumnHeader",
    MultiRowHeader = "MultiRowHeader",
    MultiColumnHeader = "MultiColumnHeader",
    PivotRowHeader = "PivotRowHeader",
    PivotMergedHeader = "PivotMergedHeader"
}
interface IExportRecord {
    data: any;
    level: number;
    type: ExportRecordType;
    owner?: string | GridTypeBase;
    hidden?: boolean;
    summaryKey?: string;
    hierarchicalOwner?: string;
    references?: IColumnInfo[];
    rawData?: any;
    dimensionKeys?: string[];
}
interface IColumnList {
    columns: IColumnInfo[];
    columnWidths: number[];
    indexOfLastPinnedColumn: number;
    maxLevel?: number;
    maxRowLevel?: number;
}
interface IColumnInfo {
    header: string;
    field: string;
    skip: boolean;
    dataType?: GridColumnDataType;
    skipFormatter?: boolean;
    formatter?: any;
    headerType?: ExportHeaderType;
    startIndex?: number;
    columnSpan?: number;
    rowSpan?: number;
    level?: number;
    exportIndex?: number;
    pinnedIndex?: number;
    columnGroupParent?: ColumnType | string;
    columnGroup?: ColumnType | string;
    currencyCode?: string;
    displayFormat?: string;
    dateFormat?: string;
    digitsInfo?: string;
}
/**
 * rowExporting event arguments
 * this.exporterService.rowExporting.subscribe((args: IRowExportingEventArgs) => {
 * // set args properties here
 * })
 */
interface IRowExportingEventArgs extends IBaseEventArgs {
    /**
     * Contains the exporting row data
     */
    rowData: any;
    /**
     * Contains the exporting row index
     */
    rowIndex: number;
    /**
     * Skip the exporting row when set to true
     */
    cancel: boolean;
}
/**
 * columnExporting event arguments
 * ```typescript
 * this.exporterService.columnExporting.subscribe((args: IColumnExportingEventArgs) => {
 * // set args properties here
 * });
 * ```
 */
interface IColumnExportingEventArgs extends IBaseEventArgs {
    /**
     * Contains the exporting column header
     */
    header: string;
    /**
     * Contains the exporting column field name
     */
    field: string;
    /**
     * Contains the exporting column index
     */
    columnIndex: number;
    /**
     * Skip the exporting column when set to true
     */
    cancel: boolean;
    /**
     * Export the column's data without applying its formatter, when set to true
     */
    skipFormatter: boolean;
    /**
     * A reference to the grid owner.
     */
    grid?: GridTypeBase;
}
declare const DEFAULT_OWNER = "default";
declare const GRID_ROOT_SUMMARY = "igxGridRootSummary";
declare const GRID_PARENT = "grid-parent";
declare const GRID_LEVEL_COL = "GRID_LEVEL_COL";
declare abstract class IgxBaseExporter {
    exportEnded: EventEmitter<IBaseEventArgs>;
    /**
     * This event is emitted when a row is exported.
     * ```typescript
     * this.exporterService.rowExporting.subscribe((args: IRowExportingEventArgs) => {
     * // put event handler code here
     * });
     * ```
     *
     * @memberof IgxBaseExporter
     */
    rowExporting: EventEmitter<IRowExportingEventArgs>;
    /**
     * This event is emitted when a column is exported.
     * ```typescript
     * this.exporterService.columnExporting.subscribe((args: IColumnExportingEventArgs) => {
     * // put event handler code here
     * });
     * ```
     *
     * @memberof IgxBaseExporter
     */
    columnExporting: EventEmitter<IColumnExportingEventArgs>;
    protected _sort: any;
    protected pivotGridFilterFieldsCount: number;
    protected _ownersMap: Map<any, IColumnList>;
    private locale;
    private _setChildSummaries;
    private isPivotGridExport;
    private options;
    private summaries;
    private rowIslandCounter;
    private flatRecords;
    private pivotGridColumns;
    private pivotGridRowDimensionsMap;
    private ownerGrid;
    /**
     * Method for exporting IgxGrid component's data.
     * ```typescript
     * this.exporterService.export(this.igxGridForExport, this.exportOptions);
     * ```
     *
     * @memberof IgxBaseExporter
     */
    export(grid: any, options: IgxExporterOptionsBase): void;
    /**
     * Method for exporting any kind of array data.
     * ```typescript
     * this.exporterService.exportData(this.arrayForExport, this.exportOptions);
     * ```
     *
     * @memberof IgxBaseExporter
     */
    exportData(data: any[], options: IgxExporterOptionsBase): void;
    private addToRowDimensionsMap;
    private exportGridRecordsData;
    private calculateColumnSpans;
    private exportRow;
    private reorderColumns;
    private prepareData;
    private preparePivotGridData;
    private prepareHierarchicalGridData;
    private addHierarchicalGridData;
    private prepareSummaries;
    private prepareIslandData;
    private getAllChildColumnsAndData;
    private prepareGridData;
    private prepareTreeGridData;
    private addTreeGridData;
    private getTreeGridChildData;
    private addFlatData;
    private setSummaries;
    private addGroupedData;
    private getColumns;
    private mapHierarchicalGridColumns;
    private getAutoGeneratedColumns;
    private addPivotRowHeaders;
    private addPivotGridColumns;
    private preparePivotGridColumns;
    private groupByKeys;
    private calculateRowSpan;
    private createRowDimension;
    private addLevelColumns;
    private addLevelData;
    private resetDefaults;
    protected abstract exportDataImplementation(data: any[], options: IgxExporterOptionsBase, done: () => void): void;
}

/** The event arguments when data from a grid is being copied. */
interface IGridClipboardEvent {
    /** `data` can be of any type and refers to the data that is being copied/stored to the clipboard */
    data: any[];
    /**
     * `cancel` returns whether an external event has intercepted the copying
     * If the value becomes "true", it returns/exits from the method, instantiating the interface
     */
    cancel: boolean;
}
/** Represents an event argument related to grid cell interactions. */
interface IGridCellEventArgs extends IBaseEventArgs {
    /** Represents the grid cell that triggered the event. */
    cell: CellType;
    /**
     * Represents the original event that occurred
     * Examples of such events include: selecting, clicking, double clicking, etc.
     */
    event: Event;
}
/** Represents an event argument related to grid row interactions. */
interface IGridRowEventArgs extends IBaseEventArgs {
    /** Represents the grid row that triggered the event. */
    row: RowType;
    /**
     * Represents the original event that occurred
     * Examples of such events include: selecting, clicking, double clicking, etc.
     */
    event: Event;
}
/** Represents an event argument for the grid contextMenu output */
interface IGridContextMenuEventArgs extends IGridCellEventArgs, IGridRowEventArgs {
}
/** Represents event arguments related to grid editing completion. */
interface IGridEditDoneEventArgs extends IBaseEventArgs {
    /**
     * @deprecated since version 17.1.0. Use the `rowKey` property instead.
     */
    rowID: any;
    /**
     * @deprecated since version 17.1.0. Use the `rowKey` property instead.
     */
    primaryKey: any;
    rowKey: any;
    cellID?: {
        rowID: any;
        columnID: any;
        rowIndex: number;
    };
    /**
     * `rowData` represents the updated/committed data of the row after the edit (newValue)
     * The only case rowData (of the current object) is used directly, is when there is no rowEditing or transactions enabled
     */
    rowData: any;
    /**
     * Represents the previous (before editing) value of the edited cell.
     * It's used when the event has been stopped/exited.
     */
    oldValue: any;
    /**
     * Optional
     * Represents the value, that is being entered in the edited cell
     * When there is no `newValue` and the event has ended, the value of the cell returns to the `oldValue`
     */
    newValue?: any;
    /**
     * Optional
     * Represents the original event, that has triggered the edit
     */
    event?: Event;
    /**
     * Optional
     * Represents the column information of the edited cell
     */
    column?: ColumnType;
    /**
     * Optional
     * Represents the grid instance that owns the edit event.
     */
    owner?: GridType;
    /**
     * Optional
     * Indicates if the editing consists of adding a new row
     */
    isAddRow?: boolean;
    /**
     * Optional
     * Indicates if the new value would be valid.
     * It can be set to return the result of the methods for validation of the grid
     */
    valid?: boolean;
}
/**
 * Represents event arguments related to grid editing.
 * The event is cancelable
 * It contains information about the row and the column, as well as the old and nwe value of the element/cell
 */
interface IGridEditEventArgs extends CancelableEventArgs, IGridEditDoneEventArgs {
}
interface IRowDataCancelableEventArgs extends IRowDataEventArgs, IGridEditEventArgs {
    /**
     * @deprecated
     */
    cellID?: {
        rowID: any;
        columnID: any;
        rowIndex: number;
    };
    /**
     * @deprecated
     */
    oldValue: any;
    /**
     * @deprecated
     */
    newValue?: any;
    /**
     * @deprecated
     */
    isAddRow?: boolean;
    owner: GridType;
}
/**
 * The event arguments after a column's pin state is changed.
 * `insertAtIndex`specifies at which index in the pinned/unpinned area the column was inserted.
 * `isPinned` returns the actual pin state of the column after the operation completed.
 */
interface IPinColumnEventArgs extends IBaseEventArgs {
    column: ColumnType;
    /**
     * If pinned, specifies at which index in the pinned area the column is inserted.
     * If unpinned, specifies at which index in the unpinned area the column is inserted.
     */
    insertAtIndex: number;
    /**
     * Returns the actual pin state of the column.
     * If pinning/unpinning is successful, value of `isPinned` will change accordingly when read in the "-ing" and "-ed" event.
     */
    isPinned: boolean;
}
/**
 * The event arguments before a column's pin state is changed.
 * `insertAtIndex`specifies at which index in the pinned/unpinned area the column is inserted.
 * Can be changed in the `columnPin` event.
 * `isPinned` returns the actual pin state of the column. When pinning/unpinning is successful,
 * the value of `isPinned` will change accordingly when read in the "-ing" and "-ed" event.
 */
interface IPinColumnCancellableEventArgs extends IPinColumnEventArgs, CancelableEventArgs {
}
/**
 * Represents event arguments related to events, that can occur for rows in a grid
 * Example for events: adding, deleting, selection, transaction, etc.
 */
interface IRowDataEventArgs extends IBaseEventArgs {
    /**
     * @deprecated since version 17.1.0. Use the `rowData` property instead.
     */
    data: any;
    rowData: any;
    /**
     * Represents the unique key, the row can be associated with.
     * Available if `primaryKey` exists
     * @deprecated since version 17.1.0. Use the `rowKey` property instead.
     */
    primaryKey: any;
    rowKey: any;
    /** Represents the grid instance that owns the edit event. */
    owner: GridType;
}
/** The event arguments when a column is being resized */
interface IColumnResizeEventArgs extends IBaseEventArgs {
    /** Represents the information of the column that is being resized */
    column: ColumnType;
    /** Represents the old width of the column before the resizing */
    prevWidth: string;
    /** Represents the new width, the column is being resized to */
    newWidth: string;
}
/**
 * The event arguments when a column is being resized
 * It contains information about the column, it's old and new width
 * The event can be canceled
 */
interface IColumnResizingEventArgs extends IColumnResizeEventArgs, CancelableEventArgs {
}
/**
 * The event arguments when the selection state of a row is being changed
 * The event is cancelable
 */
interface IRowSelectionEventArgs extends CancelableEventArgs, IBaseEventArgs {
    /** Represents an array of rows, that have already been selected */
    readonly oldSelection: any[];
    /** Represents the newly selected rows */
    newSelection: any[];
    /**
     * Represents an array of all added rows
     * Whenever a row has been selected, the array is "refreshed" with the selected rows
     */
    readonly added: any[];
    /**
     * Represents an array of all rows, removed from the selection
     * Whenever a row has been deselected, the array is "refreshed" with the rows,
     * that have been previously selected, but are no longer
     */
    readonly removed: any[];
    /**
     * Represents the original event, that has triggered the selection change
     * selecting, deselecting
     */
    readonly event?: Event;
    /** Indicates whether or not all rows of the grid have been selected */
    readonly allRowsSelected?: boolean;
}
/**
 * The event arguments when the selection state of a column is being changed
 * The event is cancelable
 */
interface IColumnSelectionEventArgs extends CancelableEventArgs, IBaseEventArgs {
    /** Represents an array of columns, that have already been selected */
    readonly oldSelection: string[];
    /** Represents the newly selected columns */
    newSelection: string[];
    /**
     * Represents an array of all added columns
     * Whenever a column has been selected, the array is "refreshed" with the selected columns
     */
    readonly added: string[];
    /**
     * Represents an array of all columns, removed from the selection
     * Whenever a column has been deselected, the array is "refreshed" with the columns, that have been previously selected, but are no longer
     */
    readonly removed: string[];
    /**
     * Represents the original event, that has triggered the selection change
     * selecting, deselecting
     */
    readonly event?: Event;
}
interface ISearchInfo extends IBaseSearchInfo {
    matchInfoCache: any[];
    activeMatchIndex: number;
}
/**
 * Represents the arguments for the grid toolbar export event.
 * It provides information about the grid instance, exporter service, export options,
 * and allows the event to be canceled.
 */
interface IGridToolbarExportEventArgs extends IBaseEventArgs {
    /** `grid` represents a reference to the instance of the grid te event originated from */
    grid: GridType;
    /**
     * The `exporter` is a base service.
     * The type (an abstract class `IgxBaseExporter`) has it's own properties and methods
     * It is used to define the format and options of the export, the exported element
     * and methods for preparing the data from the elements for exporting
     */
    exporter: IgxBaseExporter;
    /**
     * Represents the different settings, that can be given to an export
     * The type (an abstract class `IgxExporterOptionsBase`) has properties for column settings
     * (whether they should be ignored) as well as method for generating a file name
     */
    options: IgxExporterOptionsBase;
    /**
     * `cancel` returns whether the event has been intercepted and stopped
     * If the value becomes "true", it returns/exits from the method, instantiating the interface
     */
    cancel: boolean;
}
/** Represents event arguments related to the start of a column moving operation in a grid. */
interface IColumnMovingStartEventArgs extends IBaseEventArgs {
    /**
     * Represents the column that is being moved.
     * The `ColumnType` contains the information (the grid it belongs to, css data, settings, etc.) of the column in its properties
     */
    source: ColumnType;
}
/** Represents event arguments related to a column moving operation in a grid */
interface IColumnMovingEventArgs extends IBaseEventArgs {
    /**
     * Represents the column that is being moved.
     * The `ColumnType` contains the information (the grid it belongs to, css data, settings, etc.) of the column in its properties
     */
    source: ColumnType;
    /**
     * `cancel` returns whether the event has been intercepted and stopped
     * If the value becomes "true", it returns/exits from the method, instantiating the interface
     */
    cancel: boolean;
}
/** Represents event arguments related to the end of a column moving operation in a grid */
interface IColumnMovingEndEventArgs extends IBaseEventArgs {
    /**
     * The source of the event represents the column that is being moved.
     * The `ColumnType` contains the information (the grid it belongs to, css data, settings, etc.) of the column in its properties
     */
    source: ColumnType;
    /**
     * The target of the event represents the column, the source is being moved to.
     * The `ColumnType` contains the information (the grid it belongs to, css data, settings, etc.) of the column in its properties
     */
    target: ColumnType;
    /**
     * `cancel` returns whether the event has been intercepted and stopped
     * If the value becomes "true", it returns/exits from the method, instantiating the interface
     */
    cancel: boolean;
}
/**
 * Represents an event, emitted when keydown is triggered over element inside grid's body
 * This event is fired only if the key combination is supported in the grid.
 */
interface IGridKeydownEventArgs extends IBaseEventArgs {
    /** The `targetType` represents the type of the targeted object. For example a cell or a row */
    targetType: GridKeydownTargetType;
    /** Represents the information and details of the object itself */
    target: any;
    /** Represents the original event, that occurred. */
    event: Event;
    /**
     * The event is cancelable
     * `cancel` returns whether the event has been intercepted and stopped
     * If the value becomes "true", it returns/exits from the method, instantiating the interface
     */
    cancel: boolean;
}
/** The event is triggered when getting the current position of a certain cell */
interface ICellPosition {
    /** It returns the position (index) of the row, the cell is in */
    rowIndex: number;
    /**
     * It returns the position (index) of the column, the cell is in
     * Counts only the visible (non hidden) columns
     */
    visibleColumnIndex: number;
}
/** Emitted when a dragging operation is finished (when the row is dropped) */
interface IRowDragEndEventArgs extends IBaseEventArgs {
    /** Represents the drag directive or information associated with the drag operation */
    dragDirective: any;
    /** Represents the information of the row that is being dragged. */
    dragData: RowType;
    /** Represents the HTML element itself */
    dragElement: HTMLElement;
    /** `animation` returns whether the event is animated */
    animation: boolean;
}
/**
 * Emitted when a dragging operation is starting (when the row is "picked")
 * The event is cancelable
 */
interface IRowDragStartEventArgs extends CancelableEventArgs, IBaseEventArgs {
    /** Represents the drag directive or information associated with the drag operation */
    dragDirective: any;
    /** Represents the information of the row that is being dragged. */
    dragData: RowType;
    /** Represents the HTML element itself */
    dragElement: HTMLElement;
}
/** Represents event arguments related to the row's expansion state being changed in a grid */
interface IRowToggleEventArgs extends IBaseEventArgs {
    /**
     * Represents the ID of the row that emitted the event (which state is changed)
     * @deprecated since version 17.1.0. Use the `rowKey` property instead.
     */
    rowID: any;
    rowKey: any;
    /**
     * Returns the state of the row after the operation has ended
     * Indicating whether the row is being expanded (true) or collapsed (false)
     */
    expanded: boolean;
    /**
     * Optional
     * Represents the original event, that has triggered the expansion/collapse
     */
    event?: Event;
    /**
     * The event is cancelable
     * `cancel` returns whether the event has been intercepted and stopped
     * If the value becomes "true", it returns/exits from the method, instantiating the interface
     */
    cancel: boolean;
}
/**
 * Event emitted when a row's pin state changes.
 * The event is cancelable
 */
interface IPinRowEventArgs extends IBaseEventArgs, CancelableEventArgs {
    /**
     * The ID of the row, that was pinned/unpinned.
     * ID is either the primaryKey value or the data record instance.
     * @deprecated since version 17.1.0. Use the `rowKey` property instead.
     */
    readonly rowID: any;
    readonly rowKey: any;
    row?: RowType;
    /** The index at which to pin the row in the pinned rows collection. */
    insertAtIndex?: number;
    /** Whether or not the row is pinned or unpinned. */
    readonly isPinned: boolean;
}
/**
 * Event emitted when a grid is scrolled.
 */
interface IGridScrollEventArgs extends IBaseEventArgs {
    /** The scroll direction - vertical or horizontal. */
    direction: string;
    /** The original browser scroll event. */
    event: Event;
    /** The new scroll position */
    scrollPosition: number;
}
/**
 * Event emitted when a checkbox in the checkbox
 * list of an IgxColumnActions component is clicked.
 */
interface IColumnToggledEventArgs extends IBaseEventArgs {
    /** The column that is toggled. */
    column: ColumnType;
    /** The checked state after the action. */
    checked: boolean;
}
/** Emitted when the active node is changed */
interface IActiveNodeChangeEventArgs extends IBaseEventArgs {
    /** Represents the row index of the active node */
    row: number;
    /** Represents the column index of the active node */
    column: number;
    /**
     * Optional
     * Represents the hierarchical level of the active node
     */
    level?: number;
    /**
     * Represents the type of the active node.
     * The GridKeydownTargetType is an enum or that specifies the possible target types
     */
    tag: GridKeydownTargetType;
}
/**
 * Represents event arguments related to sorting and grouping operations
 * The event is cancelable
 */
interface ISortingEventArgs extends IBaseEventArgs, CancelableEventArgs {
    /**
     * Optional
     * Represents the sorting expressions applied to the grid.
     * It can be a single sorting expression or an array of them
     * The expression contains information like file name, whether the letter case should be taken into account, etc.
     */
    sortingExpressions?: ISortingExpression | Array<ISortingExpression>;
    /**
     * Optional
     * Represents the grouping expressions applied to the grid.
     * It can be a single grouping expression or an array of them
     * The expression contains information like the sorting expression and criteria by which the elements will be grouped
     */
    groupingExpressions?: IGroupingExpression | Array<IGroupingExpression>;
}
/** @hidden @internal */
interface IColumnsAutoGeneratedEventArgs extends IBaseEventArgs {
    columns?: ColumnType[];
}
/**
 * Represents event arguments related to filtering operations
 * The event is cancelable
 */
interface IFilteringEventArgs extends IBaseEventArgs, CancelableEventArgs {
    /**
     * Represents the filtering expressions applied to the grid.
     * The expression contains information like filtering operands and operator, an expression or condition, etc.
     */
    filteringExpressions: IFilteringExpressionsTree;
}
/** The event arguments after a column's visibility is changed. */
interface IColumnVisibilityChangedEventArgs extends IBaseEventArgs {
    /** Represents the column the event originated from */
    column: any;
    /**
     * The new hidden state that the column will have, if operation is successful.
     * Will be `true` when hiding and `false` when showing.
     */
    newValue: boolean;
}
/**
 * The event arguments when a column's visibility is changed.
 * The event is cancelable
 * It contains information about the column and the it's visibility after the operation (will be `true` when hiding and `false` when showing)
 */
interface IColumnVisibilityChangingEventArgs extends IColumnVisibilityChangedEventArgs, CancelableEventArgs {
}

declare class IgxEditRow {
    id: any;
    index: number;
    data: any;
    grid: GridType;
    transactionState: any;
    state: any;
    newData: any;
    rowFormGroup: FormGroup<{}>;
    constructor(id: any, index: number, data: any, grid: GridType);
    createRowEditEventArgs(includeNewValue?: boolean, event?: Event): IGridEditEventArgs;
    createRowDataEventArgs(event?: Event): IRowDataCancelableEventArgs;
    createRowEditDoneEventArgs(cachedRowData: any, event?: Event): IGridEditDoneEventArgs;
    get isAddRow(): boolean;
}
declare class IgxAddRow extends IgxEditRow {
    recordRef: any;
    constructor(id: any, index: number, data: any, recordRef: any, grid: GridType);
    createRowEditEventArgs(includeNewValue?: boolean, event?: Event): IGridEditEventArgs;
    createRowEditDoneEventArgs(cachedRowData: any, event?: Event): IGridEditDoneEventArgs;
    get isAddRow(): boolean;
}
interface IgxAddRowParent {
    /**
     * @deprecated since version 17.1.0. Use `rowKey` instead
     */
    rowID: string;
    rowKey: any;
    index: number;
    asChild: boolean;
    isPinned: boolean;
}
declare class IgxCell {
    id: any;
    rowIndex: number;
    column: any;
    value: any;
    _editValue: any;
    rowData: any;
    grid: GridType;
    primaryKey: any;
    state: any;
    pendingValue: any;
    constructor(id: any, rowIndex: number, column: any, value: any, _editValue: any, rowData: any, grid: GridType);
    get editValue(): any;
    set editValue(value: any);
    castToNumber(value: any): any;
    createCellEditEventArgs(includeNewValue?: boolean, event?: Event): IGridEditEventArgs;
    createCellEditDoneEventArgs(value: any, event?: Event): IGridEditDoneEventArgs;
}
declare class IgxCellCrudState {
    grid: GridType;
    cell: IgxCell | null;
    row: IgxEditRow | null;
    isInCompositionMode: boolean;
    createCell(cell: any): IgxCell;
    createRow(cell: IgxCell): IgxEditRow;
    sameRow(rowID: any): boolean;
    sameCell(cell: IgxCell): boolean;
    get cellInEditMode(): boolean;
    beginCellEdit(event?: Event): void;
    cellEdit(event?: Event): IGridEditEventArgs;
    updateCell(exit: boolean, event?: Event): IGridEditEventArgs;
    cellEditDone(event: any, addRow: boolean): IGridEditDoneEventArgs;
    /** Exit cell edit mode */
    exitCellEdit(event?: Event): IGridEditDoneEventArgs;
    /** Clears cell editing state */
    endCellEdit(restoreFocus?: boolean): void;
    /** Returns whether the targeted cell is in edit mode */
    targetInEdit(rowIndex: number, columnIndex: number): boolean;
}
declare class IgxRowCrudState extends IgxCellCrudState {
    closeRowEditingOverlay: Subject<unknown>;
    private _rowEditingBlocked;
    private _rowEditingStarted;
    get primaryKey(): any;
    get rowInEditMode(): RowType;
    get rowEditing(): boolean;
    get nonEditable(): boolean;
    get rowEditingBlocked(): boolean;
    set rowEditingBlocked(val: boolean);
    /** Enters row edit mode */
    beginRowEdit(event?: Event): boolean;
    rowEdit(event: Event): IGridEditEventArgs;
    updateRow(commit: boolean, event?: Event): IGridEditEventArgs;
    /**
     * @hidden @internal
     */
    endRowTransaction(commit: boolean, event?: Event): IGridEditEventArgs | IRowDataCancelableEventArgs;
    rowEditDone(cachedRowData: any, event: Event): IGridEditDoneEventArgs;
    /** Exit row edit mode */
    exitRowEdit(cachedRowData: any, event?: Event): IGridEditDoneEventArgs;
    /** Clears row editing state */
    endRowEdit(): void;
    /** Clears cell and row editing state and closes row editing template if it is open */
    endEditMode(): void;
    updateRowEditData(row: IgxEditRow, value?: any): void;
    protected getParentRowId(): any;
}
declare class IgxRowAddCrudState extends IgxRowCrudState {
    addRowParent: IgxAddRowParent;
    /**
     * @hidden @internal
     */
    createAddRow(parentRow: RowType, asChild?: boolean): IgxAddRow;
    /**
     * @hidden @internal
     */
    createAddRowParent(row: RowType, newRowAsChild?: boolean): void;
    /**
     * @hidden @internal
     */
    endRowTransaction(commit: boolean, event?: Event): IGridEditEventArgs | IRowDataCancelableEventArgs;
    /**
     * @hidden @internal
     */
    endAddRow(): void;
    /**
     * @hidden
     * @internal
     * TODO: consider changing modifier
     */
    _findRecordIndexInView(rec: any): number;
    protected getParentRowId(): any;
}
declare class IgxGridCRUDService extends IgxRowAddCrudState {
    enterEditMode(cell: any, event?: Event): boolean;
    /**
     * Enters add row mode by creating temporary dummy so the user can fill in new row cells.
     *
     * @param parentRow Parent row after which the Add Row UI will be rendered.
     *                  If `null` will show it at the bottom after all rows (or top if there are not rows).
     * @param asChild Specifies if the new row should be added as a child to a tree row.
     * @param event Base event that triggered the add row mode.
     */
    enterAddRowMode(parentRow: RowType, asChild?: boolean, event?: Event): void;
    /**
     * Finishes the row transactions on the current row and returns whether the grid editing was canceled.
     *
     * @remarks
     * If `commit === true`, passes them from the pending state to the data (or transaction service)
     * @example
     * ```html
     * <button type="button" igxButton (click)="grid.endEdit(true)">Commit Row</button>
     * ```
     * @param commit
     */
    endEdit(commit?: boolean, event?: Event): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridCRUDService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxGridCRUDService>;
}

/**
 * Represents a range selection between certain rows and columns of the grid.
 * Range selection can be made either through drag selection or through keyboard selection.
 */
interface GridSelectionRange {
    /** The index of the starting row of the selection range. */
    rowStart: number;
    /** The index of the ending row of the selection range. */
    rowEnd: number;
    /**
     * The identifier or index of the starting column of the selection range.
     * It can be either a string representing the column's field name or a numeric index.
     */
    columnStart: string | number;
    /**
     * The identifier or index of the ending column of the selection range.
     * It can be either a string representing the column's field name or a numeric index.
     */
    columnEnd: string | number;
}
/**
 * Represents a single selected cell or node in a grid.
 */
interface ISelectionNode {
    /**
     * The index of the selected row.
     */
    row: number;
    /**
     * The index of the selected column.
     */
    column: number;
    /**
     * (Optional)
     * Additional layout information for multi-row selection nodes.
     */
    layout?: IMultiRowLayoutNode;
    /**
     * (Optional)
     * Indicates if the selected node is a summary row.
     * This property is true if the selected row is a summary row; otherwise, it is false.
     */
    isSummaryRow?: boolean;
}
interface IMultiRowLayoutNode {
    rowStart: number;
    colStart: number;
    rowEnd: number;
    colEnd: number;
    columnVisibleIndex: number;
}
/**
 * Represents the state of the keyboard when selecting.
 */
interface ISelectionKeyboardState {
    /** The selected node in the grid, if any. Can be null if no node is selected. */
    node: null | ISelectionNode;
    /** Indicates whether the Shift key is currently pressed during the selection. */
    shift: boolean;
    /** The range of the selected cells in the grid. Can be null when resetting the selection. */
    range: GridSelectionRange;
    /** Indicates whether the selection is currently active (being performed). `False` when resetting the selection.  */
    active: boolean;
}
/**
 * Represents the state of the grid selection using pointer interactions (mouse).
 * Extends ISelectionKeyboardState to include pointer-specific properties.
 */
interface ISelectionPointerState extends ISelectionKeyboardState {
    /** Indicates whether the Ctrl key is currently pressed during the selection. */
    ctrl: boolean;
    /** Indicates whether the primary pointer button is pressed during the selection (clicked). */
    primaryButton: boolean;
}
/**
 * Represents the state of the columns in the grid.
 */
interface IColumnSelectionState {
    /** Represents the field name of the selected column, if any. Can be null if no column is selected. */
    field: null | string;
    /** An array of strings representing the ranges of selected columns in the grid. */
    range: string[];
}
/**
 * Represents the overall state of grid selection, combining both keyboard and pointer interaction states.
 * It can be either an ISelectionKeyboardState or an ISelectionPointerState.
 */
type SelectionState = ISelectionKeyboardState | ISelectionPointerState;
/**
 * Injection token for accessing the grid transaction object.
 * This allows injecting the grid transaction object into components or services.
 */
declare const IgxGridTransaction: InjectionToken<TransactionService<Transaction, State>>;

/**
 * This enumeration is used to configure whether the drop position is set before or after
 * the target.
 */
declare enum DropPosition {
    BeforeDropTarget = 0,
    AfterDropTarget = 1
}
/**
 * @hidden
 * @internal
 */
declare class IgxColumnMovingService {
    cancelDrop: boolean;
    icon: HTMLElement;
    column: ColumnType;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnMovingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxColumnMovingService>;
}

declare class IgxGridValidationService {
    /**
     * @hidden
     * @internal
     */
    grid: GridType;
    private _validityStates;
    private _valid;
    /** Gets whether state is valid.
    */
    get valid(): boolean;
    /**
     * @hidden
     * @internal
     */
    create(rowId: any, data: any): FormGroup<any>;
    /**
    * @hidden
    * @internal
    */
    private addFormControl;
    /**
     * @hidden
     * @internal
     Wraps the provided path into an array. This way FormGroup.get will return proper result.
     Otherwise, if the path is a string (e.g. 'address.street'), FormGroup.get will treat it as there is a nested structure
     and will look for control with a name of 'address' which returns undefined.
     */
    private getFormControlPath;
    /**
     * @hidden
     * @internal
     */
    getFormGroup(id: any): FormGroup<any>;
    /**
     * @hidden
     * @internal
     */
    getFormControl(rowId: any, columnKey: string): _angular_forms.AbstractControl<any, any, any>;
    /**
     * @hidden
     * @internal
     */
    add(rowId: any, form: FormGroup): void;
    /**
     * Checks the validity of the native ngControl
     */
    isFieldInvalid(formGroup: FormGroup, fieldName: string): boolean;
    /**
     * Checks the validity of the native ngControl after edit
     */
    isFieldValidAfterEdit(formGroup: FormGroup, fieldName: string): boolean;
    /**
     * @hidden
     * @internal
     */
    private getValidity;
    /**
     * Returns all invalid record states.
     */
    getInvalid(): IRecordValidationState[];
    /**
     * @hidden
     * @internal
     */
    update(rowId: any, rowData: any): void;
    /**
     * @hidden
     * @internal
     * Update validity based on new data.
     */
    updateAll(newData: any): void;
    /** Marks the associated record or field as touched.
     * @param key The id of the record that will be marked as touched.
     * @param field Optional. The field from the record that will be marked as touched. If not provided all fields will be touched.
    */
    markAsTouched(key: any, field?: string): void;
    /**
     * @hidden
     * @internal
     */
    private updateStatus;
    /** Clears validation state by key or all states if none is provided.
     * @param key Optional. The key of the record for which to clear state.
    */
    clear(key?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridValidationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxGridValidationService>;
}

/**
* Default pivot keys used for data processing in the pivot pipes.
*/
declare const DEFAULT_PIVOT_KEYS: {
    aggregations: string;
    records: string;
    children: string;
    level: string;
    rowDimensionSeparator: string;
    columnDimensionSeparator: string;
};
/**
 * Event emitted when dimension collection for rows, columns of filters is changed.
 */
interface IDimensionsChange {
    /** The new list of dimensions. */
    dimensions: IPivotDimension[];
    /** The dimension list type - Row, Column or Filter. */
    dimensionCollectionType: PivotDimensionType;
}
/**
* Event emitted when values list is changed.
*/
interface IValuesChange {
    /** The new list of values. */
    values: IPivotValue[];
}
/**
 * Event emitted when pivot configuration is changed.
 */
interface IPivotConfigurationChangedEventArgs {
    /** The new configuration. */
    pivotConfiguration: IPivotConfiguration;
}
/**
* Interface describing Pivot data processing for dimensions.
* Should contain a process method and return records hierarchy based on the provided dimensions.
*/
interface IPivotDimensionStrategy {
    process(collection: any, dimensions: IPivotDimension[], values: IPivotValue[], cloneStrategy: IDataCloneStrategy, pivotKeys?: IPivotKeys): any[];
}
/**
* Interface describing a PivotAggregation function.
* Accepts an array of extracted data members and a array of the original data records.
*/
type PivotAggregation = (members: any[], data: any[]) => any;
/**
* Interface describing a IPivotAggregator class.
* Used for specifying custom aggregator lists.
*/
interface IPivotAggregator {
    /** Aggregation unique key. */
    key: string;
    /** Aggregation label to show in the UI. */
    label: string;
    /**
     * Aggregation name that will be used from a list of predefined aggregations.
     * If not set will use the specified aggregator function.
     */
    aggregatorName?: PivotAggregationType;
    /**
     * Aggregator function can be a custom implementation of `PivotAggregation`, or
     * use predefined ones from `IgxPivotAggregate` and its variants.
     */
    aggregator?: (members: any[], data?: any[]) => any;
}
/**
* Configuration of the pivot grid.
*/
interface IPivotConfiguration {
    /** A strategy to transform the rows. */
    rowStrategy?: IPivotDimensionStrategy | null;
    /** A strategy to transform the columns. */
    columnStrategy?: IPivotDimensionStrategy | null;
    /** A list of the rows. */
    rows: IPivotDimension[] | null;
    /** A list of the columns. */
    columns: IPivotDimension[] | null;
    /** A list of the values. */
    values: IPivotValue[] | null;
    /** Dimensions to be displayed in the filter area. */
    filters?: IPivotDimension[] | null;
    /** Pivot data keys used for data generation. Can be used for custom remote scenarios where the data is pre-populated. */
    pivotKeys?: IPivotKeys;
}
/**
* Configuration of a pivot dimension.
*/
interface IPivotDimension {
    /** Allows defining a hierarchy when multiple sub groups need to be extracted from single member. */
    childLevel?: IPivotDimension;
    /** Unique member to extract related data field value or the result of the memberFunction. */
    memberName: string;
    /** Function that extracts the value */
    memberFunction?: (data: any) => any;
    /** Display name to show instead of the field name of this value. **/
    displayName?: string;
    /** Enables/Disables a particular dimension from pivot structure. */
    enabled: boolean;
    /**
     * A predefined or defined via the `igxPivotSelector` filter expression tree for the current dimension to be applied in the filter pipe.
     * */
    filter?: IFilteringExpressionsTree | null;
    /** Enable/disable sorting for a particular dimension. True by default. */
    sortable?: boolean;
    /**
     * The sorting direction of the current dimension. Determines the order in which the values will appear in the related dimension.
     */
    sortDirection?: SortingDirection;
    /**
     * The dataType of the related data field.
     */
    dataType?: GridColumnDataType;
    /** The width of the dimension cells to be rendered.Can be pixel, % or "auto". */
    width?: string;
    /** Level of the dimension. */
    level?: number;
    /** @hidden @internal */
    autoWidth?: number;
    horizontalSummary?: boolean;
}
/**
* Configuration of a pivot value aggregation.
*/
interface IPivotValue {
    /** Unique member to extract related data field value for aggregations. */
    member: string;
    /** Display name to show instead of member for the column header of this value. **/
    displayName?: string;
    /**
     * Active aggregator definition with key, label and aggregator.
     */
    aggregate: IPivotAggregator;
    /**
     * List of aggregates to show in aggregate drop-down.
     */
    aggregateList?: IPivotAggregator[];
    /** Enables/Disables a particular value from pivot aggregation. */
    enabled: boolean;
    /**  Allow conditionally styling of the IgxPivotGrid cells. */
    styles?: any;
    /** Enables a data type specific template of the cells */
    dataType?: GridColumnDataType;
    /** Applies display format to cell values. */
    formatter?: (value: any, rowData?: IPivotGridRecord, columnData?: IPivotGridColumn) => any;
}
/** Interface describing the Pivot column data.
*  Contains information on the related column dimensions and their values.
*/
interface IPivotGridColumn {
    field: string;
    /** Gets/Sets the group value associated with the related column dimension by its memberName. **/
    dimensionValues: Map<string, string>;
    /** List of dimensions associated with the column.**/
    dimensions: IPivotDimension[];
    value: IPivotValue;
}
/** Interface describing the Pivot data keys used for data generation.
*  Can be used for custom remote scenarios where the data is pre-populated.
*/
interface IPivotKeys {
    /** Field that stores children for hierarchy building. */
    children: string;
    /** Field that stores reference to the original data records. */
    records: string;
    /** Field that stores aggregation values. */
    aggregations: string;
    /** Field that stores dimension level based on its hierarchy. */
    level: string;
    /** Separator used when generating the unique column field values. */
    columnDimensionSeparator: string;
    /** Separator used when generating the unique row field values. */
    rowDimensionSeparator: string;
}
/** The dimension types - Row, Column or Filter. */
declare enum PivotDimensionType {
    Row = 0,
    Column = 1,
    Filter = 2
}
declare enum PivotRowLayoutType {
    Vertical = "vertical",
    Horizontal = "horizontal"
}
declare enum PivotSummaryPosition {
    Top = "top",
    Bottom = "bottom"
}
interface IPivotUISettings {
    showConfiguration?: boolean;
    showRowHeaders?: boolean;
    rowLayout?: PivotRowLayoutType;
    horizontalSummariesPosition?: PivotSummaryPosition;
}
type PivotAggregationType = 'SUM' | 'AVG' | 'MIN' | 'MAX' | 'COUNT' | 'LATEST' | 'EARLIEST';
/** Interface describing the pivot dimension data.
* Contains additional information needed to render dimension headers.
*/
interface IPivotDimensionData {
    /** Associated column definition. */
    column: ColumnType;
    /** Associated dimension definition. */
    dimension: IPivotDimension;
    /** List of previous dimension groups. */
    prevDimensions: IPivotDimension[];
    /** Whether this a child dimension. */
    isChild?: boolean;
}
interface PivotRowHeaderGroupType {
    rowIndex: number;
    parent: any;
    header: any;
    headerID: string;
    grid: any;
}
interface DimensionValueType {
    value: string;
    children: Map<string, string | DimensionValueType>;
}
interface IPivotGridRecord {
    /** Gets/Sets the group value associated with the related row dimension by its memberName. **/
    dimensionValues: Map<string, string>;
    /** Gets/Sets the aggregation value associated with the value path. Value path depends on configured column dimension hierarchy and values.**/
    aggregationValues: Map<string, any>;
    /** List of children records in case any row dimension member contain a hierarchy. Each dimension member contains its own hierarchy, which you can get by its memberName. **/
    children?: Map<string, IPivotGridRecord[]>;
    /** List of original data records associated with the current pivoted data. **/
    records?: any[];
    /** Record level**/
    level?: number;
    /** List of dimensions associated with the record.**/
    dimensions: IPivotDimension[];
    /** If set, it specifies the name of the dimension, that has total record enabled. */
    totalRecordDimensionName?: string;
    /** The index of the record in the total view */
    dataIndex?: number;
}
interface IPivotGridGroupRecord extends IPivotGridRecord {
    height?: number;
    rowSpan?: number;
}
interface IPivotGridHorizontalGroup {
    value?: string;
    rootDimension?: IPivotDimension;
    dimensions?: IPivotDimension[];
    records?: IPivotGridRecord[];
    rowStart?: number;
    rowSpan?: number;
    colStart?: number;
    colSpan?: number;
}
interface IgxPivotGridValueTemplateContext {
    $implicit: IPivotValue;
}

declare const IGX_GRID_BASE: InjectionToken<GridType>;
declare const IGX_GRID_SERVICE_BASE: InjectionToken<GridServiceType>;
interface IGridDataBindable extends GridTypeBase {
    data: any[] | null;
    get filteredData(): any[] | null;
}
/**
 * Interface representing a cell in the grid. It is essentially the blueprint to a cell object.
 * Contains definitions of properties and methods, relevant to a cell
 */
interface CellType {
    /** The current value of the cell. */
    value: any;
    /** The value to display when the cell is in edit mode. */
    editValue: any;
    /** Indicates whether the cell is currently selected. It is false, if the sell is not selected, and true, if it is. */
    selected: boolean;
    /** Indicates whether the cell is currently active (focused). */
    active: boolean;
    /** Indicates whether the cell can be edited. */
    editable: boolean;
    /** Indicates whether the cell is currently in edit mode. */
    editMode: boolean;
    /** Represents the native HTML element of the cell itself */
    nativeElement?: HTMLElement;
    /** Represents the column that the cell belongs to. */
    column: ColumnType;
    /** Represents the row that the cell belongs to */
    row: RowType;
    /** Represents the grid instance containing the cell */
    grid: GridType;
    /** Optional; An object identifying the cell. It contains rowID, columnID, and rowIndex of the cell. */
    id?: {
        rowID: any;
        columnID: number;
        rowIndex: number;
    };
    /** Optional; The `cellID` is the unique key, used to identify the cell */
    cellID?: any;
    /**
     * Optional; An object representing the validation state of the cell.
     * Whether it's valid or invalid, and if it has errors
     */
    readonly validation?: IGridValidationState;
    readonly?: boolean;
    /** An optional title to display for the cell */
    title?: any;
    /** The CSS width of the cell as a string. */
    width: string;
    /** The index of the column that the cell belongs to. It counts only the visible (not hidden) columns */
    visibleColumnIndex?: number;
    /** A method definition to update the value of the cell. */
    update: (value: any) => void;
    /** A method definition to start or end the edit mode of the cell. It takes a boolean value as an argument*/
    setEditMode?(value: boolean): void;
    /**
     * Optional;
     * A method definition to calculate the size of the cell to fit the content
     * The method can be used to calculate the size of the cell with the longest content and resize all cells to that size
     */
    calculateSizeToFit?(range: any): number;
    /**
     * Optional
     * A method to activate the cell.
     * It takes a focus or keyboard event as an argument
     */
    activate?(event: FocusEvent | KeyboardEvent): void;
    /**
     * Optional
     * A method to handle double-click events on the cell
     * It takes a mouse event as an argument
     */
    onDoubleClick?(event: MouseEvent): void;
    /**
     * Optional
     * A method to handle click events on the cell
     * It takes a mouse event as an argument
     */
    onClick?(event: MouseEvent): void;
}
/**
 * Interface representing a header cell in the grid. It is essentially the blueprint to a header cell object.
 * Contains definitions of properties, relevant to the header
 */
interface HeaderType {
    /** Represents the native HTML element of the cell itself */
    nativeElement: HTMLElement;
    /** The column that the header cell represents. */
    column: ColumnType;
    /** Indicates whether the column is currently sorted. */
    sorted: boolean;
    /** Indicates whether the cell can be selected */
    selectable: boolean;
    /** Indicates whether the cell is currently selected */
    selected: boolean;
    /** Indicates whether the column header is a title cell. */
    title: boolean;
    /** Represents the sorting direction of the column (ascending, descending or none). */
    sortDirection: SortingDirection;
}
/**
 * Interface representing a row in the grid. It is essentially the blueprint to a row object.
 * Contains definitions of properties and methods, relevant to a row
 */
interface RowType {
    /** Represents the native HTML element of the row itself */
    nativeElement?: HTMLElement;
    /** The index of the row within the grid */
    index: number;
    viewIndex: number;
    /** Indicates whether the row is grouped. */
    isGroupByRow?: boolean;
    isSummaryRow?: boolean;
    /**
     * Optional
     * A map of column field names to the summary results for the row.
     */
    summaries?: Map<string, IgxSummaryResult[]>;
    groupRow?: IGroupByRecord;
    key?: any;
    readonly validation?: IGridValidationState;
    data?: any;
    /**
     * Optional
     * A list or an array of cells, that belong to the row
     */
    cells?: QueryList<CellType> | CellType[];
    /**
     * Optional
     * Indicates whether the current row is disabled
     */
    disabled?: boolean;
    /**
     * Optional
     * Virtualization state of data record added from cache
     */
    virtDirRow?: IgxGridForOfDirective<ColumnType, ColumnType[]>;
    /**
     * Optional
     * Indicates whether the current row is pinned.
     */
    pinned?: boolean;
    /**
     * Optional
     * Indicates whether the current row is selected
     */
    selected?: boolean;
    /**
     * Optional
     * Indicates whether the current row is expanded.
     * The value is true, if the row is expanded and false, if it is collapsed
     */
    expanded?: boolean;
    /**
     * Optional
     * Indicates whether the row is marked for deletion.
     */
    deleted?: boolean;
    /**
    * Optional
    * Indicates whether the row is currently being edited.
    */
    inEditMode?: boolean;
    /**
     * Optional
     * Contains the child rows of the current row, if there are any.
     */
    children?: RowType[];
    /**
     * Optional
     * Contains the parent row of the current row, if it has one.
     * If the parent row exist, it means that the current row is a child row
     */
    parent?: RowType;
    /**
     * Optional
     * Indicates whether the current row has any child rows
     */
    hasChildren?: boolean;
    /**
     * Optional
     * Represents the hierarchical record associated with the row (for tree grids).
     * It is of type ITreeGridRecord, which contains the data, children, the hierarchical level, etc.
     */
    treeRow?: ITreeGridRecord;
    addRowUI?: boolean;
    /**
     * Optional
     * Indicates whether the row is currently focused.
     */
    focused?: boolean;
    /** Represent the grid instance, the row belongs to */
    grid: GridType;
    onRowSelectorClick?: (event: MouseEvent) => void;
    /**
     * Optional
     * A method to handle click event on the row
     * It takes a `MouseEvent` as an argument
     */
    onClick?: (event: MouseEvent) => void;
    /**
     * Optional
     * A method to handle adding a new row
     */
    beginAddRow?: () => void;
    /**
     * Optional
     * A method to handle changing the value of elements of the row
     * It takes the new value as an argument
     */
    update?: (value: any) => void;
    /**
     * Optional
     * A method to handle deleting rows
     */
    delete?: () => any;
    /**
     * Optional
     * A method to handle pinning a row
     */
    pin?: () => void;
    /**
     * Optional
     * A method to handle unpinning a row, that has been pinned
     */
    unpin?: () => void;
}
/**
 * Interface representing the event arguments when a form group is created in the grid.
 * - formGroup: The form group that is created.
 * - owner: The grid instance that owns the form group.
 */
interface IGridFormGroupCreatedEventArgs {
    formGroup: FormGroup;
    owner: GridType;
}
/**
 * Interface representing the event arguments for the grid validation status change event.
 * - status: The validation status ('VALID' or 'INVALID').
 * - owner: The grid instance that owns the validation state.
 */
interface IGridValidationStatusEventArgs {
    status: ValidationStatus;
    owner: GridType;
}
/**
 * Type representing the validation status.
 * - 'VALID': The validation status is valid.
 * - 'INVALID': The validation status is invalid.
 */
type ValidationStatus = 'VALID' | 'INVALID';
/**
 * Interface representing the validation state of a grid.
 * - status: The validation status ('VALID' or 'INVALID').
 * - errors: The validation errors if any.
 */
interface IGridValidationState {
    readonly status: ValidationStatus;
    readonly errors?: ValidationErrors;
}
/**
 * Interface representing the validation state of a record in the grid.
 * - `key`: The unique identifier of the record.
 * - `fields`: An array of the validation state of individual fields in the record.
 */
interface IRecordValidationState extends IGridValidationState {
    key: any;
    fields: IFieldValidationState[];
}
/**
 * Interface representing the validation state of a field in the grid.
 * -`field`: The name of the field (property) being validated.
 */
interface IFieldValidationState extends IGridValidationState {
    field: string;
}
/**
 * Represents the service interface for interacting with the grid.
 */
interface GridServiceType {
    /** The reference to the parent `GridType` that contains the service. */
    grid: GridType;
    /** Represents the type of the CRUD service (Create, Read, Update, Delete) operations on the grid data. */
    crudService: any;
    /** A service responsible for handling column moving within the grid. It contains a reference to the column, its icon, and indicator for cancelation. */
    cms: IgxColumnMovingService;
    /** Represents a method declaration for retrieving the data used in the grid. The returned values could be of any type */
    get_data(): any[];
    /**
     * Represents a method declaration for retrieving all the data available in the grid, including any transactional data.
     * `includeTransactions`: Optional parameter. Specifies whether to include transactional data if present.
     * Returns an array containing all the data available in the grid.
     */
    get_all_data(includeTransactions?: boolean): any[];
    /** Represents a method declaration for retrieving a column object by its name, taken as a parameter. */
    get_column_by_name(name: string): ColumnType;
    /** Represents a method declaration for retrieving the data associated with a specific row by its unique identifier (of any type, taken as a parameter). */
    getRowData(id: any): any;
    /** Represents a method declaration for retrieving the data associated with a specific record by its unique identifier (of any type, taken as a parameter). */
    get_rec_by_id(id: any): any;
    /** Represents a method declaration for retrieving the unique identifier of a specific row by its data. */
    get_row_id(rowData: any): any;
    /** Represents a method declaration for retrieving the row object associated with a specific index (taken as a parameter) in the grid */
    get_row_by_index(rowSelector: any): RowType;
    /** Represents a method declaration for retrieving the row object associated with a specific key (taken as a parameter) in the grid */
    get_row_by_key(rowSelector: any): RowType;
    /** Represents a method declaration for retrieving the index of a record in the grid's data collection using its unique identifier. */
    get_rec_index_by_id(pk: string | number, dataCollection?: any[]): number;
    /** Represents a method declaration for retrieving the index of a record in the grid's data collection using its index. */
    get_rec_id_by_index(index: number, dataCollection?: any[]): any;
    get_row_index_in_data(rowID: any, dataCollection?: any[]): number;
    /** Represents a method declaration for retrieving the cell object associated with a specific row and column in the grid. */
    get_cell_by_key(rowSelector: any, field: string): CellType;
    /** Represents a method declaration for retrieving the cell object associated with a specific row and column using their indexes. */
    get_cell_by_index(rowIndex: number, columnID: number | string): CellType;
    /**
     * Represents a method declaration for retrieving the cell object associated with a specific row and column using their indexes.
     * It counts only the indexes of the visible columns and rows
     */
    get_cell_by_visible_index(rowIndex: number, columnIndex: number): any;
    /** Represents a method declaration that sets the expansion state of a group row (used for tree grids)
     * It takes the value for the expansion as a parameter (expanded or collapsed)
     */
    set_grouprow_expansion_state?(groupRow: IGroupByRecord, value: boolean): void;
    row_deleted_transaction(id: any): boolean;
    /**
     * Represents a method declaration for adding a new row to the grid.
     * It takes the row's data and the identifier of the parent row if applicable (used for tree grids)
     */
    addRowToData(rowData: any, parentID?: any): void;
    /** Represents a method declaration for deleting a row, specified by it's identifier (taken as a parameter) */
    deleteRowById(id: any): any;
    /** Represents a method declaration for retrieving the row's current state of expansion (used for tree grids)*/
    get_row_expansion_state(id: any): boolean;
    /** Represents a method declaration for setting a new expansion state. It can be triggered by an event */
    set_row_expansion_state(id: any, expanded: boolean, event?: Event): void;
    get_summary_data(): any[] | null;
    prepare_sorting_expression(stateCollections: Array<Array<any>>, expression: ISortingExpression): void;
    /**
     * Represents a method declaration for sorting by only one expression
     * The expression contains fieldName, sorting directory, whether case should be ignored and optional sorting strategy
     */
    sort(expression: ISortingExpression): void;
    /**
     * Represents a method declaration for sorting by multiple expressions
     * The expressions contains fieldName, sorting directory, whether case should be ignored and optional sorting strategy
     */
    sort_multiple(expressions: ISortingExpression[]): void;
    /** Represents a method declaration for resetting the sorting */
    clear_sort(fieldName: string): void;
    /** Represents an event, triggered when the pin state is changed */
    get_pin_row_event_args(rowID: any, index?: number, row?: RowType, pinned?: boolean): IPinRowEventArgs;
    filterDataByExpressions(expressionsTree: IFilteringExpressionsTree): any[];
    sortDataByExpressions(data: any[], expressions: ISortingExpression[]): any[];
    update_cell(cell: IgxCell): IGridEditEventArgs;
    update_row(row: IgxEditRow, value: any, event?: Event): IGridEditEventArgs;
    expand_path_to_record?(record: ITreeGridRecord): void;
    get_selected_children?(record: ITreeGridRecord, selectedRowIDs: any[]): void;
    get_groupBy_record_id?(gRow: IGroupByRecord): string;
    remove_grouping_expression?(fieldName: string): void;
    clear_groupby?(field: string | any): void;
    getParentRowId?(child: GridType): any;
    getChildGrids?(inDepth?: boolean): GridType[];
    getChildGrid?(path: IPathSegment[]): GridType | undefined;
    unsetChildRowIsland?(rowIsland: GridType): void;
    registerChildRowIsland?(rowIsland: GridType): void;
}
/**
 * Interface representing a grid type. It is essentially the blueprint to a grid object.
 * Contains definitions of properties and methods, relevant to a grid
 * Extends `IGridDataBindable`
 */
interface GridType extends IGridDataBindable {
    /** Represents the locale of the grid: `USD`, `EUR`, `GBP`, `CNY`, `JPY`, etc. */
    locale: string;
    cellMergeMode: GridCellMergeMode;
    mergeStrategy: IGridMergeStrategy;
    resourceStrings: IGridResourceStrings;
    /** Represents the native HTML element itself */
    nativeElement: HTMLElement;
    /** Indicates whether rows in the grid are editable. If te value is true, the rows can be edited */
    rowEditable: boolean;
    rootSummariesEnabled: boolean;
    /** Indicates whether filtering in the grid is enabled. If te value is true, the grid can be filtered */
    allowFiltering: boolean;
    /** Indicates whether rows in the grid can be dragged. If te value is true, the rows can be dragged */
    rowDraggable: boolean;
    /** Represents the unique primary key used for identifying rows in the grid */
    primaryKey: string;
    /** Represents the unique identifier of the grid. */
    id: string;
    /** The height of the visible rows in the grid. */
    renderedRowHeight: number;
    pipeTrigger: number;
    summaryPipeTrigger: number;
    /** @hidden @internal */
    columnsToMerge: ColumnType[];
    /** @hidden @internal */
    groupablePipeTrigger: number;
    filteringPipeTrigger: number;
    /** @hidden @internal */
    hasColumnLayouts: boolean;
    /** Indicates whether the grid is currently in a moving state. */
    moving: boolean;
    isLoading: boolean;
    /** @hidden @internal */
    gridSize: _Size;
    /** @hidden @internal */
    isColumnWidthSum: boolean;
    /** @hidden @internal */
    minColumnWidth: number;
    /** @hidden @internal */
    hoverIndex?: number;
    /** Strategy, used for cloning the provided data. The type has one method, that takes any type of data */
    dataCloneStrategy: IDataCloneStrategy;
    /** Represents the grid service type providing API methods for the grid */
    readonly gridAPI: GridServiceType;
    /** The filter mode for the grid. It can be quick filter of excel-style filter */
    filterMode: FilterMode;
    /** @hidden @internal */
    theadRow: any;
    /** @hidden @internal */
    groupArea: any;
    /** @hidden @internal */
    filterCellList: any[];
    /** @hidden @internal */
    filteringRow: any;
    /** @hidden @internal */
    actionStrip: any;
    /** @hidden @internal */
    resizeLine: any;
    /** @hidden @internal */
    tfoot: ElementRef<HTMLElement>;
    /** @hidden @internal */
    paginator?: IgxPaginatorComponent;
    /** @hidden @internal */
    paginatorList?: QueryList<IgxPaginatorComponent>;
    /** @hidden @internal */
    crudService: any;
    /** @hidden @internal */
    summaryService: any;
    /** Represents the state of virtualization for the grid. It has an owner, start index and chunk size */
    virtualizationState: IForOfState;
    /** @hidden @internal */
    /** The service handling selection in the grid. Selecting, deselecting elements */
    selectionService: any;
    navigation: any;
    /** @hidden @internal */
    filteringService: any;
    outlet: any;
    /** Indicates whether the grid has columns that can be moved */
    /** @hidden @internal */
    hasMovableColumns: boolean;
    /** Indicates whether the grid's rows can be selected */
    isRowSelectable: boolean;
    /** Indicates whether the selectors of the rows are visible */
    showRowSelectors: boolean;
    /** Indicates if the column of the grid is in drag mode */
    columnInDrag: any;
    /** @hidden @internal */
    /** The width of pinned element for pinning at start. */
    pinnedStartWidth: number;
    /** The width of pinned element for pinning at end. */
    pinnedEndWidth: number;
    /** @hidden @internal */
    /** The width of unpinned element */
    unpinnedWidth: number;
    /** The CSS margin of the summaries */
    summariesMargin: number;
    headSelectorBaseAriaLabel: string;
    /** Indicates whether the grid has columns that are shown */
    hasVisibleColumns: boolean;
    /**
     * Optional
     * Indicates whether the grid has expandable children (hierarchical and tree grid)
     */
    hasExpandableChildren?: boolean;
    /**
     * Optional
     * Indicates whether collapsed grid elements should be expanded
     */
    showExpandAll?: boolean;
    /** Represents the count of only the hidden (not visible) columns */
    hiddenColumnsCount: number;
    /** Represents the count of only the pinned columns */
    pinnedColumnsCount: number;
    /**
     * Optional
     * The template for grid icons.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    iconTemplate?: TemplateRef<any>;
    /**
     * Optional
     * The template for group-by rows.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    groupRowTemplate?: TemplateRef<IgxGroupByRowTemplateContext>;
    /**
     * Optional
     * The template for the group row selector.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    groupByRowSelectorTemplate?: TemplateRef<IgxGroupByRowSelectorTemplateContext>;
    /**
     * Optional
     * The template for row loading indicators.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    rowLoadingIndicatorTemplate?: TemplateRef<any>;
    /**
     * The template for the header selector.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    headSelectorTemplate: TemplateRef<IgxHeadSelectorTemplateContext>;
    /**
     * The template for row selectors.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    rowSelectorTemplate: TemplateRef<IgxRowSelectorTemplateContext>;
    /**
     * The template for sort header icons.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    sortHeaderIconTemplate: TemplateRef<IgxGridHeaderTemplateContext>;
    /**
     * The template for ascending sort header icons.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    sortAscendingHeaderIconTemplate: TemplateRef<IgxGridHeaderTemplateContext>;
    /**
     * The template for descending sort header icons.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    sortDescendingHeaderIconTemplate: TemplateRef<IgxGridHeaderTemplateContext>;
    /**
     * The template for header collapsed indicators.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    headerCollapsedIndicatorTemplate: TemplateRef<IgxGridTemplateContext>;
    /**
     * The template for header expanded indicators.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    headerExpandedIndicatorTemplate: TemplateRef<IgxGridTemplateContext>;
    /** The template for drag indicator icons. Could be of any type */
    dragIndicatorIconTemplate: any;
    /** The base drag indicator icon. Could be of any type */
    dragIndicatorIconBase: any;
    /** Indicates whether transitions are disabled for the grid. */
    disableTransitions: boolean;
    /** Indicates whether the currency symbol is positioned to the left of values. */
    currencyPositionLeft: boolean;
    /** Indicates whether the width of the column is set by the user, or is configured automatically. */
    columnWidthSetByUser: boolean;
    headerFeaturesWidth: number;
    /** CSS styling calculated for an element: calcHeight, calcWidth, outerWidth */
    calcHeight: number;
    calcWidth: number;
    outerWidth: number;
    /** The height of each row in the grid. Setting a constant height can solve problems with not showing all elements when scrolling */
    rowHeight: number;
    multiRowLayoutRowSize: number;
    defaultRowHeight: number;
    /** The default font size, calculated for each element */
    _baseFontSize?: number;
    scrollSize: number;
    /** The trigger for grid validation. It's value can either be `change` or `blur` */
    validationTrigger: GridValidationTrigger;
    /**
     * The configuration for columns and rows pinning in the grid
     * It's of type IPinningConfig, which can have value for columns (start, end) and for rows (top, bottom)
    */
    pinning: IPinningConfig;
    expansionStates: Map<any, boolean>;
    parentVirtDir: any;
    tbody: any;
    verticalScrollContainer: any;
    dataRowList: any;
    rowList: any;
    /** An unmodifiable list, containing all the columns of the grid. */
    columnList: QueryList<ColumnType>;
    columns: ColumnType[];
    /** An array of columns, but it counts only the ones visible (not hidden) in the view */
    visibleColumns: ColumnType[];
    /** An array of columns, but it counts only the ones that are not pinned */
    unpinnedColumns: ColumnType[];
    /** An array of columns, but it counts only the ones that are pinned */
    pinnedColumns: ColumnType[];
    /** An array of columns, but it counts only the ones that are pinned to the start. */
    pinnedStartColumns: ColumnType[];
    /** An array of columns, but it counts only the ones that are pinned to the end. */
    pinnedEndColumns: ColumnType[];
    /** represents an array of the headers of the columns */
    /** @hidden @internal */
    headerCellList: any[];
    /** @hidden @internal */
    headerGroups: any[];
    /** @hidden @internal */
    headerGroupsList: any[];
    summariesRowList: any;
    /** @hidden @internal */
    headerContainer: any;
    /** Indicates whether cells are selectable in the grid */
    isCellSelectable: boolean;
    /** Indicates whether it is allowed to select more than one row in the grid */
    isMultiRowSelectionEnabled: boolean;
    hasPinnedRecords: boolean;
    pinnedRecordsCount: number;
    pinnedRecords: any[];
    unpinnedRecords: any[];
    /** @hidden @internal */
    pinnedDataView: any[];
    pinnedRows: any[];
    dataView: any[];
    _filteredUnpinnedData: any[];
    _filteredSortedUnpinnedData: any[];
    filteredSortedData: any[] | null;
    dataWithAddedInTransactionRows: any[];
    /** Represents the transaction service for the grid. */
    readonly transactions: TransactionService<Transaction, State>;
    /** Represents the validation service for the grid. The type contains properties and methods (logic) for validating records */
    readonly validation: IgxGridValidationService;
    defaultSummaryHeight: number;
    summaryRowHeight: number;
    rowEditingOverlay: IgxToggleDirective;
    totalRowsCountAfterFilter: number;
    _totalRecords: number;
    /**
     * Represents the paging of the grid. It can be either 'Local' or 'Remote'
     * - Local: Default value; The grid will paginate the data source based on the page
     */
    pagingMode: GridPagingMode;
    /** The paging state for the grid; Used to configure how paging should be applied - which is the current page, records per page */
    /** @hidden */
    pagingState: any;
    rowEditTabs: any;
    /** Represents the last search in the grid
     * It contains the search text (the user has entered), the match and some settings for the search
     */
    readonly lastSearchInfo: ISearchInfo;
    /** @hidden @internal */
    page: number;
    /** @hidden @internal */
    perPage: number;
    /** The ID of the row currently being dragged in the grid. */
    /** @hidden @internal */
    dragRowID: any;
    /** Indicates whether a row is currently being dragged */
    rowDragging: boolean;
    firstEditableColumnIndex: number;
    lastEditableColumnIndex: number;
    isRowPinningToTop: boolean;
    hasDetails: boolean;
    /** @hidden @internal */
    hasSummarizedColumns: boolean;
    /** @hidden @internal */
    hasColumnGroups: boolean;
    /** @hidden @internal */
    hasEditableColumns: boolean;
    /** Property, that provides a callback for loading unique column values on demand.
     * If this property is provided, the unique values it generates will be used by the Excel Style Filtering  */
    uniqueColumnValuesStrategy: (column: ColumnType, tree: FilteringExpressionsTree, done: (values: any[]) => void) => void;
    /** Property, that gets the header cell inner width for auto-sizing. */
    getHeaderCellWidth: (element: HTMLElement) => ISizeInfo;
    /**
     * Provides change detection functionality.
     * A change-detection tree collects all views that are to be checked for changes.
     * The property cannot be changed (readonly) */
    readonly cdr: ChangeDetectorRef;
    /** @hidden @internal */
    document: Document;
    /**
    * The template for expanded row indicators.
    * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
    */
    rowExpandedIndicatorTemplate: TemplateRef<IgxGridRowTemplateContext>;
    /**
     * The template for collapsed row indicators.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    rowCollapsedIndicatorTemplate: TemplateRef<IgxGridRowTemplateContext>;
    /**
     * The template for header icon
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    excelStyleHeaderIconTemplate: TemplateRef<IgxGridHeaderTemplateContext>;
    selectRowOnClick: boolean;
    /** Represents the selection mode for cells: 'none','single', 'multiple', 'multipleCascade' */
    cellSelection: GridSelectionMode;
    /** Represents the selection mode for rows: 'none','single', 'multiple', 'multipleCascade' */
    rowSelection: GridSelectionMode;
    /** Represents the selection mode for columns: 'none','single', 'multiple', 'multipleCascade' */
    columnSelection: GridSelectionMode;
    /** Represents the calculation mode for summaries: 'rootLevelOnly', 'childLevelsOnly', 'rootAndChildLevels' */
    summaryCalculationMode: GridSummaryCalculationMode;
    /** Represents the position of summaries: 'top', 'bottom' */
    summaryPosition: GridSummaryPosition;
    lastChildGrid?: GridType;
    /** @hidden @internal */
    toolbarOutlet?: ViewContainerRef;
    /** @hidden @internal */
    paginatorOutlet?: ViewContainerRef;
    flatData?: any[] | null;
    /** @hidden @internal */
    childRow?: any;
    expansionDepth?: number;
    childDataKey?: any;
    foreignKey?: any;
    cascadeOnDelete?: boolean;
    loadChildrenOnDemand?: (parentID: any, done: (children: any[]) => void) => void;
    hasChildrenKey?: any;
    loadingRows?: Set<any>;
    parent?: GridType;
    highlightedRowID?: any;
    updateOnRender?: boolean;
    childLayoutKeys?: any[];
    childLayoutList?: QueryList<any>;
    rootGrid?: GridType;
    processedRootRecords?: ITreeGridRecord[];
    rootRecords?: ITreeGridRecord[];
    records?: Map<any, ITreeGridRecord>;
    processedExpandedFlatData?: any[] | null;
    processedRecords?: Map<any, ITreeGridRecord>;
    treeGroupArea?: any;
    activeNodeChange: EventEmitter<IActiveNodeChangeEventArgs>;
    gridKeydown: EventEmitter<IGridKeydownEventArgs>;
    cellClick: EventEmitter<IGridCellEventArgs>;
    rowClick: EventEmitter<IGridRowEventArgs>;
    doubleClick: EventEmitter<IGridCellEventArgs>;
    contextMenu: EventEmitter<IGridContextMenuEventArgs>;
    selected: EventEmitter<IGridCellEventArgs>;
    rangeSelected: EventEmitter<GridSelectionRange>;
    rowSelectionChanging: EventEmitter<IRowSelectionEventArgs>;
    localeChange: EventEmitter<boolean>;
    filtering: EventEmitter<IFilteringEventArgs>;
    filteringDone: EventEmitter<IFilteringExpressionsTree>;
    columnPinned: EventEmitter<IPinColumnEventArgs>;
    columnResized: EventEmitter<IColumnResizeEventArgs>;
    columnMovingEnd: EventEmitter<IColumnMovingEndEventArgs>;
    columnSelectionChanging: EventEmitter<IColumnSelectionEventArgs>;
    columnMoving: EventEmitter<IColumnMovingEventArgs>;
    columnMovingStart: EventEmitter<IColumnMovingStartEventArgs>;
    columnPin: EventEmitter<IPinColumnCancellableEventArgs>;
    columnVisibilityChanging: EventEmitter<IColumnVisibilityChangingEventArgs>;
    columnVisibilityChanged: EventEmitter<IColumnVisibilityChangedEventArgs>;
    batchEditingChange?: EventEmitter<boolean>;
    rowAdd: EventEmitter<IRowDataCancelableEventArgs>;
    rowAdded: EventEmitter<IRowDataEventArgs>;
    rowAddedNotifier: Subject<IRowDataEventArgs>;
    rowDelete: EventEmitter<IRowDataCancelableEventArgs>;
    rowDeleted: EventEmitter<IRowDataEventArgs>;
    rowDeletedNotifier: Subject<IRowDataEventArgs>;
    cellEditEnter: EventEmitter<IGridEditEventArgs>;
    cellEdit: EventEmitter<IGridEditEventArgs>;
    cellEditDone: EventEmitter<IGridEditDoneEventArgs>;
    cellEditExit: EventEmitter<IGridEditDoneEventArgs>;
    rowEditEnter: EventEmitter<IGridEditEventArgs>;
    rowEdit: EventEmitter<IGridEditEventArgs>;
    rowEditDone: EventEmitter<IGridEditDoneEventArgs>;
    rowEditExit: EventEmitter<IGridEditDoneEventArgs>;
    rowDragStart: EventEmitter<IRowDragStartEventArgs>;
    rowDragEnd: EventEmitter<IRowDragEndEventArgs>;
    rowToggle: EventEmitter<IRowToggleEventArgs>;
    formGroupCreated: EventEmitter<IGridFormGroupCreatedEventArgs>;
    validationStatusChange: EventEmitter<IGridValidationStatusEventArgs>;
    toolbarExporting: EventEmitter<IGridToolbarExportEventArgs>;
    rendered$: Observable<boolean>;
    resizeNotify: Subject<void>;
    sortStrategy: IGridSortingStrategy;
    groupStrategy?: IGridGroupingStrategy;
    filteringLogic: FilteringLogic;
    filterStrategy: IFilteringStrategy;
    allowAdvancedFiltering: boolean;
    sortingExpressions: ISortingExpression[];
    sortingExpressionsChange: EventEmitter<ISortingExpression[]>;
    filteringExpressionsTree: IFilteringExpressionsTree;
    filteringExpressionsTreeChange: EventEmitter<IFilteringExpressionsTree>;
    advancedFilteringExpressionsTree: IFilteringExpressionsTree;
    advancedFilteringExpressionsTreeChange: EventEmitter<IFilteringExpressionsTree>;
    sortingOptions: ISortingOptions;
    batchEditing: boolean;
    groupingExpansionState?: IGroupByExpandState[];
    groupingExpressions?: IGroupingExpression[];
    groupingExpressionsChange?: EventEmitter<IGroupingExpression[]>;
    groupsExpanded?: boolean;
    readonly groupsRecords?: IGroupByRecord[];
    groupingFlatResult?: any[];
    groupingResult?: any[];
    groupingMetadata?: any[];
    selectedCells?: CellType[];
    selectedRows: any[];
    /** @hidden @internal */
    activeDescendant?: string;
    /** @hidden @internal */
    readonly type: 'flat' | 'tree' | 'hierarchical' | 'pivot';
    toggleGroup?(groupRow: IGroupByRecord): void;
    clearGrouping?(field: string): void;
    groupBy?(expression: IGroupingExpression | Array<IGroupingExpression>): void;
    resolveOutlet?(): IgxOverlayOutletDirective;
    updateColumns(columns: ColumnType[]): void;
    getSelectedRanges(): GridSelectionRange[];
    deselectAllColumns(): void;
    deselectColumns(columns: string[] | ColumnType[]): void;
    selectColumns(columns: string[] | ColumnType[]): void;
    selectedColumns(): ColumnType[];
    refreshSearch(): void;
    getDefaultExpandState(record: any): boolean;
    trackColumnChanges(index: number, column: any): any;
    getPossibleColumnWidth(baseWidth?: number, minColumnWidth?: number): string;
    resetHorizontalVirtualization(): void;
    hasVerticalScroll(): boolean;
    getVisibleContentHeight(): number;
    getDragGhostCustomTemplate(): TemplateRef<any> | null;
    openRowOverlay(id: any): void;
    openAdvancedFilteringDialog(overlaySettings?: OverlaySettings): void;
    showSnackbarFor(index: number): void;
    getColumnByName(name: string): any;
    getColumnByVisibleIndex(index: number): ColumnType;
    getHeaderGroupWidth(column: ColumnType): string;
    getRowByKey?(key: any): RowType;
    getRowByIndex?(index: number): RowType;
    setFilteredData(data: any, pinned: boolean): void;
    setFilteredSortedData(data: any, pinned: boolean): void;
    sort(expression: ISortingExpression | ISortingExpression[]): void;
    clearSort(name?: string): void;
    pinRow(id: any, index?: number, row?: RowType): boolean;
    unpinRow(id: any, row?: RowType): boolean;
    getUnpinnedIndexById(id: any): number;
    getEmptyRecordObjectFor(inRow: RowType): any;
    isSummaryRow(rec: any): boolean;
    isRecordPinned(rec: any): boolean;
    isRecordMerged(rec: any): boolean;
    getInitialPinnedIndex(rec: any): number;
    isRecordPinnedByViewIndex(rowIndex: number): boolean;
    isColumnGrouped(fieldName: string): boolean;
    isDetailRecord(rec: any): boolean;
    isGroupByRecord(rec: any): boolean;
    isGhostRecord(rec: any): boolean;
    isTreeRow?(rec: any): boolean;
    isChildGridRecord?(rec: any): boolean;
    getChildGrids?(inDepth?: boolean): any[];
    isHierarchicalRecord?(record: any): boolean;
    columnToVisibleIndex(key: string | number): number;
    moveColumn(column: ColumnType, target: ColumnType, pos: DropPosition): void;
    navigateTo(rowIndex: number, visibleColumnIndex: number, callback?: (e: any) => any): void;
    getPreviousCell(currRowIndex: number, curVisibleColIndex: number, callback: (c: ColumnType) => boolean): ICellPosition;
    getNextCell(currRowIndex: number, curVisibleColIndex: number, callback: (c: ColumnType) => boolean): ICellPosition;
    clearCellSelection(): void;
    selectRange(range: GridSelectionRange | GridSelectionRange[]): void;
    selectRows(rowIDs: any[], clearCurrentSelection?: boolean): void;
    deselectRows(rowIDs: any[]): void;
    selectAllRows(onlyFilterData?: boolean): void;
    deselectAllRows(onlyFilterData?: boolean): void;
    setUpPaginator(): void;
    createFilterDropdown(column: ColumnType, options: OverlaySettings): any;
    updateCell(value: any, rowSelector: any, column: string): void;
    createRow?(index: number, data?: any): RowType;
    deleteRow(id: any): any;
    deleteRowById(id: any): any;
    updateRow(value: any, rowSelector: any): void;
    collapseRow(id: any): void;
    notifyChanges(repaint?: boolean): void;
    resetColumnCollections(): void;
    triggerPipes(): void;
    repositionRowEditingOverlay(row: RowType): void;
    closeRowEditingOverlay(): void;
    reflow(): void;
    isExpandedGroup(group: IGroupByRecord): boolean;
    createColumnsList?(cols: ColumnType[]): void;
    toggleAllGroupRows?(): void;
    toggleAll?(): void;
    generateRowPath?(rowId: any): any[];
    preventHeaderScroll?(args: any): void;
}
/**
 * An interface describing a Flat Grid type. It is essentially the blueprint to a grid kind
 * Contains definitions of properties and methods, relevant to a grid kind
 * Extends from `GridType`
 */
interface FlatGridType extends GridType {
    groupingExpansionState: IGroupByExpandState[];
    groupingExpressions: IGroupingExpression[];
    groupingExpressionsChange: EventEmitter<IGroupingExpression[]>;
    toggleGroup(groupRow: IGroupByRecord): void;
    clearGrouping(field: string): void;
    groupBy(expression: IGroupingExpression | Array<IGroupingExpression>): void;
}
/**
 * An interface describing a Tree Grid type. It is essentially the blueprint to a grid kind
 * Contains definitions of properties and methods, relevant to a grid kind
 * Extends from `GridType`
 */
interface TreeGridType extends GridType {
    records: Map<any, ITreeGridRecord>;
    isTreeRow(rec: any): boolean;
}
/**
 * An interface describing a Hierarchical Grid type. It is essentially the blueprint to a grid kind
 * Contains definitions of properties and methods, relevant to a grid kind
 * Extends from `GridType`
 */
interface HierarchicalGridType extends GridType {
    childLayoutKeys: any[];
}
/**
 * An interface describing a Pivot Grid type. It is essentially the blueprint to a grid kind
 * Contains definitions of properties and methods, relevant to a grid kind
 * Extends from `GridType`
 */
interface PivotGridType extends GridType {
    /**
     * The configuration settings for the pivot grid.
     * it includes dimension strategy for rows and columns, filters and data keys
     */
    pivotConfiguration: IPivotConfiguration;
    /**
     * An array of all dimensions (rows and columns) in the pivot grid.
     * it includes hierarchical level, filters and sorting, dimensional level, etc.
     */
    allDimensions: IPivotDimension[];
    /** Specifies whether to show the pivot configuration UI in the grid. */
    pivotUI: IPivotUISettings;
    /** @hidden @internal */
    columnDimensions: IPivotDimension[];
    /** @hidden @internal */
    rowDimensions: IPivotDimension[];
    rowDimensionResizing: boolean;
    /** @hidden @internal */
    visibleRowDimensions: IPivotDimension[];
    /** @hidden @internal */
    hasHorizontalLayout: boolean;
    /** @hidden @internal */
    values: IPivotValue[];
    /** @hidden @internal */
    filterDimensions: IPivotDimension[];
    /** @hidden @internal */
    dimensionDataColumns: ColumnType[];
    pivotRowWidths: number;
    getRowDimensionByName(name: string): IPivotDimension;
    /** Represents a method declaration for setting up the columns for the pivot grid based on the pivot configuration */
    setupColumns(): void;
    /** Represents a method declaration that allows toggle of expansion state of a row (taken as a parameter) in the pivot grid */
    toggleRow(rowID: any): void;
    /**
     * Represents a method declaration for resolving the data type for a specific field (column).
     * It takes the field as a parameter and returns it's type
     */
    resolveDataTypes(field: any): GridColumnDataType;
    /**
     * Represents a method declaration for moving dimension from its currently collection to the specified target collection
     * by type (Row, Column or Filter) at specified index or at the collection's end
     */
    moveDimension(dimension: IPivotDimension, targetCollectionType: PivotDimensionType, index?: number): any;
    getDimensionsByType(dimension: PivotDimensionType): any;
    /** Toggles the dimension's enabled state on or off. The dimension remains in its current collection */
    toggleDimension(dimension: IPivotDimension): any;
    /** Sort the dimension and its children in the provided direction (ascending, descending or none). */
    sortDimension(dimension: IPivotDimension, sortDirection: SortingDirection): any;
    /** Toggles the value's enabled state on or off. The value remains in its current collection. */
    toggleValue(value: IPivotValue): any;
    /** Move value from its currently at specified index or at the end.
     * If the parameter is not set, it will add it to the end of the collection. */
    moveValue(value: IPivotValue, index?: number): any;
    rowDimensionWidth(dim: IPivotDimension): string;
    rowDimensionWidthToPixels(dim: IPivotDimension): number;
    /** Emits an event when the dimensions in the pivot grid change. */
    dimensionsChange: EventEmitter<IDimensionsChange>;
    /** Emits an event when the values in the pivot grid change. */
    valuesChange: EventEmitter<IValuesChange>;
    /** Emits an event when the a dimension is sorted. */
    dimensionsSortingExpressionsChange: EventEmitter<ISortingExpression[]>;
    /** @hidden @internal */
    pivotKeys: IPivotKeys;
    hasMultipleValues: boolean;
    excelStyleFilterMaxHeight: string;
    excelStyleFilterMinHeight: string;
    valueChipTemplate: TemplateRef<any>;
    rowDimensionHeaderTemplate: TemplateRef<IgxColumnTemplateContext>;
}
interface GridSVGIcon {
    name: string;
    value: string;
}
interface ISizeInfo {
    width: number;
    padding: number;
}
interface IgxGridMasterDetailContext {
    $implicit: any;
    index: number;
}
interface IgxGroupByRowTemplateContext {
    $implicit: IGroupByRecord;
}
interface IgxGridTemplateContext {
    $implicit: GridType;
}
interface IgxGridRowTemplateContext {
    $implicit: RowType;
}
interface IgxGridRowDragGhostContext {
    $implicit: any;
    data: any;
    grid: GridType;
}
interface IgxGridEmptyTemplateContext {
    $implicit: undefined;
}
interface IgxGridRowEditTemplateContext {
    $implicit: undefined;
    rowChangesCount: number;
    endEdit: (commit: boolean, event?: Event) => void;
}
interface IgxGridRowEditTextTemplateContext {
    $implicit: number;
}
interface IgxGridRowEditActionsTemplateContext {
    $implicit: (commit: boolean, event?: Event) => void;
}
interface IgxGridHeaderTemplateContext {
    $implicit: HeaderType;
}
interface IgxColumnTemplateContext {
    $implicit: ColumnType;
    column: ColumnType;
}
interface IgxCellTemplateContext {
    $implicit: any;
    additionalTemplateContext: any;
    formControl?: FormControl<any>;
    defaultErrorTemplate?: TemplateRef<any>;
    cell: CellType;
}
interface IgxRowSelectorTemplateDetails {
    index: number;
    /**
     * @deprecated in version 15.1.0. Use the `key` property instead.
     */
    rowID: any;
    key: any;
    selected: boolean;
    select?: () => void;
    deselect?: () => void;
}
interface IgxRowSelectorTemplateContext {
    $implicit: IgxRowSelectorTemplateDetails;
}
interface IgxGroupByRowSelectorTemplateDetails {
    selectedCount: number;
    totalCount: number;
    groupRow: IGroupByRecord;
}
interface IgxGroupByRowSelectorTemplateContext {
    $implicit: IgxGroupByRowSelectorTemplateDetails;
}
interface IgxHeadSelectorTemplateDetails {
    selectedCount: number;
    totalCount: number;
    selectAll?: () => void;
    deselectAll?: () => void;
}
interface IgxHeadSelectorTemplateContext {
    $implicit: IgxHeadSelectorTemplateDetails;
}
interface IgxSummaryTemplateContext {
    $implicit: IgxSummaryResult[];
}
interface IgxGridPaginatorTemplateContext {
    $implicit: GridType;
}
/**
 * An interface describing settings for row/column pinning position.
 */
interface IPinningConfig {
    columns?: ColumnPinningPosition;
    rows?: RowPinningPosition;
}
/**
 * An interface describing settings for clipboard options
 */
interface IClipboardOptions {
    /**
     * Enables/disables the copy behavior
     */
    enabled: boolean;
    /**
     * Include the columns headers in the clipboard output.
     */
    copyHeaders: boolean;
    /**
     * Apply the columns formatters (if any) on the data in the clipboard output.
     */
    copyFormatters: boolean;
    /**
     * The separator used for formatting the copy output. Defaults to `\t`.
     */
    separator: string;
}

declare abstract class IgxColumnActionsBaseDirective {
    /** @hidden @internal */
    abstract actionEnabledColumnsFilter: (value: ColumnType, index: number, array: ColumnType[]) => boolean;
    /**
     * @hidden @internal
     */
    abstract get checkAllLabel(): string;
    /**
     * @hidden @internal
     */
    abstract get uncheckAllLabel(): string;
    /** @hidden @internal */
    abstract columnChecked(column: ColumnType): boolean;
    /** @hidden @internal */
    abstract toggleColumn(column: ColumnType): void;
    /** @hidden @internal */
    abstract uncheckAll(): void;
    /** @hidden @internal */
    abstract checkAll(): void;
    /** @hidden @internal */
    abstract get allChecked(): boolean;
    /** @hidden @internal */
    abstract get allUnchecked(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnActionsBaseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnActionsBaseDirective, never, never, {}, {}, never, never, true, never>;
}

/**
 * Providing reference to `IgxColumnActionsComponent`:
 * ```typescript
 *  @ViewChild('columnActions', { read: IgxColumnActionsComponent })
 *  public columnActions: IgxColumnActionsComponent;
 */
declare class IgxColumnActionsComponent implements DoCheck {
    private differs;
    /**
     * Gets/Sets the grid to provide column actions for.
     *
     * @example
     * ```typescript
     * let grid = this.columnActions.grid;
     * ```
     */
    grid: GridType;
    /**
     * Gets/sets the indentation of columns in the column list based on their hierarchy level.
     *
     * @example
     * ```
     * <igx-column-actions [indentation]="15"></igx-column-actions>
     * ```
     */
    indentation: number;
    /**
     * Sets/Gets the css class selector.
     * By default the value of the `class` attribute is `"igx-column-actions"`.
     * ```typescript
     * let cssCLass =  this.columnHidingUI.cssClass;
     * ```
     * ```typescript
     * this.columnHidingUI.cssClass = 'column-chooser';
     * ```
     */
    cssClass: string;
    /**
     * Gets/sets the max height of the columns area.
     *
     * @remarks
     * The default max height is 100%.
     * @example
     * ```html
     * <igx-column-actions [columnsAreaMaxHeight]="200px"></igx-column-actions>
     * ```
     */
    columnsAreaMaxHeight: string;
    /**
     * Shows/hides the columns filtering input from the UI.
     *
     * @example
     * ```html
     *  <igx-column-actions [hideFilter]="true"></igx-column-actions>
     * ```
     */
    hideFilter: boolean;
    /**
     * Gets the checkbox components representing column items currently present in the dropdown
     *
     * @example
     * ```typescript
     * let columnItems =  this.columnActions.columnItems;
     * ```
     */
    columnItems: QueryList<IgxCheckboxComponent>;
    /**
     * Gets/sets the title of the column actions component.
     *
     * @example
     * ```html
     * <igx-column-actions [title]="'Pin Columns'"></igx-column-actions>
     * ```
     */
    title: string;
    /**
     * An event that is emitted after a column's checked state is changed.
     * Provides references to the `column` and the `checked` properties as event arguments.
     * ```html
     *  <igx-column-actions (columnToggled)="columnToggled($event)"></igx-column-actions>
     * ```
     */
    columnToggled: EventEmitter<IColumnToggledEventArgs>;
    /**
     * @hidden @internal
     */
    actionableColumns: ColumnType[];
    /**
     * @hidden @internal
     */
    filteredColumns: ColumnType[];
    /**
     * @hidden @internal
     */
    pipeTrigger: number;
    /**
     * @hidden @internal
     */
    actionsDirective: IgxColumnActionsBaseDirective;
    protected _differ: IterableDiffer<any> | null;
    /**
     * @hidden @internal
     */
    private _filterColumnsPrompt;
    /**
     * @hidden @internal
     */
    private _filterCriteria;
    /**
     * @hidden @internal
     */
    private _columnDisplayOrder;
    /**
     * @hidden @internal
     */
    private _uncheckAllText;
    /**
     * @hidden @internal
     */
    private _checkAllText;
    /**
     * @hidden @internal
     */
    private _id;
    constructor();
    /**
     * Gets the prompt that is displayed in the filter input.
     *
     * @example
     * ```typescript
     * let filterColumnsPrompt = this.columnActions.filterColumnsPrompt;
     * ```
     */
    get filterColumnsPrompt(): string;
    /**
     * Sets the prompt that is displayed in the filter input.
     *
     * @example
     * ```html
     * <igx-column-actions [filterColumnsPrompt]="'Type here to search'"></igx-column-actions>
     * ```
     */
    set filterColumnsPrompt(value: string);
    /**
     * Gets the value which filters the columns list.
     *
     * @example
     * ```typescript
     * let filterCriteria =  this.columnActions.filterCriteria;
     * ```
     */
    get filterCriteria(): string;
    /**
     * Sets the value which filters the columns list.
     *
     * @example
     * ```html
     *  <igx-column-actions [filterCriteria]="'ID'"></igx-column-actions>
     * ```
     */
    set filterCriteria(value: string);
    /**
     * Gets the display order of the columns.
     *
     * @example
     * ```typescript
     * let columnDisplayOrder = this.columnActions.columnDisplayOrder;
     * ```
     */
    get columnDisplayOrder(): ColumnDisplayOrder;
    /**
     * Sets the display order of the columns.
     *
     * @example
     * ```typescript
     * this.columnActions.columnDisplayOrder = ColumnDisplayOrder.Alphabetical;
     * ```
     */
    set columnDisplayOrder(value: ColumnDisplayOrder);
    /**
     * Gets the text of the button that unchecks all columns.
     *
     * @remarks
     * If unset it is obtained from the IgxColumnActionsBased derived directive applied.
     * @example
     * ```typescript
     * let uncheckAllText = this.columnActions.uncheckAllText;
     * ```
     */
    get uncheckAllText(): string;
    /**
     * Sets the text of the button that unchecks all columns.
     *
     * @example
     * ```html
     * <igx-column-actions [uncheckAllText]="'Show All'"></igx-column-actions>
     * ```
     */
    set uncheckAllText(value: string);
    /**
     * Gets the text of the button that checks all columns.
     *
     * @remarks
     * If unset it is obtained from the IgxColumnActionsBased derived directive applied.
     * @example
     * ```typescript
     * let uncheckAllText = this.columnActions.uncheckAllText;
     * ```
     */
    get checkAllText(): string;
    /**
     * Sets the text of the button that checks all columns.
     *
     * @remarks
     * If unset it is obtained from the IgxColumnActionsBased derived directive applied.
     * @example
     * ```html
     * <igx-column-actions [checkAllText]="'Hide All'"></igx-column-actions>
     * ```
     */
    set checkAllText(value: string);
    /**
     * @hidden @internal
     */
    get checkAllDisabled(): boolean;
    /**
     * @hidden @internal
     */
    get uncheckAllDisabled(): boolean;
    /**
     * Gets/Sets the value of the `id` attribute.
     *
     * @remarks
     * If not provided it will be automatically generated.
     * @example
     * ```html
     * <igx-column-actions [id]="'igx-actions-1'"></igx-column-actions>
     * ```
     */
    get id(): string;
    set id(value: string);
    /**
     * @hidden @internal
     */
    get titleID(): string;
    /**
     * @hidden @internal
     */
    trackChanges: (index: any, col: any) => string;
    /**
     * @hidden @internal
     */
    ngDoCheck(): void;
    /**
     * Unchecks all columns and performs the appropriate action.
     *
     * @example
     * ```typescript
     * this.columnActions.uncheckAllColumns();
     * ```
     */
    uncheckAllColumns(): void;
    /**
     * Checks all columns and performs the appropriate action.
     *
     * @example
     * ```typescript
     * this.columnActions.checkAllColumns();
     * ```
     */
    checkAllColumns(): void;
    /**
     * @hidden @internal
     */
    toggleColumn(column: ColumnType): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxColumnActionsComponent, "igx-column-actions", never, { "grid": { "alias": "grid"; "required": false; }; "indentation": { "alias": "indentation"; "required": false; }; "columnsAreaMaxHeight": { "alias": "columnsAreaMaxHeight"; "required": false; }; "hideFilter": { "alias": "hideFilter"; "required": false; }; "title": { "alias": "title"; "required": false; }; "filterColumnsPrompt": { "alias": "filterColumnsPrompt"; "required": false; }; "filterCriteria": { "alias": "filterCriteria"; "required": false; }; "columnDisplayOrder": { "alias": "columnDisplayOrder"; "required": false; }; "uncheckAllText": { "alias": "uncheckAllText"; "required": false; }; "checkAllText": { "alias": "checkAllText"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "columnToggled": "columnToggled"; }, never, never, true, never>;
    static ngAcceptInputType_hideFilter: unknown;
}

declare class IgxColumnHidingDirective extends IgxColumnActionsBaseDirective {
    protected columnActions: IgxColumnActionsComponent;
    constructor();
    /**
     * @hidden @internal
     */
    get checkAllLabel(): string;
    /**
     * @hidden @internal
     */
    get uncheckAllLabel(): string;
    /**
     * @hidden @internal
     */
    checkAll(): void;
    /**
     * @hidden @internal
     */
    uncheckAll(): void;
    /**
     * @hidden @internal
     */
    actionEnabledColumnsFilter: (c: any) => boolean;
    /**
     * @hidden @internal
     */
    columnChecked(column: ColumnType): boolean;
    /**
     * @hidden @internal
     */
    toggleColumn(column: ColumnType): void;
    get allChecked(): boolean;
    get allUnchecked(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnHidingDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnHidingDirective, "[igxColumnHiding]", never, {}, {}, never, never, true, never>;
}

declare class IgxColumnPinningDirective extends IgxColumnActionsBaseDirective {
    protected columnActions: IgxColumnActionsComponent;
    constructor();
    /**
     * @hidden @internal
     */
    get checkAllLabel(): string;
    /**
     * @hidden @internal
     */
    get uncheckAllLabel(): string;
    /**
     * @hidden @internal
     */
    checkAll(): void;
    /**
     * @hidden @internal
     */
    uncheckAll(): void;
    /**
     * @hidden @internal
     */
    actionEnabledColumnsFilter: (c: ColumnType) => boolean;
    /**
     * @hidden @internal
     */
    columnChecked(column: ColumnType): boolean;
    /**
     * @hidden @internal
     */
    toggleColumn(column: ColumnType): void;
    get allUnchecked(): boolean;
    get allChecked(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnPinningDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnPinningDirective, "[igxColumnPinning]", never, {}, {}, never, never, true, never>;
}

declare class IgxColumnRequiredValidatorDirective extends RequiredValidator {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnRequiredValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnRequiredValidatorDirective, "igx-column[required]", never, {}, {}, never, never, true, never>;
}
declare class IgxColumnMinValidatorDirective extends MinValidator {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnMinValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnMinValidatorDirective, "igx-column[min]", never, {}, {}, never, never, true, never>;
}
declare class IgxColumnMaxValidatorDirective extends MaxValidator {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnMaxValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnMaxValidatorDirective, "igx-column[max]", never, {}, {}, never, never, true, never>;
}
declare class IgxColumnEmailValidatorDirective extends EmailValidator {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnEmailValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnEmailValidatorDirective, "igx-column[email]", never, {}, {}, never, never, true, never>;
}
declare class IgxColumnMinLengthValidatorDirective extends MinLengthValidator {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnMinLengthValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnMinLengthValidatorDirective, "igx-column[minlength]", never, {}, {}, never, never, true, never>;
}
declare class IgxColumnMaxLengthValidatorDirective extends MaxLengthValidator {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnMaxLengthValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnMaxLengthValidatorDirective, "igx-column[maxlength]", never, {}, {}, never, never, true, never>;
}
declare class IgxColumnPatternValidatorDirective extends PatternValidator {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnPatternValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnPatternValidatorDirective, "igx-column[pattern]", never, {}, {}, never, never, true, never>;
}

/**
 * @hidden
 * @internal
 */
declare class IgxColumnResizingService {
    private zone;
    /**
     * @hidden
     */
    startResizePos: number;
    /**
     * Indicates that a column is currently being resized.
     */
    isColumnResizing: boolean;
    /**
     * @hidden
     */
    resizeCursor: string;
    /**
     * @hidden
     */
    showResizer: boolean;
    /**
     * The column being resized.
     */
    column: ColumnType;
    /**
     * @hidden
     */
    getColumnHeaderRenderedWidth(): number;
    /**
     * @hidden
     */
    get resizerHeight(): number;
    /**
     * Returns the minimal possible width to which the column can be resized.
     */
    get restrictResizeMin(): number;
    /**
     * Returns the maximal possible width to which the column can be resized.
     */
    get restrictResizeMax(): number;
    /**
     * Autosizes the column to the longest currently visible cell value, including the header cell.
     * If the column has a predifined maxWidth and the autosized column width will become bigger than it,
     * then the column is sized to its maxWidth.
     */
    autosizeColumnOnDblClick(): void;
    /**
     * Resizes the column regaridng to the column minWidth and maxWidth.
     */
    resizeColumn(event: MouseEvent, ratio?: number): void;
    protected _handlePixelResize(diff: number, column: ColumnType): void;
    protected _handlePercentageResize(diff: number, column: ColumnType): void;
    protected getColMinWidth(column: ColumnType): number;
    protected resizeColumnLayoutFor(column: ColumnType, diff: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnResizingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxColumnResizingService>;
}

/**
 * @hidden
 */
declare class IgxGridHeaderComponent implements DoCheck, OnDestroy {
    grid: GridType;
    colResizingService: IgxColumnResizingService;
    cdr: ChangeDetectorRef;
    private ref;
    column: ColumnType;
    /**
     * @hidden
     */
    protected defaultESFHeaderIconTemplate: TemplateRef<any>;
    /**
     * @hidden
     */
    protected defaultSortHeaderIconTemplate: any;
    /**
     * @hidden
     */
    protected sortIconContainer: ElementRef;
    get pinnedCss(): boolean;
    get pinnedLastCss(): boolean;
    get pinnedFirstCSS(): boolean;
    /**
     * Gets whether the header group is stored in the last column in the pinned area.
     */
    get isLastPinned(): boolean;
    /**
     * Gets whether the header group is stored in the first column of the right pinned area.
     */
    get isFirstPinned(): boolean;
    /**
     * Gets whether the header group is stored in a pinned column.
     *
     * @memberof IgxGridHeaderGroupComponent
     */
    get isPinned(): boolean;
    /**
     * @hidden
     */
    id: string;
    /**
     * Returns the `aria-selected` of the header.
     */
    get ariaSelected(): boolean;
    /**
     * Returns the `aria-sort` of the header.
     */
    get ariaSort(): "ascending" | "descending";
    /**
     * @hidden
     */
    get ariaColIndx(): number;
    /**
     * @hidden
     */
    get ariaRowIndx(): number;
    get columnGroupStyle(): boolean;
    get sortAscendingStyle(): boolean;
    get sortDescendingStyle(): boolean;
    get numberStyle(): boolean;
    get sortableStyle(): boolean;
    get selectableStyle(): boolean;
    get filterableStyle(): any;
    get sortedStyle(): boolean;
    get selectedStyle(): boolean;
    /**
     * @hidden
     */
    get esfIconTemplate(): TemplateRef<any>;
    /**
     * @hidden
     */
    get sortIconTemplate(): any;
    /**
     * @hidden
     */
    get disabled(): boolean;
    get sorted(): boolean;
    get filterIconClassName(): "igx-excel-filter__icon--filtered" | "igx-excel-filter__icon";
    get selectable(): boolean;
    get selected(): boolean;
    get title(): string;
    get nativeElement(): HTMLElement;
    sortDirection: SortingDirection;
    protected _destroy$: Subject<boolean>;
    onClick(event: MouseEvent): void;
    /**
     * @hidden
     */
    onPinterEnter(): void;
    /**
     * @hidden
     */
    onPointerLeave(): void;
    /**
     * @hidden @internal
     */
    ngDoCheck(): void;
    /**
     * @hidden @internal
     */
    ngOnDestroy(): void;
    /**
     * @hidden @internal
     */
    onPointerDownIndicator(event: any): void;
    /**
     * @hidden @internal
     */
    onFilteringIconClick(event: any): void;
    /**
     * @hidden @internal
     */
    onSortingIconClick(event: any): void;
    protected getSortDirection(): void;
    protected isAdvancedFilterApplied(): boolean;
    private triggerSort;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridHeaderComponent, "igx-grid-header", never, { "column": { "alias": "column"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @hidden @internal
 */
declare class FilterListItem {
    value: any;
    label: any;
    isSelected: boolean;
    indeterminate: boolean;
    isFiltered: boolean;
    isSpecial: boolean;
    isBlanks: boolean;
    children?: Array<FilterListItem>;
    parent?: FilterListItem;
}
/**
 * @hidden
 */
declare class ExpressionUI {
    expressionId: string;
    expression: IFilteringExpression;
    beforeOperator: FilteringLogic;
    afterOperator: FilteringLogic;
    isSelected: boolean;
    isVisible: boolean;
    constructor();
}
/**
 * @hidden @internal
 */
declare class ActiveElement {
    index: number;
    id: string;
    checked: boolean;
}
declare function generateExpressionsList(expressions: IFilteringExpressionsTree | IFilteringExpression, operator: FilteringLogic, expressionsUIs: ExpressionUI[]): void;

/**
 * @hidden
 */
declare class IgxFilteringService implements OnDestroy {
    private iconService;
    protected _overlayService: IgxOverlayService;
    isFilterRowVisible: boolean;
    filteredColumn: ColumnType;
    selectedExpression: IFilteringExpression;
    columnToMoreIconHidden: Map<string, boolean>;
    activeFilterCell: number;
    grid: GridType;
    private columnsWithComplexFilter;
    private areEventsSubscribed;
    protected destroy$: Subject<boolean>;
    private isFiltering;
    private columnToExpressionsMap;
    private columnStartIndex;
    protected _filterMenuOverlaySettings: OverlaySettings;
    protected lastActiveNode: any;
    ngOnDestroy(): void;
    toggleFilterDropdown(element: HTMLElement, column: ColumnType): void;
    /**
     * Subscribe to grid's events.
     */
    subscribeToEvents(): void;
    /**
     * Close filtering row if a column is hidden.
     */
    hideFilteringRowOnColumnVisibilityChange(col: ColumnType): void;
    /**
     * Internal method to create expressionsTree and filter grid used in both filter modes.
     */
    filterInternal(field: string, expressions?: FilteringExpressionsTree | Array<ExpressionUI>): void;
    /**
     * Execute filtering on the grid.
     */
    filter(field: string, value: any, conditionOrExpressionTree?: IFilteringOperation | IFilteringExpressionsTree, ignoreCase?: boolean): void;
    filter_global(term: any, condition: any, ignoreCase: any): void;
    /**
     * Clears the filter of a given column if name is provided. Otherwise clears the filters of all columns.
     */
    clearFilter(field: string): void;
    clear_filter(fieldName: string): void;
    /**
     * Filters all the `IgxColumnComponent` in the `IgxGridComponent` with the same condition.
     * @deprecated in version 19.0.0.
     */
    filterGlobal(value: any, condition: any, ignoreCase?: any): void;
    /**
     * Register filtering SVG icons in the icon service.
     */
    registerSVGIcons(): void;
    /**
     * Returns the ExpressionUI array for a given column.
     */
    getExpressions(columnId: string): ExpressionUI[];
    /**
     * Recreates all ExpressionUIs for all columns. Executed after filtering to refresh the cache.
     */
    refreshExpressions(): void;
    /**
     * Remove an ExpressionUI for a given column.
     */
    removeExpression(columnId: string, indexToRemove: number): void;
    /**
     * Generate filtering tree for a given column from existing ExpressionUIs.
     */
    createSimpleFilteringTree(columnId: string, expressionUIList?: any): FilteringExpressionsTree;
    /**
     * Returns whether a complex filter is applied to a given column.
     */
    isFilterComplex(columnId: string): boolean;
    /**
     * Returns the string representation of the FilteringLogic operator.
     */
    getOperatorAsString(operator: FilteringLogic): any;
    /**
     * Generate the label of a chip from a given filtering expression.
     */
    getChipLabel(expression: IFilteringExpression): any;
    /**
     * Updates the content of a filterCell.
     */
    updateFilteringCell(column: ColumnType): void;
    generateExpressionsList(expressions: IFilteringExpressionsTree | IFilteringExpression, operator: FilteringLogic, expressionsUIs: ExpressionUI[]): void;
    isFilteringExpressionsTreeEmpty(expressionTree: IFilteringExpressionsTree): boolean;
    protected filter_internal(fieldName: string, term: any, conditionOrExpressionsTree: IFilteringOperation | IFilteringExpressionsTree, ignoreCase: boolean): void;
    /** Modifies the filteringState object to contain the newly added filtering conditions/expressions.
     * If createNewTree is true, filteringState will not be modified (because it directly affects the grid.filteringExpressionsTree),
     * but a new object is created and returned.
     */
    protected prepare_filtering_expression(filteringState: IFilteringExpressionsTree, fieldName: string, searchVal: any, conditionOrExpressionsTree: IFilteringOperation | IFilteringExpressionsTree, ignoreCase: boolean, insertAtIndex?: number, createNewTree?: boolean): FilteringExpressionsTree;
    private isFilteringTreeComplex;
    private getChildAndOperatorsCount;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFilteringService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxFilteringService>;
}

/**
 * @hidden
 */
declare class IgxGridFilteringCellComponent implements AfterViewInit, OnInit, DoCheck {
    cdr: ChangeDetectorRef;
    filteringService: IgxFilteringService;
    column: ColumnType;
    protected emptyFilter: TemplateRef<any>;
    protected defaultFilter: TemplateRef<any>;
    protected complexFilter: TemplateRef<any>;
    protected chipsArea: IgxChipsAreaComponent;
    protected moreIcon: ElementRef;
    protected ghostChip: IgxChipComponent;
    protected complexChip: IgxChipComponent;
    get styleClasses(): string;
    expressionsList: ExpressionUI[];
    moreFiltersCount: number;
    get pinnedCss(): boolean;
    get pinnedLastCss(): boolean;
    get pinnedFirstCSS(): boolean;
    private baseClass;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngDoCheck(): void;
    /**
     * Returns whether a chip with a given index is visible or not.
     */
    isChipVisible(index: number): boolean;
    /**
     * Updates the filtering cell area.
     */
    updateFilterCellArea(): void;
    get template(): TemplateRef<any>;
    /**
     * Gets the context passed to the filter template.
     *
     * @memberof IgxGridFilteringCellComponent
     */
    get context(): {
        $implicit: ColumnType;
        column: ColumnType;
    };
    /**
     * Chip clicked event handler.
     */
    onChipClicked(expression?: IFilteringExpression): void;
    /**
     * Chip removed event handler.
     */
    onChipRemoved(eventArgs: IBaseChipEventArgs, item: ExpressionUI): void;
    /**
     * Clears the filtering.
     */
    clearFiltering(): void;
    /**
     * Returns the filtering indicator class.
     */
    filteringIndicatorClass(): {
        [x: string]: boolean;
    };
    protected get filteringElementsSize(): _Size;
    private removeExpression;
    private isMoreIconHidden;
    private updateVisibleFilters;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridFilteringCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridFilteringCellComponent, "igx-grid-filtering-cell", never, { "column": { "alias": "column"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @hidden
 */
declare class IgxGridHeaderGroupComponent implements DoCheck {
    private cdr;
    grid: GridType;
    private ref;
    colResizingService: IgxColumnResizingService;
    filteringService: IgxFilteringService;
    protected platform: PlatformUtil;
    get rowEnd(): number;
    get colEnd(): number;
    get rowStart(): number;
    get colStart(): number;
    get pinnedCss(): boolean;
    get headerID(): string;
    /**
     * Gets the column of the header group.
     *
     * @memberof IgxGridHeaderGroupComponent
     */
    column: ColumnType;
    get active(): boolean;
    get activeGroup(): boolean;
    /**
     * @hidden
     */
    header: IgxGridHeaderComponent;
    /**
     * @hidden
     */
    filter: IgxGridFilteringCellComponent;
    /**
     * @hidden
     */
    children: QueryList<IgxGridHeaderGroupComponent>;
    /**
     * Gets the width of the header group.
     *
     * @memberof IgxGridHeaderGroupComponent
     */
    get width(): string;
    defaultCss: boolean;
    get headerDragCss(): boolean;
    get filteringCss(): boolean;
    /**
     * @hidden
     */
    get zIndex(): number;
    /**
     * @hidden
     */
    get ariaHidden(): boolean;
    /**
     * Gets whether the header group belongs to a column that is filtered.
     *
     * @memberof IgxGridHeaderGroupComponent
     */
    get isFiltered(): boolean;
    /**
     * Gets whether the header group is stored in the last column in the pinned area.
     *
     * @memberof IgxGridHeaderGroupComponent
     */
    get isLastPinned(): boolean;
    /**
     * Gets whether the header group is stored in the first column of the right pinned area.
     */
    get isFirstPinned(): boolean;
    get groupDisplayStyle(): string;
    /**
     * Gets whether the header group is stored in a pinned column.
     *
     * @memberof IgxGridHeaderGroupComponent
     */
    get isPinned(): boolean;
    /**
     * Gets whether the header group belongs to a column that is moved.
     *
     * @memberof IgxGridHeaderGroupComponent
     */
    get isHeaderDragged(): boolean;
    /**
     * @hidden
     */
    get hasLastPinnedChildColumn(): boolean;
    /**
     * @hidden
     */
    get hasFirstPinnedChildColumn(): boolean;
    /**
     * @hidden
     */
    get selectable(): boolean;
    /**
     * @hidden
     */
    get selected(): boolean;
    /**
     * @hidden
     */
    get height(): number;
    /**
     * @hidden
     */
    get title(): string;
    get nativeElement(): HTMLElement;
    /**
     * @hidden
     */
    onMouseDown(event: MouseEvent): void;
    /**
     * @hidden
     */
    groupClicked(event: MouseEvent): void;
    /**
     * @hidden @internal
     */
    onPointerDownIndicator(event: any): void;
    /**
     * @hidden @internal
     */
    toggleExpandState(event: MouseEvent): void;
    /**
     * @hidden @internal
     */
    pointerdown(event: PointerEvent): void;
    activate(): void;
    ngDoCheck(): void;
    /**
     * @hidden
     */
    onPinterEnter(): void;
    /**
     * @hidden
     */
    onPointerLeave(): void;
    protected get activeNode(): {
        row: number;
        column: number;
        level: number;
        mchCache: {
            level: number;
            visibleIndex: number;
        };
        layout: {
            rowStart: number;
            colStart: number;
            rowEnd: number;
            colEnd: number;
            columnVisibleIndex: number;
        };
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridHeaderGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridHeaderGroupComponent, "igx-grid-header-group", never, { "column": { "alias": "column"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IgxSummaryOperand {
    /**
     * Counts all the records in the data source.
     * If filtering is applied, counts only the filtered records.
     * ```typescript
     * IgxSummaryOperand.count(dataSource);
     * ```
     *
     * @memberof IgxSummaryOperand
     */
    static count(data: any[]): number;
    /**
     * Executes the static `count` method and returns `IgxSummaryResult[]`.
     * ```typescript
     * interface IgxSummaryResult {
     *   key: string;
     *   label: string;
     *   summaryResult: any;
     * }
     * ```
     * Can be overridden in the inherited classes to provide customization for the `summary`.
     * ```typescript
     * class CustomSummary extends IgxSummaryOperand {
     *   constructor() {
     *     super();
     *   }
     *   public operate(data: any[], allData: any[], fieldName: string, groupRecord: IGroupByRecord): IgxSummaryResult[] {
     *     const result = [];
     *     result.push({
     *       key: "test",
     *       label: "Test",
     *       summaryResult: IgxSummaryOperand.count(data)
     *     });
     *     return result;
     *   }
     * }
     * this.grid.getColumnByName('ColumnName').summaries = CustomSummary;
     * ```
     *
     * @memberof IgxSummaryOperand
     */
    operate(data?: any[], _allData?: any[], _fieldName?: string, _groupRecord?: IGroupByRecord): IgxSummaryResult[];
}
declare class IgxNumberSummaryOperand extends IgxSummaryOperand {
    /**
     * Returns the minimum numeric value in the provided data records.
     * If filtering is applied, returns the minimum value in the filtered data records.
     * ```typescript
     * IgxNumberSummaryOperand.min(data);
     * ```
     *
     * @memberof IgxNumberSummaryOperand
     */
    static min(data: any[]): number;
    /**
     * Returns the maximum numeric value in the provided data records.
     * If filtering is applied, returns the maximum value in the filtered data records.
     * ```typescript
     * IgxNumberSummaryOperand.max(data);
     * ```
     *
     * @memberof IgxNumberSummaryOperand
     */
    static max(data: any[]): number;
    /**
     * Returns the sum of the numeric values in the provided data records.
     * If filtering is applied, returns the sum of the numeric values in the data records.
     * ```typescript
     * IgxNumberSummaryOperand.sum(data);
     * ```
     *
     * @memberof IgxNumberSummaryOperand
     */
    static sum(data: any[]): number;
    /**
     * Returns the average numeric value in the data provided data records.
     * If filtering is applied, returns the average numeric value in the filtered data records.
     * ```typescript
     * IgxSummaryOperand.average(data);
     * ```
     *
     * @memberof IgxNumberSummaryOperand
     */
    static average(data: any[]): number;
    /**
     * Executes the static methods and returns `IgxSummaryResult[]`.
     * ```typescript
     * interface IgxSummaryResult {
     *   key: string;
     *   label: string;
     *   summaryResult: any;
     * }
     * ```
     * Can be overridden in the inherited classes to provide customization for the `summary`.
     * ```typescript
     * class CustomNumberSummary extends IgxNumberSummaryOperand {
     *   constructor() {
     *     super();
     *   }
     *   public operate(data: any[], allData: any[], fieldName: string, groupRecord: IGroupByRecord): IgxSummaryResult[] {
     *     const result = super.operate(data, allData, fieldName, groupRecord);
     *     result.push({
     *       key: "avg",
     *       label: "Avg",
     *       summaryResult: IgxNumberSummaryOperand.average(data)
     *     });
     *     result.push({
     *       key: 'mdn',
     *       label: 'Median',
     *       summaryResult: this.findMedian(data)
     *     });
     *     return result;
     *   }
     * }
     * this.grid.getColumnByName('ColumnName').summaries = CustomNumberSummary;
     * ```
     *
     * @memberof IgxNumberSummaryOperand
     */
    operate(data?: any[], allData?: any[], fieldName?: string, groupRecord?: IGroupByRecord): IgxSummaryResult[];
}
declare class IgxDateSummaryOperand extends IgxSummaryOperand {
    /**
     * Returns the latest date value in the data records.
     * If filtering is applied, returns the latest date value in the filtered data records.
     * ```typescript
     * IgxDateSummaryOperand.latest(data);
     * ```
     *
     * @memberof IgxDateSummaryOperand
     */
    static latest(data: any[]): any;
    /**
     * Returns the earliest date value in the data records.
     * If filtering is applied, returns the latest date value in the filtered data records.
     * ```typescript
     * IgxDateSummaryOperand.earliest(data);
     * ```
     *
     * @memberof IgxDateSummaryOperand
     */
    static earliest(data: any[]): any;
    /**
     * Executes the static methods and returns `IgxSummaryResult[]`.
     * ```typescript
     * interface IgxSummaryResult {
     *   key: string;
     *   label: string;
     *   summaryResult: any;
     * }
     * ```
     * Can be overridden in the inherited classes to provide customization for the `summary`.
     * ```typescript
     * class CustomDateSummary extends IgxDateSummaryOperand {
     *   constructor() {
     *     super();
     *   }
     *   public operate(data: any[], allData: any[], fieldName: string, groupRecord: IGroupByRecord): IgxSummaryResult[] {
     *     const result = super.operate(data, allData, fieldName, groupRecord);
     *     result.push({
     *       key: "deadline",
     *       label: "Deadline Date",
     *       summaryResult: this.calculateDeadline(data);
     *     });
     *     return result;
     *   }
     * }
     * this.grid.getColumnByName('ColumnName').summaries = CustomDateSummary;
     * ```
     *
     * @memberof IgxDateSummaryOperand
     */
    operate(data?: any[], allData?: any[], fieldName?: string, groupRecord?: IGroupByRecord): IgxSummaryResult[];
}
declare class IgxTimeSummaryOperand extends IgxSummaryOperand {
    /**
     * Returns the latest time value in the data records. Compare only the time part of the date.
     * If filtering is applied, returns the latest time value in the filtered data records.
     * ```typescript
     * IgxTimeSummaryOperand.latestTime(data);
     * ```
     *
     * @memberof IgxTimeSummaryOperand
     */
    static latestTime(data: any[]): any;
    /**
     * Returns the earliest time value in the data records. Compare only the time part of the date.
     * If filtering is applied, returns the earliest time value in the filtered data records.
     * ```typescript
     * IgxTimeSummaryOperand.earliestTime(data);
     * ```
     *
     * @memberof IgxTimeSummaryOperand
     */
    static earliestTime(data: any[]): any;
    /**
     * @memberof IgxTimeSummaryOperand
     */
    operate(data?: any[], allData?: any[], fieldName?: string, groupRecord?: IGroupByRecord): IgxSummaryResult[];
}

declare class IgxFilterCellTemplateDirective {
    template: TemplateRef<IgxColumnTemplateContext>;
    static ngTemplateContextGuard(_directive: IgxFilterCellTemplateDirective, context: unknown): context is IgxColumnTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFilterCellTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxFilterCellTemplateDirective, "[igxFilterCellTemplate]", never, {}, {}, never, never, true, never>;
}
declare class IgxCellTemplateDirective {
    template: TemplateRef<IgxCellTemplateContext>;
    static ngTemplateContextGuard(_directive: IgxCellTemplateDirective, context: unknown): context is IgxCellTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxCellTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxCellTemplateDirective, "[igxCell]", never, {}, {}, never, never, true, never>;
}
declare class IgxCellValidationErrorDirective {
    template: TemplateRef<IgxCellTemplateContext>;
    static ngTemplateContextGuard(_directive: IgxCellValidationErrorDirective, context: unknown): context is IgxCellTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxCellValidationErrorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxCellValidationErrorDirective, "[igxCellValidationError]", never, {}, {}, never, never, true, never>;
}
declare class IgxCellHeaderTemplateDirective {
    template: TemplateRef<IgxColumnTemplateContext>;
    static ngTemplateContextGuard(_directive: IgxCellHeaderTemplateDirective, context: unknown): context is IgxColumnTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxCellHeaderTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxCellHeaderTemplateDirective, "[igxHeader]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxCellFooterTemplateDirective {
    template: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxCellFooterTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxCellFooterTemplateDirective, "[igxFooter]", never, {}, {}, never, never, true, never>;
}
declare class IgxCellEditorTemplateDirective {
    template: TemplateRef<IgxCellTemplateContext>;
    static ngTemplateContextGuard(_directive: IgxCellEditorTemplateDirective, context: unknown): context is IgxCellTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxCellEditorTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxCellEditorTemplateDirective, "[igxCellEditor]", never, {}, {}, never, never, true, never>;
}
declare class IgxCollapsibleIndicatorTemplateDirective {
    template: TemplateRef<IgxColumnTemplateContext>;
    static ngTemplateContextGuard(_directive: IgxCollapsibleIndicatorTemplateDirective, context: unknown): context is IgxColumnTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxCollapsibleIndicatorTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxCollapsibleIndicatorTemplateDirective, "[igxCollapsibleIndicator]", never, {}, {}, never, never, true, never>;
}
declare class IgxSummaryTemplateDirective {
    template: TemplateRef<IgxSummaryTemplateContext>;
    static ngTemplateContextGuard(_directive: IgxSummaryTemplateDirective, context: unknown): context is IgxSummaryTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxSummaryTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxSummaryTemplateDirective, "[igxSummary]", never, {}, {}, never, never, true, never>;
}

/**
 * **Ignite UI for Angular Column** -
 * [Documentation](https://www.infragistics.com/products/ignite-ui-angular/angular/components/grid/grid#columns-configuration)
 *
 * The Ignite UI Column is used within an `igx-grid` element to define what data the column will show. Features such as sorting,
 * filtering & editing are enabled at the column level.  You can also provide a template containing custom content inside
 * the column using `ng-template` which will be used for all cells within the column.
 *
 * @igxParent IgxGridComponent, IgxTreeGridComponent, IgxHierarchicalGridComponent, IgxPivotGridComponent, IgxRowIslandComponent, IgxColumnGroupComponent, IgxColumnLayoutComponent
 */
declare class IgxColumnComponent implements AfterContentInit, OnDestroy, ColumnType {
    grid: GridType;
    private _validators;
    /** @hidden @internal **/
    cdr: ChangeDetectorRef;
    protected platform: PlatformUtil;
    /**
     * Sets/gets the `field` value.
     * ```typescript
     * let columnField = this.column.field;
     * ```
     * ```html
     * <igx-column [field] = "'ID'"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set field(value: string);
    get field(): string;
    /**
     * Sets/gets whether to merge cells in this column.
     * ```html
     * <igx-column [merge]="true"></igx-column>
     * ```
     *
     */
    get merge(): boolean;
    set merge(value: boolean);
    /**
     * @hidden @internal
     */
    validators: Validator[];
    /**
     * Sets/gets the `header` value.
     * ```typescript
     * let columnHeader = this.column.header;
     * ```
     * ```html
     * <igx-column [header] = "'ID'"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    header: string;
    /**
     * Sets/gets the `title` value.
     * ```typescript
     * let title = this.column.title;
     * ```
     * ```html
     * <igx-column [title] = "'Some column tooltip'"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    title: string;
    /**
     * Sets/gets whether the column is sortable.
     * Default value is `false`.
     * ```typescript
     * let isSortable = this.column.sortable;
     * ```
     * ```html
     * <igx-column [sortable] = "true"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    sortable: boolean;
    /**
     * Returns if the column is selectable.
     * ```typescript
     * let columnSelectable = this.column.selectable;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get selectable(): boolean;
    /**
     * Sets if the column is selectable.
     * Default value is `true`.
     * ```html
     * <igx-column [selectable] = "false"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set selectable(value: boolean);
    /**
     * Sets/gets whether the column is groupable.
     * Default value is `false`.
     * ```typescript
     * let isGroupable = this.column.groupable;
     * ```
     * ```html
     * <igx-column [groupable] = "true"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get groupable(): boolean;
    set groupable(value: boolean);
    /**
     * Gets whether the column is editable.
     * Default value is `false`.
     * ```typescript
     * let isEditable = this.column.editable;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get editable(): boolean;
    /**
     * Sets whether the column is editable.
     * ```typescript
     * this.column.editable = true;
     * ```
     * ```html
     * <igx-column [editable] = "true"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set editable(editable: boolean);
    /**
     * Sets/gets whether the column is filterable.
     * Default value is `true`.
     * ```typescript
     * let isFilterable = this.column.filterable;
     * ```
     * ```html
     * <igx-column [filterable] = "false"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    filterable: boolean;
    /**
     * Sets/gets whether the column is resizable.
     * Default value is `false`.
     * ```typescript
     * let isResizable = this.column.resizable;
     * ```
     * ```html
     * <igx-column [resizable] = "true"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    resizable: boolean;
    /**
     * Sets/gets whether the column header is included in autosize logic.
     * Useful when template for a column header is sized based on parent, for example a default `div`.
     * Default value is `false`.
     * ```typescript
     * let isResizable = this.column.resizable;
     * ```
     * ```html
     * <igx-column [resizable] = "true"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    autosizeHeader: boolean;
    /**
     * Gets a value indicating whether the summary for the column is enabled.
     * ```typescript
     * let hasSummary = this.column.hasSummary;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get hasSummary(): boolean;
    /**
     * Sets a value indicating whether the summary for the column is enabled.
     * Default value is `false`.
     * ```html
     * <igx-column [hasSummary] = "true"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set hasSummary(value: boolean);
    /**
     * Gets whether the column is hidden.
     * ```typescript
     * let isHidden = this.column.hidden;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get hidden(): boolean;
    /**
     * Sets the column hidden property.
     * Default value is `false`.
     * ```html
     * <igx-column [hidden] = "true"></igx-column>
     * ```
     *
     * Two-way data binding.
     * ```html
     * <igx-column [(hidden)] = "model.isHidden"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set hidden(value: boolean);
    /**
     * Returns if the column is selected.
     * ```typescript
     * let isSelected = this.column.selected;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get selected(): boolean;
    /**
     * Select/deselect a column.
     * Default value is `false`.
     * ```typescript
     * this.column.selected = true;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set selected(value: boolean);
    /**
     * Emitted when the column is hidden or shown.
     *
     * ```html
     * <igx-column (hiddenChange)="hiddenChange($event)">
     * </igx-column>
     * ```
     *
     */
    hiddenChange: EventEmitter<boolean>;
    /**
     * Emitted when the column expanded or collapsed.
     *
     * ```html
     * <igx-column (expandedChange)="expandedChange($event)">
     * </igx-column>
     * ```
     *
     */
    expandedChange: EventEmitter<boolean>;
    /** @hidden */
    collapsibleChange: EventEmitter<boolean>;
    /** @hidden */
    visibleWhenCollapsedChange: EventEmitter<boolean>;
    /** @hidden @internal */
    columnChange: EventEmitter<void>;
    /**
     * Gets whether the hiding is disabled.
     * ```typescript
     * let isHidingDisabled =  this.column.disableHiding;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    disableHiding: boolean;
    /**
     * Gets whether the pinning is disabled.
     * ```typescript
     * let isPinningDisabled =  this.column.disablePinning;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    disablePinning: boolean;
    /**
     * Gets the `width` of the column.
     * ```typescript
     * let columnWidth = this.column.width;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get width(): string;
    /**
     * Sets the `width` of the column.
     * ```html
     * <igx-column [width] = "'25%'"></igx-column>
     * ```
     *
     * Two-way data binding.
     * ```html
     * <igx-column [(width)]="model.columns[0].width"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set width(value: string);
    /** @hidden @internal **/
    autoSize: number;
    /**
     * Sets/gets the maximum `width` of the column.
     * ```typescript
     * let columnMaxWidth = this.column.width;
     * ```
     * ```html
     * <igx-column [maxWidth] = "'150px'"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set maxWidth(value: string);
    get maxWidth(): string;
    /**
     * Sets/gets the class selector of the column header.
     * ```typescript
     * let columnHeaderClass = this.column.headerClasses;
     * ```
     * ```html
     * <igx-column [headerClasses] = "'column-header'"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    headerClasses: string;
    /**
     * Sets conditional style properties on the column header.
     * Similar to `ngStyle` it accepts an object literal where the keys are
     * the style properties and the value is the expression to be evaluated.
     * ```typescript
     * styles = {
     *  background: 'royalblue',
     *  color: (column) => column.pinned ? 'red': 'inherit'
     * }
     * ```
     * ```html
     * <igx-column [headerStyles]="styles"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    headerStyles: any;
    /**
     * Sets/gets the class selector of the column group header.
     * ```typescript
     * let columnHeaderClass = this.column.headerGroupClasses;
     * ```
     * ```html
     * <igx-column [headerGroupClasses] = "'column-group-header'"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    headerGroupClasses: string;
    /**
     * Sets conditional style properties on the column header group wrapper.
     * Similar to `ngStyle` it accepts an object literal where the keys are
     * the style properties and the value is the expression to be evaluated.
     * ```typescript
     * styles = {
     *  background: 'royalblue',
     *  color: (column) => column.pinned ? 'red': 'inherit'
     * }
     * ```
     * ```html
     * <igx-column [headerGroupStyles]="styles"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    headerGroupStyles: any;
    /**
     * Sets a conditional class selector of the column cells.
     * Accepts an object literal, containing key-value pairs,
     * where the key is the name of the CSS class, while the
     * value is either a callback function that returns a boolean,
     * or boolean, like so:
     * ```typescript
     * callback = (rowData, columnKey, cellValue, rowIndex) => { return rowData[columnKey] > 6; }
     * cellClasses = { 'className' : this.callback };
     * ```
     * ```html
     * <igx-column [cellClasses] = "cellClasses"></igx-column>
     * <igx-column [cellClasses] = "{'class1' : true }"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    cellClasses: any;
    /**
     * Sets conditional style properties on the column cells.
     * Similar to `ngStyle` it accepts an object literal where the keys are
     * the style properties and the value is the expression to be evaluated.
     * As with `cellClasses` it accepts a callback function.
     * ```typescript
     * styles = {
     *  background: 'royalblue',
     *  color: (rowData, columnKey, cellValue, rowIndex) => value.startsWith('Important') ? 'red': 'inherit'
     * }
     * ```
     * ```html
     * <igx-column [cellStyles]="styles"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    cellStyles: any;
    /**
     * Applies display format to cell values in the column. Does not modify the underlying data.
     *
     * @remarks
     * Note: As the formatter is used in places like the Excel style filtering dialog, in certain
     * scenarios (remote filtering for example), the row data argument can be `undefined`.
     *
     *
     * In this example, we check to see if the column name is Salary, and then provide a method as the column formatter
     * to format the value into a currency string.
     *
     * @example
     * ```typescript
     * columnInit(column: IgxColumnComponent) {
     *   if (column.field == "Salary") {
     *     column.formatter = (salary => this.format(salary));
     *   }
     * }
     *
     * format(value: number) : string {
     *   return formatCurrency(value, "en-us", "$");
     * }
     * ```
     *
     * @example
     * ```typescript
     * const column = this.grid.getColumnByName('Address');
     * const addressFormatter = (address: string, rowData: any) => data.privacyEnabled ? 'unknown' : address;
     * column.formatter = addressFormatter;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    formatter: (value: any, rowData?: any) => any;
    /**
     * The summaryFormatter is used to format the display of the column summaries.
     *
     * In this example, we check to see if the column name is OrderDate, and then provide a method as the summaryFormatter
     * to change the locale for the dates to 'fr-FR'. The summaries with the count key are skipped so they are displayed as numbers.
     *
     * ```typescript
     * columnInit(column: IgxColumnComponent) {
     *   if (column.field == "OrderDate") {
     *     column.summaryFormatter = this.summaryFormat;
     *   }
     * }
     *
     * summaryFormat(summary: IgxSummaryResult, summaryOperand: IgxSummaryOperand): string {
     *   const result = summary.summaryResult;
     *   if(summaryResult.key !== 'count' && result !== null && result !== undefined) {
     *      const pipe = new DatePipe('fr-FR');
     *      return pipe.transform(result,'mediumDate');
     *   }
     *   return result;
     * }
     * ```
     *
     * @memberof IgxColumnComponent
     */
    summaryFormatter: (summary: IgxSummaryResult, summaryOperand: IgxSummaryOperand) => any;
    /**
     * Sets/gets whether the column filtering should be case sensitive.
     * Default value is `true`.
     * ```typescript
     * let filteringIgnoreCase = this.column.filteringIgnoreCase;
     * ```
     * ```html
     * <igx-column [filteringIgnoreCase] = "false"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    filteringIgnoreCase: boolean;
    /**
     * Sets/gets whether the column sorting should be case sensitive.
     * Default value is `true`.
     * ```typescript
     * let sortingIgnoreCase = this.column.sortingIgnoreCase;
     * ```
     * ```html
     * <igx-column [sortingIgnoreCase] = "false"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    sortingIgnoreCase: boolean;
    /**
     * Sets/gets whether the column is `searchable`.
     * Default value is `true`.
     * ```typescript
     * let isSearchable =  this.column.searchable';
     * ```
     * ```html
     *  <igx-column [searchable] = "false"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    searchable: boolean;
    /**
     * Sets/gets the data type of the column values.
     * Default value is `string`.
     * ```typescript
     * let columnDataType = this.column.dataType;
     * ```
     * ```html
     * <igx-column [dataType] = "'number'"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    dataType: GridColumnDataType;
    /** @hidden */
    collapsibleIndicatorTemplate: TemplateRef<IgxColumnTemplateContext>;
    /**
     * Row index where the current field should end.
     * The amount of rows between rowStart and rowEnd will determine the amount of spanning rows to that field
     * ```html
     * <igx-column-layout>
     *   <igx-column [rowEnd]="2" [rowStart]="1" [colStart]="1"></igx-column>
     * </igx-column-layout>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    rowEnd: number;
    /**
     * Column index where the current field should end.
     * The amount of columns between colStart and colEnd will determine the amount of spanning columns to that field
     * ```html
     * <igx-column-layout>
     *   <igx-column [colEnd]="3" [rowStart]="1" [colStart]="1"></igx-column>
     * </igx-column-layout>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    colEnd: number;
    /**
     * Row index from which the field is starting.
     * ```html
     * <igx-column-layout>
     *   <igx-column [rowStart]="1" [colStart]="1"></igx-column>
     * </igx-column-layout>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    rowStart: number;
    /**
     * Column index from which the field is starting.
     * ```html
     * <igx-column-layout>
     *   <igx-column [colStart]="1" [rowStart]="1"></igx-column>
     * </igx-column-layout>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    colStart: number;
    /**
     * Sets/gets custom properties provided in additional template context.
     *
     * ```html
     * <igx-column [additionalTemplateContext]="contextObject">
     *   <ng-template igxCell let-cell="cell" let-props="additionalTemplateContext">
     *      {{ props }}
     *   </ng-template>
     * </igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    additionalTemplateContext: any;
    /**
     * Emitted when the column width changes.
     *
     * ```html
     * <igx-column (widthChange)="widthChange($event)">
     * </igx-column>
     * ```
     *
     */
    widthChange: EventEmitter<string>;
    /**
     * Emitted when the column is pinned/unpinned.
     *
     * ```html
     * <igx-column (pinnedChange)="pinnedChange($event)">
     * </igx-column>
     * ```
     *
     */
    pinnedChange: EventEmitter<boolean>;
    /**
     * @hidden
     */
    filterCellTemplateDirective: IgxFilterCellTemplateDirective;
    /**
     * @hidden
     */
    protected summaryTemplateDirective: IgxSummaryTemplateDirective;
    /**
     * @hidden
     * @see {@link bodyTemplate}
     */
    protected cellTemplate: IgxCellTemplateDirective;
    /**
     * @hidden
     */
    protected cellValidationErrorTemplate: IgxCellValidationErrorDirective;
    /**
     * @hidden
     */
    protected headTemplate: QueryList<IgxCellHeaderTemplateDirective>;
    /**
     * @hidden
     */
    protected editorTemplate: IgxCellEditorTemplateDirective;
    /**
     * @hidden
     */
    protected collapseIndicatorTemplate: IgxCollapsibleIndicatorTemplateDirective;
    /**
     * @hidden
     */
    get calcWidth(): any;
    /** @hidden @internal **/
    calcPixelWidth: number;
    /**
     * @hidden
     */
    get maxWidthPx(): number;
    /**
     * @hidden
     */
    get maxWidthPercent(): number;
    /**
     * @hidden
     */
    get minWidthPx(): number;
    /**
     * @hidden
     */
    get userSetMinWidthPx(): number;
    /**
     * @hidden
     */
    get minWidthPercent(): number;
    /**
     * Sets/gets the minimum `width` of the column.
     * Default value is `88`;
     * ```typescript
     * let columnMinWidth = this.column.minWidth;
     * ```
     * ```html
     * <igx-column [minWidth] = "'100px'"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set minWidth(value: string);
    get minWidth(): string;
    /** @hidden @internal **/
    get resolvedWidth(): string;
    /**
     * Gets the column index.
     * ```typescript
     * let columnIndex = this.column.index;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get index(): number;
    /**
     * Gets the pinning position of the column.
     * ```typescript
     * let pinningPosition = this.column.pinningPosition;
     */
    get pinningPosition(): ColumnPinningPosition;
    /**
     * Sets the pinning position of the column.
     *```html
     * <igx-column [pinningPosition]="1"></igx-column>
     * ```
     */
    set pinningPosition(value: ColumnPinningPosition);
    /**
     * Gets whether the column is `pinned`.
     * ```typescript
     * let isPinned = this.column.pinned;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get pinned(): boolean;
    /**
     * Sets whether the column is pinned.
     * Default value is `false`.
     * ```html
     * <igx-column [pinned] = "true"></igx-column>
     * ```
     *
     * Two-way data binding.
     * ```html
     * <igx-column [(pinned)] = "model.columns[0].isPinned"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set pinned(value: boolean);
    /**
     * Gets the column `summaries`.
     * ```typescript
     * let columnSummaries = this.column.summaries;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get summaries(): any;
    /**
     * Sets the column `summaries`.
     * ```typescript
     * this.column.summaries = IgxNumberSummaryOperand;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set summaries(classRef: any);
    /**
     * Sets/gets the summary operands to exclude from display.
     * Accepts an array of string keys representing the summary types to disable, such as 'Min', 'Max', 'Count' etc.
     * ```typescript
     * let disabledSummaries = this.column.disabledSummaries;
     * ```
     * ```html
     * <igx-column [disabledSummaries]="['min', 'max', 'average']"></igx-column>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get disabledSummaries(): string[];
    set disabledSummaries(value: string[]);
    /**
     * Gets the column `filters`.
     * ```typescript
     * let columnFilters = this.column.filters'
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get filters(): IgxFilteringOperand;
    /**
     * Sets the column `filters`.
     * ```typescript
     * this.column.filters = IgxBooleanFilteringOperand.instance().
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set filters(instance: IgxFilteringOperand);
    /**
     * Gets the column `sortStrategy`.
     * ```typescript
     * let sortStrategy = this.column.sortStrategy
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get sortStrategy(): ISortingStrategy;
    /**
     * Sets the column `sortStrategy`.
     * ```typescript
     * this.column.sortStrategy = new CustomSortingStrategy().
     * class CustomSortingStrategy extends SortingStrategy {...}
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set sortStrategy(classRef: ISortingStrategy);
    /**
     * Gets the function that compares values for merging.
     * ```typescript
     * let mergingComparer = this.column.mergingComparer'
     * ```
     */
    get mergingComparer(): (prevRecord: any, record: any, field: string) => boolean;
    /**
     * Sets a custom function to compare values for merging.
     * ```typescript
     * this.column.mergingComparer = (prevRecord: any, record: any, field: string) => { return prevRecord[field] === record[field]; }
     * ```
     */
    set mergingComparer(funcRef: (prevRecord: any, record: any, field: string) => boolean);
    /**
     * Gets the function that compares values for grouping.
     * ```typescript
     * let groupingComparer = this.column.groupingComparer'
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get groupingComparer(): (a: any, b: any, currRec?: any, groupRec?: any) => number;
    /**
     * Sets a custom function to compare values for grouping.
     * Subsequent values in the sorted data that the function returns 0 for are grouped.
     * ```typescript
     * this.column.groupingComparer = (a: any, b: any, currRec?: any, groupRec?: any) => { return a === b ? 0 : -1; }
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set groupingComparer(funcRef: (a: any, b: any, currRec?: any, groupRec?: any) => number);
    /**
     * @hidden @internal
     */
    get defaultMinWidth(): string;
    /**
     * Returns a reference to the `summaryTemplate`.
     * ```typescript
     * let summaryTemplate = this.column.summaryTemplate;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get summaryTemplate(): TemplateRef<IgxSummaryTemplateContext>;
    /**
     * Sets the summary template.
     * ```html
     * <ng-template #summaryTemplate igxSummary let-summaryResults>
     *    <p>{{ summaryResults[0].label }}: {{ summaryResults[0].summaryResult }}</p>
     *    <p>{{ summaryResults[1].label }}: {{ summaryResults[1].summaryResult }}</p>
     * </ng-template>
     * ```
     * ```typescript
     * @ViewChild("'summaryTemplate'", {read: TemplateRef })
     * public summaryTemplate: TemplateRef<any>;
     * this.column.summaryTemplate = this.summaryTemplate;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set summaryTemplate(template: TemplateRef<IgxSummaryTemplateContext>);
    /**
     * Returns a reference to the `bodyTemplate`.
     * ```typescript
     * let bodyTemplate = this.column.bodyTemplate;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get bodyTemplate(): TemplateRef<IgxCellTemplateContext>;
    /**
     * Sets the body template.
     * ```html
     * <ng-template #bodyTemplate igxCell let-val>
     *    <div style = "background-color: yellowgreen" (click) = "changeColor(val)">
     *       <span> {{val}} </span>
     *    </div>
     * </ng-template>
     * ```
     * ```typescript
     * @ViewChild("'bodyTemplate'", {read: TemplateRef })
     * public bodyTemplate: TemplateRef<any>;
     * this.column.bodyTemplate = this.bodyTemplate;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set bodyTemplate(template: TemplateRef<IgxCellTemplateContext>);
    /**
     * Returns a reference to the header template.
     * ```typescript
     * let headerTemplate = this.column.headerTemplate;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get headerTemplate(): TemplateRef<IgxColumnTemplateContext>;
    /**
     * Sets the header template.
     * Note that the column header height is fixed and any content bigger than it will be cut off.
     * ```html
     * <ng-template #headerTemplate>
     *   <div style = "background-color:black" (click) = "changeColor(val)">
     *       <span style="color:red" >{{column.field}}</span>
     *   </div>
     * </ng-template>
     * ```
     * ```typescript
     * @ViewChild("'headerTemplate'", {read: TemplateRef })
     * public headerTemplate: TemplateRef<any>;
     * this.column.headerTemplate = this.headerTemplate;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set headerTemplate(template: TemplateRef<IgxColumnTemplateContext>);
    /**
     * Returns a reference to the inline editor template.
     * ```typescript
     * let inlineEditorTemplate = this.column.inlineEditorTemplate;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get inlineEditorTemplate(): TemplateRef<IgxCellTemplateContext>;
    /**
     * Sets the inline editor template.
     * ```html
     * <ng-template #inlineEditorTemplate igxCellEditor let-cell="cell">
     *     <input type="string" [(ngModel)]="cell.value"/>
     * </ng-template>
     * ```
     * ```typescript
     * @ViewChild("'inlineEditorTemplate'", {read: TemplateRef })
     * public inlineEditorTemplate: TemplateRef<any>;
     * this.column.inlineEditorTemplate = this.inlineEditorTemplate;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set inlineEditorTemplate(template: TemplateRef<IgxCellTemplateContext>);
    /**
     * Returns a reference to the validation error template.
     * ```typescript
     * let errorTemplate = this.column.errorTemplate;
     * ```
     */
    get errorTemplate(): TemplateRef<IgxCellTemplateContext>;
    /**
     * Sets the error template.
     * ```html
     * <ng-template igxCellValidationError let-cell="cell" #errorTemplate >
     *     <div *ngIf="cell.validation.errors?.['forbiddenName']">
     *      This name is forbidden.
     *     </div>
     * </ng-template>
     * ```
     * ```typescript
     * @ViewChild("'errorTemplate'", {read: TemplateRef })
     * public errorTemplate: TemplateRef<any>;
     * this.column.errorTemplate = this.errorTemplate;
     * ```
     */
    set errorTemplate(template: TemplateRef<IgxCellTemplateContext>);
    /**
     * Returns a reference to the `filterCellTemplate`.
     * ```typescript
     * let filterCellTemplate = this.column.filterCellTemplate;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get filterCellTemplate(): TemplateRef<IgxColumnTemplateContext>;
    /**
     * Sets the quick filter template.
     * ```html
     * <ng-template #filterCellTemplate IgxFilterCellTemplate let-column="column">
     *    <input (input)="onInput()">
     * </ng-template>
     * ```
     * ```typescript
     * @ViewChild("'filterCellTemplate'", {read: TemplateRef })
     * public filterCellTemplate: TemplateRef<any>;
     * this.column.filterCellTemplate = this.filterCellTemplate;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set filterCellTemplate(template: TemplateRef<IgxColumnTemplateContext>);
    /**
     * @hidden @internal
     */
    get cells(): CellType[];
    /**
     * @hidden @internal
     */
    get _cells(): CellType[];
    /**
     * Gets the column visible index.
     * If the column is not visible, returns `-1`.
     * ```typescript
     * let visibleColumnIndex =  this.column.visibleIndex;
     * ```
     */
    get visibleIndex(): number;
    /**
     * Returns a boolean indicating if the column is a `ColumnGroup`.
     * ```typescript
     * let columnGroup =  this.column.columnGroup;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get columnGroup(): boolean;
    /**
     * Returns a boolean indicating if the column is a `ColumnLayout` for multi-row layout.
     * ```typescript
     * let columnGroup =  this.column.columnGroup;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get columnLayout(): boolean;
    /**
     * Returns a boolean indicating if the column is a child of a `ColumnLayout` for multi-row layout.
     * ```typescript
     * let columnLayoutChild =  this.column.columnLayoutChild;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get columnLayoutChild(): boolean;
    /**
     * A list containing all the child columns under this column (if any).
     * Empty without children or if this column is not Group or Layout.
     */
    get childColumns(): ColumnType[];
    /** @hidden @internal **/
    get allChildren(): IgxColumnComponent[];
    /**
     * Returns the level of the column in a column group.
     * Returns `0` if the column doesn't have a `parent`.
     * ```typescript
     * let columnLevel =  this.column.level;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get level(): number;
    /** @hidden @internal **/
    get isLastPinned(): boolean;
    /** @hidden @internal **/
    get isFirstPinned(): boolean;
    /** @hidden @internal **/
    get gridRowSpan(): number;
    /** @hidden @internal **/
    get gridColumnSpan(): number;
    /**
     * Indicates whether the column will be visible when its parent is collapsed.
     * ```html
     * <igx-column-group>
     *   <igx-column [visibleWhenCollapsed]="true"></igx-column>
     * </igx-column-group>
     * ```
     *
     * @memberof IgxColumnComponent
     */
    set visibleWhenCollapsed(value: boolean);
    get visibleWhenCollapsed(): boolean;
    /**
     * @remarks
     * Pass optional parameters for DatePipe and/or DecimalPipe to format the display value for date and numeric columns.
     * Accepts an `IColumnPipeArgs` object with any of the `format`, `timezone` and `digitsInfo` properties.
     * For more details see https://angular.io/api/common/DatePipe and https://angular.io/api/common/DecimalPipe
     * @example
     * ```typescript
     * const pipeArgs: IColumnPipeArgs = {
     *      format: 'longDate',
     *      timezone: 'UTC',
     *      digitsInfo: '1.1-2'
     * }
     * ```
     * ```html
     * <igx-column dataType="date" [pipeArgs]="pipeArgs"></igx-column>
     * <igx-column dataType="number" [pipeArgs]="pipeArgs"></igx-column>
     * ```
     * @memberof IgxColumnComponent
     */
    set pipeArgs(value: IColumnPipeArgs);
    get pipeArgs(): IColumnPipeArgs;
    /**
     * Pass optional properties for the default column editors.
     * @remarks
     * Options may be applicable only to specific column type editors.
     * @example
     * ```typescript
     * const editorOptions: IColumnEditorOptions = {
     *      dateTimeFormat: 'MM/dd/YYYY',
     * }
     * ```
     * ```html
     * <igx-column dataType="date" [editorOptions]="editorOptions"></igx-column>
     * ```
     * @memberof IgxColumnComponent
     */
    set editorOptions(value: IColumnEditorOptions);
    get editorOptions(): IColumnEditorOptions;
    /**
     * @hidden
     * @internal
     */
    get collapsible(): boolean;
    set collapsible(_value: boolean);
    /**
     * @hidden
     * @internal
     */
    get expanded(): boolean;
    set expanded(_value: boolean);
    /**
     * @hidden
     */
    defaultWidth: string;
    /**
     * @hidden
     */
    widthSetByUser: boolean;
    /**
     * @hidden
     */
    hasNestedPath: boolean;
    /**
     * @hidden
     * @internal
     */
    defaultTimeFormat: string;
    /**
     * @hidden
     * @internal
     */
    defaultDateTimeFormat: string;
    /**
     * Returns the filteringExpressionsTree of the column.
     * ```typescript
     * let tree =  this.column.filteringExpressionsTree;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get filteringExpressionsTree(): FilteringExpressionsTree;
    /**
     * Sets/gets the parent column.
     * ```typescript
     * let parentColumn = this.column.parent;
     * ```
     * ```typescript
     * this.column.parent = higherLevelColumn;
     * ```
     */
    parent: ColumnType | null;
    /**
     * Sets/gets the children columns.
     * ```typescript
     * let columnChildren = this.column.children;
     * ```
     *
     * @deprecated in version 18.1.0. Use the `childColumns` property instead.
     */
    children: QueryList<IgxColumnComponent>;
    /**
     * @hidden
     */
    destroy$: Subject<any>;
    /**
     * @hidden
     */
    widthConstrained: boolean;
    /**
     * @hidden
     */
    protected _applySelectableClass: boolean;
    protected _vIndex: number;
    protected _pinningPosition: any;
    /**
     * @hidden
     */
    protected _pinned: boolean;
    /**
     * @hidden
     */
    protected _bodyTemplate: TemplateRef<IgxCellTemplateContext>;
    /**
     * @hidden
     */
    protected _errorTemplate: TemplateRef<IgxCellTemplateContext>;
    /**
     * @hidden
     */
    protected _headerTemplate: TemplateRef<IgxColumnTemplateContext>;
    /**
     * @hidden
     */
    protected _summaryTemplate: TemplateRef<IgxSummaryTemplateContext>;
    /**
     * @hidden
     */
    protected _inlineEditorTemplate: TemplateRef<IgxCellTemplateContext>;
    /**
     * @hidden
     */
    protected _filterCellTemplate: TemplateRef<IgxColumnTemplateContext>;
    /**
     * @hidden
     */
    protected _summaries: any;
    /**
     * @hidden
     */
    private _disabledSummaries;
    /**
     * @hidden
     */
    protected _filters: any;
    /**
     * @hidden
     */
    protected _sortStrategy: ISortingStrategy;
    /**
     * @hidden
     */
    protected _groupingComparer: (a: any, b: any, currRec?: any, groupRec?: any) => number;
    protected _mergingComparer: (prevRecord: any, record: any, field: string) => boolean;
    /**
     * @hidden
     */
    protected _hidden: boolean;
    /**
     * @hidden
     */
    protected _index: number;
    /**
     * @hidden
     */
    protected _disablePinning: boolean;
    /**
     * @hidden
     */
    protected _width: string;
    /**
     * @hidden
     */
    protected _defaultMinWidth: string;
    /**
     * @hidden
     */
    protected _maxWidth: any;
    /**
     * @hidden
     */
    protected _hasSummary: boolean;
    /**
     * @hidden
     */
    protected _editable: boolean;
    /**
     * @hidden
     */
    protected _groupable: boolean;
    /**
     * @hidden
     */
    protected _merge: boolean;
    /**
     *  @hidden
     */
    protected _visibleWhenCollapsed: any;
    /**
     * @hidden
     */
    protected _collapsible: boolean;
    /**
     * @hidden
     */
    protected _expanded: boolean;
    /**
     * @hidden
     */
    protected _selectable: boolean;
    /**
     * @hidden
     */
    protected get isPrimaryColumn(): boolean;
    private _field;
    private _calcWidth;
    private _columnPipeArgs;
    private _editorOptions;
    /**
     * @hidden
     * @internal
     */
    resetCaches(): void;
    /**
     * @hidden
     */
    ngOnDestroy(): void;
    /**
     * @hidden
     */
    ngAfterContentInit(): void;
    /**
     * @hidden
     */
    getGridTemplate(isRow: boolean): string;
    /** @hidden @internal **/
    getInitialChildColumnSizes(children: QueryList<IgxColumnComponent>): Array<MRLColumnSizeInfo>;
    /** @hidden @internal **/
    getFilledChildColumnSizes(children: QueryList<IgxColumnComponent>): Array<string>;
    /** @hidden @internal **/
    getResizableColUnderEnd(): MRLResizeColumnInfo[];
    /**
     * Pins the column in the specified position at the provided index in that pinned area.
     * Defaults to index `0` if not provided, or to the initial index in the pinned area.
     * Returns `true` if the column is successfully pinned. Returns `false` if the column cannot be pinned.
     * Column cannot be pinned if:
     * - Is already pinned
     * - index argument is out of range
     * ```typescript
     * let success = this.column.pin();
     * ```
     *
     * @memberof IgxColumnComponent
     */
    pin(index?: number, pinningPosition?: ColumnPinningPosition): boolean;
    /**
     * Unpins the column and place it at the provided index in the unpinned area.
     * Defaults to index `0` if not provided, or to the initial index in the unpinned area.
     * Returns `true` if the column is successfully unpinned. Returns `false` if the column cannot be unpinned.
     * Column cannot be unpinned if:
     * - Is already unpinned
     * - index argument is out of range
     * ```typescript
     * let success = this.column.unpin();
     * ```
     *
     * @memberof IgxColumnComponent
     */
    unpin(index?: number): boolean;
    /**
     * Moves a column to the specified visible index.
     * If passed index is invalid, or if column would receive a different visible index after moving, moving is not performed.
     * If passed index would move the column to a different column group. moving is not performed.
     *
     * @example
     * ```typescript
     * column.move(index);
     * ```
     * @memberof IgxColumnComponent
     */
    move(index: number): void;
    /**
     * No children for the column, so will returns 1 or 0, if the column is hidden.
     *
     * @hidden
     */
    calcChildren(): number;
    /**
     * Toggles column vibisility and emits the respective event.
     *
     * @hidden
     */
    toggleVisibility(value?: boolean): void;
    /**
     * Returns a reference to the top level parent column.
     * ```typescript
     * let topLevelParent =  this.column.topLevelParent;
     * ```
     */
    get topLevelParent(): ColumnType | undefined;
    /**
     * @hidden @internal
     */
    get headerCell(): IgxGridHeaderComponent;
    /**
     * @hidden @internal
     */
    get filterCell(): IgxGridFilteringCellComponent;
    /**
     * @hidden @internal
     */
    get headerGroup(): IgxGridHeaderGroupComponent;
    /**
     * Autosize the column to the longest currently visible cell value, including the header cell.
     * ```typescript
     * @ViewChild('grid') grid: IgxGridComponent;
     * let column = this.grid.columnList.filter(c => c.field === 'ID')[0];
     * column.autosize();
     * ```
     *
     * @memberof IgxColumnComponent
     * @param byHeaderOnly Set if column should be autosized based only on the header content.
     */
    autosize(byHeaderOnly?: boolean): void;
    /**
     * @hidden
     */
    getAutoSize(byHeader?: boolean): string;
    /**
     * @hidden
     */
    getCalcWidth(): any;
    /**
     * @hidden
     * Returns the width and padding of a header cell.
     */
    getHeaderCellWidths(): igniteui_angular_grids_core.ISizeInfo;
    /**
     * @hidden
     * Returns the size (in pixels) of the longest currently visible cell, including the header cell.
     * ```typescript
     * @ViewChild('grid') grid: IgxGridComponent;
     *
     * let column = this.grid.columnList.filter(c => c.field === 'ID')[0];
     * let size = column.getLargestCellWidth();
     * ```
     * @memberof IgxColumnComponent
     */
    getLargestCellWidth(): string;
    /**
     * @hidden
     */
    getCellWidth(): string;
    /**
     * @hidden
     */
    populateVisibleIndexes(): void;
    protected getColumnSizesString(children: QueryList<IgxColumnComponent>): string;
    /**
     * @hidden
     * @internal
     */
    getConstrainedSizePx(newSize: any): any;
    /**
     * @hidden
     * @internal
     */
    protected cacheCalcWidth(): any;
    /**
     * @hidden
     * @internal
     */
    protected setExpandCollapseState(): void;
    /**
     * @hidden
     * @internal
     */
    protected checkCollapsibleState(): boolean;
    /**
     * @hidden
     */
    get pinnable(): any;
    /**
     * @hidden
     */
    get applySelectableClass(): boolean;
    /**
     * @hidden
     */
    set applySelectableClass(value: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxColumnComponent, "igx-column", never, { "field": { "alias": "field"; "required": false; }; "merge": { "alias": "merge"; "required": false; }; "header": { "alias": "header"; "required": false; }; "title": { "alias": "title"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "groupable": { "alias": "groupable"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "autosizeHeader": { "alias": "autosizeHeader"; "required": false; }; "hasSummary": { "alias": "hasSummary"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "disableHiding": { "alias": "disableHiding"; "required": false; }; "disablePinning": { "alias": "disablePinning"; "required": false; }; "width": { "alias": "width"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "headerClasses": { "alias": "headerClasses"; "required": false; }; "headerStyles": { "alias": "headerStyles"; "required": false; }; "headerGroupClasses": { "alias": "headerGroupClasses"; "required": false; }; "headerGroupStyles": { "alias": "headerGroupStyles"; "required": false; }; "cellClasses": { "alias": "cellClasses"; "required": false; }; "cellStyles": { "alias": "cellStyles"; "required": false; }; "formatter": { "alias": "formatter"; "required": false; }; "summaryFormatter": { "alias": "summaryFormatter"; "required": false; }; "filteringIgnoreCase": { "alias": "filteringIgnoreCase"; "required": false; }; "sortingIgnoreCase": { "alias": "sortingIgnoreCase"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "dataType": { "alias": "dataType"; "required": false; }; "collapsibleIndicatorTemplate": { "alias": "collapsibleIndicatorTemplate"; "required": false; }; "rowEnd": { "alias": "rowEnd"; "required": false; }; "colEnd": { "alias": "colEnd"; "required": false; }; "rowStart": { "alias": "rowStart"; "required": false; }; "colStart": { "alias": "colStart"; "required": false; }; "additionalTemplateContext": { "alias": "additionalTemplateContext"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "pinningPosition": { "alias": "pinningPosition"; "required": false; }; "pinned": { "alias": "pinned"; "required": false; }; "summaries": { "alias": "summaries"; "required": false; }; "disabledSummaries": { "alias": "disabledSummaries"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "sortStrategy": { "alias": "sortStrategy"; "required": false; }; "mergingComparer": { "alias": "mergingComparer"; "required": false; }; "groupingComparer": { "alias": "groupingComparer"; "required": false; }; "summaryTemplate": { "alias": "summaryTemplate"; "required": false; }; "bodyTemplate": { "alias": "cellTemplate"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "inlineEditorTemplate": { "alias": "cellEditorTemplate"; "required": false; }; "errorTemplate": { "alias": "errorTemplate"; "required": false; }; "filterCellTemplate": { "alias": "filterCellTemplate"; "required": false; }; "visibleWhenCollapsed": { "alias": "visibleWhenCollapsed"; "required": false; }; "pipeArgs": { "alias": "pipeArgs"; "required": false; }; "editorOptions": { "alias": "editorOptions"; "required": false; }; }, { "hiddenChange": "hiddenChange"; "expandedChange": "expandedChange"; "collapsibleChange": "collapsibleChange"; "visibleWhenCollapsedChange": "visibleWhenCollapsedChange"; "columnChange": "columnChange"; "widthChange": "widthChange"; "pinnedChange": "pinnedChange"; }, ["filterCellTemplateDirective", "summaryTemplateDirective", "cellTemplate", "cellValidationErrorTemplate", "editorTemplate", "collapseIndicatorTemplate", "headTemplate"], never, true, never>;
    static ngAcceptInputType_sortable: unknown;
    static ngAcceptInputType_groupable: unknown;
    static ngAcceptInputType_editable: unknown;
    static ngAcceptInputType_filterable: unknown;
    static ngAcceptInputType_resizable: unknown;
    static ngAcceptInputType_autosizeHeader: unknown;
    static ngAcceptInputType_hasSummary: unknown;
    static ngAcceptInputType_hidden: unknown;
    static ngAcceptInputType_disableHiding: unknown;
    static ngAcceptInputType_disablePinning: unknown;
    static ngAcceptInputType_filteringIgnoreCase: unknown;
    static ngAcceptInputType_sortingIgnoreCase: unknown;
    static ngAcceptInputType_searchable: unknown;
    static ngAcceptInputType_pinned: unknown;
    static ngAcceptInputType_visibleWhenCollapsed: unknown;
}

/**
 * **Ignite UI for Angular Column Group**
 *
 * @igxParent IgxGridComponent, IgxTreeGridComponent, IgxHierarchicalGridComponent, IgxColumnGroupComponent, IgxRowIslandComponent
 */
declare class IgxColumnGroupComponent extends IgxColumnComponent implements AfterContentInit {
    /**
     * @deprecated in version 18.1.0. Use the `childColumns` property instead.
     */
    children: QueryList<IgxColumnComponent>;
    /**
     * Set if the column group is collapsible.
     * Default value is `false`
     * ```html
     *  <igx-column-group [collapsible] = "true"></igx-column-group>
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    set collapsible(value: boolean);
    get collapsible(): boolean;
    /**
     * Set whether the group is expanded or collapsed initially.
     * Applied only if the collapsible property is set to `true`
     * Default value is `true`
     * ```html
     *  const state = false
     *  <igx-column-group [(expand)] = "state"></igx-column-group>
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    set expanded(value: boolean);
    get expanded(): boolean;
    /**
     * Gets the column group `summaries`.
     * ```typescript
     * let columnGroupSummaries = this.columnGroup.summaries;
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    get summaries(): any;
    /**
     * Sets the column group `summaries`.
     * ```typescript
     * this.columnGroup.summaries = IgxNumberSummaryOperand;
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    set summaries(classRef: any);
    /**
     * Sets/gets whether the column group is `searchable`.
     * Default value is `true`.
     * ```typescript
     * let isSearchable =  this.columnGroup.searchable;
     * ```
     * ```html
     *  <igx-column-group [searchable] = "false"></igx-column-group>
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    searchable: boolean;
    /**
     * Gets the column group `filters`.
     * ```typescript
     * let columnGroupFilters = this.columnGroup.filters;
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    get filters(): any;
    /**
     * Sets the column group `filters`.
     * ```typescript
     * this.columnGroup.filters = IgxStringFilteringOperand;
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    set filters(classRef: any);
    /**
     * Returns if the column group is selectable
     * ```typescript
     * let columnGroupSelectable = this.columnGroup.selectable;
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    get selectable(): boolean;
    /**
     * @hidden
     */
    set selectable(value: boolean);
    /**
     * @hidden
     */
    get bodyTemplate(): TemplateRef<any>;
    /**
     * @hidden
     */
    set bodyTemplate(template: TemplateRef<any>);
    /**
     * Allows you to define a custom template for expand/collapse indicator
     *
     * @memberof IgxColumnGroupComponent
     */
    collapsibleIndicatorTemplate: TemplateRef<IgxColumnTemplateContext>;
    /**
     * @hidden
     */
    get inlineEditorTemplate(): TemplateRef<any>;
    /**
     * @hidden
     */
    set inlineEditorTemplate(template: TemplateRef<any>);
    /**
     * @hidden @internal
     */
    get cells(): CellType[];
    /**
     * Gets whether the column group is hidden.
     * ```typescript
     * let isHidden = this.columnGroup.hidden;
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    get hidden(): boolean;
    /**
     * Sets the column group hidden property.
     * ```html
     * <igx-column [hidden] = "true"></igx-column>
     * ```
     *
     * Two-way data binding
     * ```html
     * <igx-column [(hidden)] = "model.columns[0].isHidden"></igx-column>
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    set hidden(value: boolean);
    /**
     * Returns if the column group is selected.
     * ```typescript
     * let isSelected = this.columnGroup.selected;
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    get selected(): boolean;
    /**
     * Select/deselect the column group.
     * ```typescript
     * this.columnGroup.selected = true;
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    set selected(value: boolean);
    /**
     * @hidden
     */
    ngAfterContentInit(): void;
    /**
     * A list containing all the child columns under this column (if any).
     * Empty without children or if this column is not Group or Layout.
     */
    get childColumns(): ColumnType[];
    /** @hidden @internal **/
    get allChildren(): IgxColumnComponent[];
    /**
     * Returns a boolean indicating if the column is a `ColumnGroup`.
     * ```typescript
     * let isColumnGroup =  this.columnGroup.columnGroup
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    get columnGroup(): boolean;
    /**
     * Returns a boolean indicating if the column is a `ColumnLayout` for multi-row layout.
     * ```typescript
     * let columnGroup =  this.column.columnGroup;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get columnLayout(): boolean;
    /**
     * Gets the width of the column group.
     * ```typescript
     * let columnGroupWidth = this.columnGroup.width;
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    get width(): string;
    set width(val: string);
    /** @hidden @internal **/
    get resolvedWidth(): string;
    /**
     * @hidden
     */
    get applySelectableClass(): boolean;
    /**
     * @hidden
     */
    set applySelectableClass(value: boolean);
    /**
     * @hidden
     * Calculates the number of visible columns, based on indexes of first and last visible columns.
     */
    calcChildren(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxColumnGroupComponent, "igx-column-group", never, { "collapsible": { "alias": "collapsible"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "summaries": { "alias": "summaries"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "collapsibleIndicatorTemplate": { "alias": "collapsibleIndicatorTemplate"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; }, {}, ["children"], ["igx-column,igc-column,igx-column-group,igc-column-group"], true, never>;
    static ngAcceptInputType_collapsible: unknown;
    static ngAcceptInputType_expanded: unknown;
    static ngAcceptInputType_searchable: unknown;
    static ngAcceptInputType_hidden: unknown;
}

/**
 * Column layout for declaration of Multi-row Layout
 *
 * @igxParent IgxGridComponent
 */
declare class IgxColumnLayoutComponent extends IgxColumnGroupComponent implements AfterContentInit {
    /** @hidden @internal **/
    childrenVisibleIndexes: any[];
    /**
     * Gets the width of the column layout.
     * ```typescript
     * let columnGroupWidth = this.columnGroup.width;
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    get width(): any;
    set width(val: any);
    get columnLayout(): boolean;
    /**
     * @hidden
     */
    getCalcWidth(): any;
    /**
     * Gets the column visible index.
     * If the column is not visible, returns `-1`.
     * ```typescript
     * let visibleColumnIndex =  this.column.visibleIndex;
     * ```
     *
     * @memberof IgxColumnComponent
     */
    get visibleIndex(): number;
    get hidden(): boolean;
    /**
     * Sets the column layout hidden property.
     * ```typescript
     * <igx-column-layout [hidden] = "true"></igx-column->
     * ```
     *
     * @memberof IgxColumnGroupComponent
     */
    set hidden(value: boolean);
    /**
     * @hidden
     */
    ngAfterContentInit(): void;
    /** @hidden @internal **/
    get hasLastPinnedChildColumn(): boolean;
    /** @hidden @internal **/
    get hasFirstPinnedChildColumn(): boolean;
    /**
     * @hidden
     */
    populateVisibleIndexes(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxColumnLayoutComponent, "igx-column-layout", never, { "hidden": { "alias": "hidden"; "required": false; }; }, {}, never, ["igx-column,igc-column"], true, never>;
    static ngAcceptInputType_hidden: unknown;
}

declare const IGX_GRID_VALIDATION_DIRECTIVES: readonly [typeof IgxColumnRequiredValidatorDirective, typeof IgxColumnMinValidatorDirective, typeof IgxColumnMaxValidatorDirective, typeof IgxColumnEmailValidatorDirective, typeof IgxColumnMinLengthValidatorDirective, typeof IgxColumnMaxLengthValidatorDirective, typeof IgxColumnPatternValidatorDirective];

interface ColumnGroupsCache {
    level: number;
    visibleIndex: number;
}
interface IActiveNode {
    gridID?: string;
    row: number;
    column?: number;
    level?: number;
    mchCache?: ColumnGroupsCache;
    layout?: IMultiRowLayoutNode;
}
/** @hidden */
declare class IgxGridNavigationService {
    protected platform: PlatformUtil;
    grid: GridType;
    _activeNode: IActiveNode;
    lastActiveNode: IActiveNode;
    protected pendingNavigation: boolean;
    protected keydownNotify: Subject<KeyboardEvent>;
    get activeNode(): IActiveNode;
    set activeNode(value: IActiveNode);
    constructor();
    handleNavigation(event: KeyboardEvent): void;
    dispatchEvent(event: KeyboardEvent): void;
    summaryNav(event: KeyboardEvent): void;
    headerNavigation(event: KeyboardEvent): void;
    focusTbody(event: any): void;
    focusFirstCell(header?: boolean): void;
    isColumnFullyVisible(columnIndex: number): boolean;
    shouldPerformHorizontalScroll(visibleColIndex: number, rowIndex?: number): boolean;
    shouldPerformVerticalScroll(targetRowIndex: number, _visibleColIndex: number): boolean;
    performVerticalScrollToCell(rowIndex: number, visibleColIndex?: number, cb?: () => void): void;
    performHorizontalScrollToCell(visibleColumnIndex: number, cb?: () => void): void;
    isDataRow(rowIndex: number, includeSummary?: boolean): boolean;
    isGroupRow(rowIndex: number): boolean;
    setActiveNode(activeNode: IActiveNode): void;
    isActiveNodeChanged(activeNode: IActiveNode): boolean;
    /** Focus the Grid section (header, body, footer) depending on the current activeNode */
    restoreActiveNodeFocus(): void;
    protected getNextPosition(rowIndex: number, colIndex: number, key: string, shift: boolean, ctrl: boolean, event: KeyboardEvent): {
        rowIndex: number;
        colIndex: number;
    };
    protected horizontalNav(event: KeyboardEvent, key: string, rowIndex: number, tag: GridKeydownTargetType): void;
    get lastColumnIndex(): number;
    get displayContainerWidth(): number;
    get displayContainerScrollLeft(): number;
    get containerTopOffset(): number;
    protected getColumnUnpinnedIndex(visibleColumnIndex: number): number;
    protected forOfDir(): IgxForOfDirective<any>;
    protected handleAlt(key: string, event: KeyboardEvent): void;
    protected handleEditing(shift: boolean, event: KeyboardEvent): void;
    protected navigateInBody(rowIndex: any, visibleColIndex: any, cb?: (arg: any) => void): void;
    protected emitKeyDown(type: GridKeydownTargetType, rowIndex: any, event: any): true;
    protected isColumnPinned(columnIndex: number, forOfDir: IgxForOfDirective<any>): boolean;
    protected findFirstDataRowIndex(): number;
    protected findLastDataRowIndex(): number;
    protected getRowElementByIndex(index: any): any;
    protected isValidPosition(rowIndex: number, colIndex: number): boolean;
    protected performHeaderKeyCombination(column: any, key: any, shift: any, ctrl: any, alt: any, event: any): void;
    private firstVisibleNode;
    private handleMCHeaderNav;
    private handleMCHExpandCollapse;
    private handleColumnSelection;
    private getNextColumnMCH;
    private get currentActiveColumn();
    private isActiveNode;
    private isToggleKey;
    private isAddKey;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridNavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxGridNavigationService>;
}

/**
 * A component used for presenting advanced filtering UI for a Grid.
 * It is used internally in the Grid, but could also be hosted in a container outside of it.
 *
 * Example:
 * ```html
 * <igx-advanced-filtering-dialog
 *     [grid]="grid1">
 * </igx-advanced-filtering-dialog>
 * ```
 */
declare class IgxAdvancedFilteringDialogComponent implements AfterViewInit, OnDestroy {
    cdr: ChangeDetectorRef;
    protected platform: PlatformUtil;
    /**
     * @hidden @internal
     */
    queryBuilder: IgxQueryBuilderComponent;
    /**
     * @hidden @internal
     */
    display: string;
    /**
     * @hidden @internal
     */
    inline: boolean;
    /**
     * @hidden @internal
     */
    lastActiveNode: IActiveNode;
    private destroy$;
    private _overlayComponentId;
    private _overlayService;
    private _grid;
    /**
     * @hidden @internal
     */
    ngAfterViewInit(): void;
    /**
     * @hidden @internal
     */
    ngOnDestroy(): void;
    /**
     * Assigns the grid instance corresponding to the advanced filtering dialog instance.
     */
    set grid(grid: GridType);
    /**
     * Returns the grid.
     */
    get grid(): GridType;
    /**
     * @hidden @internal
     */
    get filterableFields(): FieldType[];
    /**
     * @hidden @internal
     */
    dragStart(dragArgs: IDragStartEventArgs): void;
    /**
     * @hidden @internal
     */
    onDragMove(e: any): void;
    /**
     * @hidden @internal
     */
    onKeyDown(eventArgs: KeyboardEvent): void;
    /**
     * @hidden @internal
     */
    initialize(grid: GridType, overlayService: IgxOverlayService, overlayComponentId: string): void;
    /**
     * @hidden @internal
     */
    onClearButtonClick(event?: Event): void;
    /**
     * @hidden @internal
     */
    closeDialog(): void;
    /**
     * @hidden @internal
     */
    applyChanges(event?: Event): void;
    /**
     * @hidden @internal
     */
    cancelChanges(): void;
    /**
     * @hidden @internal
     */
    onApplyButtonClick(event?: Event): void;
    /**
     * @hidden @internal
     */
    generateEntity(): any;
    private assignResourceStrings;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxAdvancedFilteringDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxAdvancedFilteringDialogComponent, "igx-advanced-filtering-dialog", never, { "grid": { "alias": "grid"; "required": false; }; }, {}, never, never, true, never>;
}

declare abstract class BaseFilteringComponent {
    protected cdr: ChangeDetectorRef;
    element: ElementRef<any>;
    protected platform: PlatformUtil;
    abstract column: any;
    abstract get grid(): any;
    abstract overlayComponentId: string;
    abstract mainDropdown: ElementRef<HTMLElement>;
    abstract expressionsList: ExpressionUI[];
    abstract listData: FilterListItem[];
    abstract isHierarchical: boolean;
    abstract loadingStart: EventEmitter<undefined>;
    abstract loadingEnd: EventEmitter<undefined>;
    abstract initialized: EventEmitter<undefined>;
    abstract columnChange: EventEmitter<any>;
    abstract sortingChanged: EventEmitter<undefined>;
    abstract listDataLoaded: EventEmitter<undefined>;
    abstract filterCleared: EventEmitter<undefined>;
    abstract initialize(column: any, overlayService: IgxOverlayService): void;
    abstract detectChanges(): void;
    abstract hide(): void;
    abstract closeDropdown(): void;
    abstract onSelect(): void;
    abstract onPin(): void;
    abstract onHideToggle(): void;
    abstract cancel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFilteringComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseFilteringComponent, never, never, {}, {}, never, never, true, never>;
}

/**
 * A component used for presenting Excel style clear filters UI.
 */
declare class IgxExcelStyleClearFiltersComponent {
    esf: BaseFilteringComponent;
    protected platform: PlatformUtil;
    /**
     * @hidden @internal
     */
    clearFilterClass(): "igx-excel-filter__actions-clear" | "igx-excel-filter__actions-clear--disabled";
    /**
     * @hidden @internal
     */
    clearFilter(): void;
    /**
     * @hidden @internal
     */
    onClearFilterKeyDown(eventArgs: KeyboardEvent): void;
    private selectAllFilterItems;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleClearFiltersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleClearFiltersComponent, "igx-excel-style-clear-filters", never, {}, {}, never, never, true, never>;
}

/**
 * @hidden
 */
interface ILogicOperatorChangedArgs extends IBaseEventArgs {
    target: ExpressionUI;
    newValue: FilteringLogic;
}
/**
 * @hidden
 */
declare class IgxExcelStyleDefaultExpressionComponent implements AfterViewInit {
    cdr: ChangeDetectorRef;
    protected platform: PlatformUtil;
    column: ColumnType;
    expressionUI: ExpressionUI;
    expressionsList: Array<ExpressionUI>;
    grid: any;
    expressionRemoved: EventEmitter<ExpressionUI>;
    logicOperatorChanged: EventEmitter<ILogicOperatorChangedArgs>;
    overlayOutlet: IgxOverlayOutletDirective;
    protected dropdownConditions: IgxSelectComponent;
    protected logicOperatorButtonGroup: IgxButtonGroupComponent;
    protected inputValuesDirective: IgxInputDirective;
    dropDownOverlaySettings: OverlaySettings;
    get isLast(): boolean;
    get isSingle(): boolean;
    get conditionsPlaceholder(): string;
    get inputValuePlaceholder(): string;
    get type(): "number" | "text";
    get conditions(): string[];
    protected get inputValuesElement(): HTMLInputElement;
    ngAfterViewInit(): void;
    focus(): void;
    translateCondition(value: string): string;
    getIconName(): string;
    isConditionSelected(conditionName: string): boolean;
    onConditionsChanged(eventArgs: any): void;
    getCondition(value: string): IFilteringOperation;
    getConditionFriendlyName(name: string): string;
    updateSearchValueOnBlur(eventArgs: any): void;
    onLogicOperatorButtonClicked(eventArgs: any, buttonIndex: number): void;
    onLogicOperatorKeyDown(eventArgs: KeyboardEvent, buttonIndex: number): void;
    onRemoveButtonClick(): void;
    onOutletPointerDown(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleDefaultExpressionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleDefaultExpressionComponent, "igx-excel-style-default-expression", never, { "column": { "alias": "column"; "required": false; }; "expressionUI": { "alias": "expressionUI"; "required": false; }; "expressionsList": { "alias": "expressionsList"; "required": false; }; "grid": { "alias": "grid"; "required": false; }; }, { "expressionRemoved": "expressionRemoved"; "logicOperatorChanged": "logicOperatorChanged"; }, never, never, true, never>;
}

/**
 * @hidden
 */
declare class IgxExcelStyleCustomDialogComponent implements AfterViewInit {
    protected overlayService: IgxOverlayService;
    private cdr;
    protected platform: PlatformUtil;
    esf: BaseFilteringComponent;
    expressionsList: ExpressionUI[];
    column: ColumnType;
    selectedOperator: string;
    filteringService: IgxFilteringService;
    overlayComponentId: string;
    toggle: IgxToggleDirective;
    protected defaultExpressionTemplate: TemplateRef<any>;
    protected dateExpressionTemplate: TemplateRef<any>;
    protected expressionsContainer: ElementRef;
    private expressionComponents;
    private expressionDateComponents;
    private _customDialogPositionSettings;
    private _customDialogOverlaySettings;
    ngAfterViewInit(): void;
    get template(): TemplateRef<any>;
    get grid(): any;
    onCustomDialogOpening(): void;
    onCustomDialogOpened(): void;
    open(esf: any): void;
    onClearButtonClick(): void;
    closeDialog(): void;
    cancelDialog(): void;
    onApplyButtonClick(): void;
    onAddButtonClick(): void;
    onExpressionRemoved(event: ExpressionUI): void;
    onLogicOperatorChanged(event: ILogicOperatorChangedArgs): void;
    onKeyDown(eventArgs: KeyboardEvent): void;
    onApplyButtonKeyDown(eventArgs: KeyboardEvent): void;
    private createCondition;
    private markChildrenForCheck;
    private createInitialExpressionUIElement;
    private scrollToBottom;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleCustomDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleCustomDialogComponent, "igx-excel-style-custom-dialog", never, { "expressionsList": { "alias": "expressionsList"; "required": false; }; "column": { "alias": "column"; "required": false; }; "selectedOperator": { "alias": "selectedOperator"; "required": false; }; "filteringService": { "alias": "filteringService"; "required": false; }; "overlayComponentId": { "alias": "overlayComponentId"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * A component used for presenting Excel style conditional filter UI.
 */
declare class IgxExcelStyleConditionalFilterComponent implements OnDestroy {
    esf: BaseFilteringComponent;
    protected platform: PlatformUtil;
    /**
     * @hidden @internal
     */
    customDialog: IgxExcelStyleCustomDialogComponent;
    /**
     * @hidden @internal
     */
    subMenu: IgxDropDownComponent;
    protected get filterNumber(): number;
    private shouldOpenSubMenu;
    private destroy$;
    private _subMenuPositionSettings;
    private _subMenuOverlaySettings;
    constructor();
    ngOnDestroy(): void;
    /**
     * @hidden @internal
     */
    onTextFilterKeyDown(eventArgs: KeyboardEvent): void;
    /**
     * @hidden @internal
     */
    onTextFilterClick(eventArgs: any): void;
    /**
     * @hidden @internal
     */
    getCondition(value: string): IFilteringOperation;
    protected getSelectedCondition(condition: string): boolean;
    /**
     * @hidden @internal
     */
    translateCondition(value: string): string;
    /**
     * @hidden @internal
     */
    onSubMenuSelection(eventArgs: ISelectionEventArgs): void;
    /**
     * @hidden @internal
     */
    onSubMenuClosed(): void;
    /**
     * @hidden @internal
     */
    showCustomFilterItem(): boolean;
    /**
     * @hidden @internal
     */
    get subMenuText(): any;
    /**
     * @hidden @internal
     */
    get conditions(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleConditionalFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleConditionalFilterComponent, "igx-excel-style-conditional-filter", never, {}, {}, never, never, true, never>;
}

/**
 * A component used for presenting Excel style header UI.
 */
declare class IgxExcelStyleHeaderComponent {
    esf: BaseFilteringComponent;
    /**
     * Sets whether the column pinning icon should be shown in the header.
     * Default value is `false`.
     *
     * @example
     * ```html
     * <igx-excel-style-header [showPinning]="true"></igx-excel-style-header>
     * ```
     */
    showPinning: boolean;
    /**
     * Sets whether the column selecting icon should be shown in the header.
     * Default value is `false`.
     *
     * @example
     * ```html
     * <igx-excel-style-header [showSelecting]="true"></igx-excel-style-header>
     * ```
     */
    showSelecting: boolean;
    /**
     * Sets whether the column hiding icon should be shown in the header.
     * Default value is `false`.
     *
     * @example
     * ```html
     * <igx-excel-style-header [showHiding]="true"></igx-excel-style-header>
     * ```
     */
    showHiding: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleHeaderComponent, "igx-excel-style-header", never, { "showPinning": { "alias": "showPinning"; "required": false; }; "showSelecting": { "alias": "showSelecting"; "required": false; }; "showHiding": { "alias": "showHiding"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_showPinning: unknown;
    static ngAcceptInputType_showSelecting: unknown;
    static ngAcceptInputType_showHiding: unknown;
}

/**
 * A component used for presenting Excel style column hiding UI.
 */
declare class IgxExcelStyleHidingComponent {
    esf: BaseFilteringComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleHidingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleHidingComponent, "igx-excel-style-hiding", never, {}, {}, never, never, true, never>;
}

/**
 * A component used for presenting Excel style column moving UI.
 */
declare class IgxExcelStyleMovingComponent {
    esf: BaseFilteringComponent;
    /**
     * @hidden @internal
     */
    defaultClass: boolean;
    private get visibleColumns();
    /**
     * @hidden @internal
     */
    get canNotMoveLeft(): any;
    /**
     * @hidden @internal
     */
    get canNotMoveRight(): boolean;
    /**
     * @hidden @internal
     */
    onMoveButtonClicked(moveDirection: any): void;
    protected get esfSize(): string;
    private findColumn;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleMovingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleMovingComponent, "igx-excel-style-moving", never, {}, {}, never, never, true, never>;
}

/**
 * A component used for presenting Excel style column pinning UI.
 */
declare class IgxExcelStylePinningComponent {
    esf: BaseFilteringComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStylePinningComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStylePinningComponent, "igx-excel-style-pinning", never, {}, {}, never, never, true, never>;
}

declare class IgxExcelStyleLoadingValuesTemplateDirective {
    template: TemplateRef<undefined>;
    static ngTemplateContextGuard(_dir: IgxExcelStyleLoadingValuesTemplateDirective, ctx: unknown): ctx is undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleLoadingValuesTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxExcelStyleLoadingValuesTemplateDirective, "[igxExcelStyleLoading]", never, {}, {}, never, never, true, never>;
}
/**
 * A component used for presenting Excel style search UI.
 */
declare class IgxExcelStyleSearchComponent implements AfterViewInit, OnDestroy {
    cdr: ChangeDetectorRef;
    esf: BaseFilteringComponent;
    protected platform: PlatformUtil;
    private static readonly filterOptimizationThreshold;
    /**
     * @hidden @internal
     */
    defaultClass: boolean;
    /**
     * @hidden @internal
     */
    searchInput: IgxInputDirective;
    protected cancelButton: IgxButtonDirective;
    /**
     * @hidden @internal
     */
    list: IgxListComponent;
    /**
     * @hidden @internal
     */
    selectAllCheckbox: IgxCheckboxComponent;
    /**
     * @hidden @internal
     */
    addToCurrentFilterCheckbox: IgxCheckboxComponent;
    /**
     * @hidden @internal
     */
    tree: IgxTreeComponent;
    /**
     * @hidden @internal
     */
    protected virtDir: IgxForOfDirective<any>;
    /**
     * @hidden @internal
     */
    protected defaultExcelStyleLoadingValuesTemplate: TemplateRef<any>;
    /**
     * @hidden @internal
     */
    get selectAllItem(): FilterListItem;
    /**
     * @hidden @internal
     */
    get addToCurrentFilterItem(): FilterListItem;
    /**
     * @hidden @internal
     */
    get isLoading(): boolean;
    /**
     * @hidden @internal
     */
    set isLoading(value: boolean);
    /**
     * @hidden @internal
     */
    searchValue: any;
    /**
     * @hidden @internal
     */
    displayedListData: FilterListItem[];
    /**
     * @hidden @internal
     */
    matchesCount: number;
    /**
     * @hidden @internal
     */
    get valuesLoadingTemplate(): any;
    protected activeDescendant: string;
    private _id;
    private _isLoading;
    private _addToCurrentFilterItem;
    private _selectAllItem;
    private _hierarchicalSelectedItems;
    private _focusedItem;
    private destroy$;
    constructor();
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * @hidden @internal
     */
    refreshSize: () => void;
    /**
     * @hidden @internal
     */
    clearInput(): void;
    /**
     * @hidden @internal
     */
    onCheckboxChange(eventArgs: IChangeCheckboxEventArgs): void;
    /**
     * @hidden @internal
     */
    onSelectAllCheckboxChange(eventArgs: IChangeCheckboxEventArgs): void;
    /**
     * @hidden @internal
     */
    onNodeSelectionChange(eventArgs: ITreeNodeSelectionEvent): void;
    /**
     * @hidden @internal
     */
    get itemSize(): string;
    /**
     * @hidden @internal
     */
    get containerSize(): any;
    protected get id(): string;
    protected set id(value: string);
    protected getItemId(index: number): string;
    protected setActiveDescendant(): void;
    protected get focusedItem(): ActiveElement;
    protected set focusedItem(val: ActiveElement);
    /**
     * @hidden @internal
     */
    get applyButtonDisabled(): boolean;
    /**
     * @hidden @internal
     */
    onInputKeyDown(event: KeyboardEvent): void;
    /**
     * @hidden @internal
     */
    filterListData(): void;
    /**
     * @hidden @internal
     */
    applyFilter(): void;
    protected handleKeyDown(event: KeyboardEvent): void;
    protected onFocus(): void;
    protected onFocusOut(): void;
    /**
     * @hidden @internal
     */
    isHierarchical(): boolean;
    /**
     * @hidden @internal
     */
    isTreeEmpty(): boolean;
    private hierarchicalSelectMatches;
    private hierarchicalSelectAllChildren;
    private expandAllParentNodes;
    private addFilteredToSelectedItems;
    private createCondition;
    /**
     * @hidden @internal
     */
    private rejectNonNumericalEntries;
    private onArrowUpKeyDown;
    private onArrowDownKeyDown;
    private onHomeKeyDown;
    private onEndKeyDown;
    private onActionKeyDown;
    private navigateItem;
    private isIndexOutOfBounds;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleSearchComponent, "igx-excel-style-search", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * A component used for presenting Excel style conditional filter UI.
 */
declare class IgxExcelStyleSelectingComponent {
    esf: BaseFilteringComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleSelectingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleSelectingComponent, "igx-excel-style-selecting", never, {}, {}, never, never, true, never>;
}

/**
 * A component used for presenting Excel style column sorting UI.
 */
declare class IgxExcelStyleSortingComponent implements OnDestroy {
    esf: BaseFilteringComponent;
    private cdr;
    /**
     * @hidden @internal
     */
    defaultClass: boolean;
    /**
     * @hidden @internal
     */
    sortButtonGroup: IgxButtonGroupComponent;
    private destroy$;
    constructor();
    ngOnDestroy(): void;
    /**
     * @hidden @internal
     */
    onSortButtonClicked(sortDirection: any): void;
    protected get esfSize(): string;
    private updateSelectedButtons;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleSortingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleSortingComponent, "igx-excel-style-sorting", never, {}, {}, never, never, true, never>;
}

declare class IgxExcelStyleColumnOperationsTemplateDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleColumnOperationsTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxExcelStyleColumnOperationsTemplateDirective, "igx-excel-style-column-operations,[igxExcelStyleColumnOperations]", never, {}, {}, never, never, true, never>;
}
declare class IgxExcelStyleFilterOperationsTemplateDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleFilterOperationsTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxExcelStyleFilterOperationsTemplateDirective, "igx-excel-style-filter-operations,[igxExcelStyleFilterOperations]", never, {}, {}, never, never, true, never>;
}
/**
 * A component used for presenting Excel style filtering UI for a specific column.
 * It is used internally in the Grid, but could also be hosted in a container outside of it.
 *
 * Example:
 * ```html
 * <igx-grid-excel-style-filtering
 *     [column]="grid1.columns[0]">
 * </igx-grid-excel-style-filtering>
 * ```
 */
declare class IgxGridExcelStyleFilteringComponent extends BaseFilteringComponent implements AfterViewInit, OnDestroy {
    private document;
    protected gridAPI?: GridType;
    /**
     * @hidden @internal
     */
    defaultClass: boolean;
    protected get shouldApplySizes(): boolean;
    /**
     * @hidden @internal
     */
    inline: boolean;
    /**
     * @hidden @internal
     */
    loadingStart: EventEmitter<any>;
    /**
     * @hidden @internal
     */
    loadingEnd: EventEmitter<any>;
    /**
     * @hidden @internal
     */
    initialized: EventEmitter<any>;
    /**
     * @hidden @internal
     */
    sortingChanged: EventEmitter<any>;
    /**
     * @hidden @internal
     */
    columnChange: EventEmitter<ColumnType>;
    /**
     * @hidden @internal
     */
    listDataLoaded: EventEmitter<any>;
    /**
     * @hidden @internal
     */
    filterCleared: EventEmitter<any>;
    mainDropdown: ElementRef<HTMLElement>;
    /**
     * @hidden @internal
     */
    excelColumnOperationsDirective: IgxExcelStyleColumnOperationsTemplateDirective;
    /**
     * @hidden @internal
     */
    excelFilterOperationsDirective: IgxExcelStyleFilterOperationsTemplateDirective;
    /**
     * @hidden @internal
     */
    protected defaultExcelColumnOperations: TemplateRef<any>;
    /**
     * @hidden @internal
     */
    protected defaultExcelFilterOperations: TemplateRef<any>;
    /**
     * Sets the column.
     */
    set column(value: ColumnType);
    /**
     * Returns the current column.
     */
    get column(): ColumnType;
    /**
     * @hidden @internal
     */
    expressionsList: ExpressionUI[];
    /**
     * @hidden @internal
     */
    listData: FilterListItem[];
    /**
     * @hidden @internal
     */
    uniqueValues: IgxFilterItem[];
    /**
     * @hidden @internal
     */
    overlayService: IgxOverlayService;
    /**
     * @hidden @internal
     */
    overlayComponentId: string;
    /**
     * @hidden @internal
     */
    isHierarchical: boolean;
    private _minHeight;
    /**
     * Gets the minimum height.
     *
     * Setting value in template:
     * ```ts
     * [minHeight]="'<number><unit (px|rem|etc..)>'"
     * ```
     *
     * Example for setting a value:
     * ```ts
     * [minHeight]="'700px'"
     * ```
     */
    get minHeight(): string;
    /**
     * Sets the minimum height.
     */
    set minHeight(value: string);
    private _maxHeight;
    private containsNullOrEmpty;
    private selectAllSelected;
    private selectAllIndeterminate;
    private filterValues;
    private _column;
    private subscriptions;
    private _originalDisplay;
    /**
     * Gets the maximum height.
     *
     * Setting value in template:
     * ```ts
     * [maxHeight]="'<number><unit (px|rem|etc..)>'"
     * ```
     *
     * Example for setting a value:
     * ```ts
     * [maxHeight]="'700px'"
     * ```
     */
    get maxHeight(): string;
    /**
     * Sets the maximum height.
     */
    set maxHeight(value: string);
    /**
     * @hidden @internal
     */
    get grid(): GridTypeBase;
    /**
     * @hidden @internal
     */
    ngOnDestroy(): void;
    /**
     * @hidden @internal
     */
    ngAfterViewInit(): void;
    /**
     * @hidden @internal
     */
    initialize(column: ColumnType, overlayService: IgxOverlayService): void;
    /**
     * @hidden @internal
     */
    populateData(): void;
    /**
     * @hidden @internal
     */
    onPin(): void;
    /**
     * @hidden @internal
     */
    onSelect(): void;
    /**
     * @hidden @internal
     */
    columnSelectable(): boolean;
    /**
     * @hidden @internal
     */
    onHideToggle(): void;
    /**
     * @hidden @internal
     */
    cancel(): void;
    /**
     * @hidden @internal
     */
    closeDropdown(): void;
    /**
     * @hidden @internal
     */
    onKeyDown(eventArgs: KeyboardEvent): void;
    /**
     * @hidden @internal
     */
    hide(): void;
    /**
     * @hidden @internal
     */
    detectChanges(): void;
    protected computedStyles: any;
    protected get size(): string;
    protected afterColumnChange(): void;
    private init;
    private areExpressionsSelectable;
    private populateColumnData;
    private renderColumnValuesRemotely;
    private renderColumnValuesFromData;
    private renderValues;
    private generateFilterValues;
    private generateListData;
    private getColumnFilterExpressionsTree;
    private addBooleanItems;
    private addItems;
    private generateFilterListItems;
    private addSelectAllItem;
    private generateBlanksItem;
    private getFilterItemLabel;
    private getExpressionValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridExcelStyleFilteringComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridExcelStyleFilteringComponent, "igx-grid-excel-style-filtering", never, { "column": { "alias": "column"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, { "loadingStart": "loadingStart"; "loadingEnd": "loadingEnd"; "initialized": "initialized"; "sortingChanged": "sortingChanged"; "columnChange": "columnChange"; "listDataLoaded": "listDataLoaded"; "filterCleared": "filterCleared"; }, ["excelColumnOperationsDirective", "excelFilterOperationsDirective"], ["igx-excel-style-column-operations,[igxExcelStyleColumnOperations]", "igx-excel-style-filter-operations,[igxExcelStyleFilterOperations]"], true, never>;
}

/**
 * @hidden
 */
declare class IgxExcelStyleDateExpressionComponent extends IgxExcelStyleDefaultExpressionComponent {
    private input;
    private picker;
    get searchVal(): any;
    set searchVal(value: any);
    protected get inputValuesElement(): HTMLInputElement;
    get inputDatePlaceholder(): string;
    get inputTimePlaceholder(): string;
    get weekStart(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleDateExpressionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxExcelStyleDateExpressionComponent, "igx-excel-style-date-expression", never, { "searchVal": { "alias": "searchVal"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IgxGridActionButtonComponent {
    container: ElementRef;
    /**
     * Event emitted when action button is clicked.
     *
     * @example
     * ```html
     *  <igx-grid-action-button (actionClick)="startEdit($event)"></igx-grid-action-button>
     * ```
     */
    actionClick: EventEmitter<Event>;
    /**
     * Reference to the current template.
     *
     * @hidden
     * @internal
     */
    templateRef: TemplateRef<any>;
    /**
     * Whether button action is rendered in menu and should container text label.
     */
    asMenuItem: boolean;
    /**
     * Name of the icon to display in the button.
     */
    iconName: string;
    /**
     * Additional Menu item container element classes.
     */
    classNames: string;
    /** @hidden @internal */
    get containerClass(): string;
    /**
     * The name of the icon set. Used in case the icon is from a different icon set.
     */
    iconSet: string;
    /**
     * The text of the label.
     */
    labelText: string;
    /**
     * @hidden
     * @internal
     */
    handleClick(event: any): void;
    /**
     * @hidden @internal
     */
    preventEvent(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridActionButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridActionButtonComponent, "igx-grid-action-button", never, { "asMenuItem": { "alias": "asMenuItem"; "required": false; }; "iconName": { "alias": "iconName"; "required": false; }; "classNames": { "alias": "classNames"; "required": false; }; "iconSet": { "alias": "iconSet"; "required": false; }; "labelText": { "alias": "labelText"; "required": false; }; }, { "actionClick": "actionClick"; }, never, never, true, never>;
    static ngAcceptInputType_asMenuItem: unknown;
}

declare class IgxGridSelectionService {
    private zone;
    protected platform: PlatformUtil;
    grid: GridType;
    dragMode: boolean;
    activeElement: ISelectionNode | null;
    keyboardState: ISelectionKeyboardState;
    pointerState: ISelectionPointerState;
    columnsState: IColumnSelectionState;
    selection: Map<number, Set<number>>;
    temp: Map<number, Set<number>>;
    rowSelection: Set<any>;
    indeterminateRows: Set<any>;
    columnSelection: Set<string>;
    /**
     * @hidden @internal
     */
    selectedRowsChange: Subject<any[]>;
    /**
     * @hidden @internal
     */
    selectedRangeChange: Subject<Map<number, Set<number>>>;
    /**
     * Toggled when a pointerdown event is triggered inside the grid body (cells).
     * When `false` the drag select behavior is disabled.
     */
    private pointerEventInGridBody;
    private allRowsSelected;
    private _lastSelectedNode;
    private _ranges;
    private _selectionRange;
    /**
     * Returns the current selected ranges in the grid from both
     * keyboard and pointer interactions
     */
    get ranges(): GridSelectionRange[];
    get primaryButton(): boolean;
    set primaryButton(value: boolean);
    constructor();
    /**
     * Resets the keyboard state
     */
    initKeyboardState(): void;
    /**
     * Resets the pointer state
     */
    initPointerState(): void;
    /**
     * Resets the columns state
     */
    initColumnsState(): void;
    /**
     * Adds a single node.
     * Single clicks | Ctrl + single clicks on cells is the usual case.
     */
    add(node: ISelectionNode, addToRange?: boolean): void;
    /**
     * Adds the active keyboard range selection (if any) to the `ranges` meta.
     */
    addKeyboardRange(): void;
    remove(node: ISelectionNode): void;
    isInMap(node: ISelectionNode): boolean;
    selected(node: ISelectionNode): boolean;
    isActiveNode(node: ISelectionNode): boolean;
    isActiveLayout(current: IMultiRowLayoutNode, target: IMultiRowLayoutNode): boolean;
    addRangeMeta(node: ISelectionNode, state?: SelectionState): void;
    removeRangeMeta(node: ISelectionNode, state?: SelectionState): void;
    /**
     * Generates a new selection range from the given `node`.
     * If `state` is passed instead it will generate the range based on the passed `node`
     * and the start node of the `state`.
     */
    generateRange(node: ISelectionNode, state?: SelectionState): GridSelectionRange;
    /**
     *
     */
    keyboardStateOnKeydown(node: ISelectionNode, shift: boolean, shiftTab: boolean): void;
    keyboardStateOnFocus(node: ISelectionNode, emitter: EventEmitter<GridSelectionRange>, dom: any): void;
    pointerDown(node: ISelectionNode, shift: boolean, ctrl: boolean): void;
    pointerDownShiftKey(node: ISelectionNode): void;
    mergeMap(target: Map<number, Set<number>>, source: Map<number, Set<number>>): void;
    pointerEnter(node: ISelectionNode, event: PointerEvent): boolean;
    pointerUp(node: ISelectionNode, emitter: EventEmitter<GridSelectionRange>, firedOutsideGrid?: boolean): boolean;
    selectRange(node: ISelectionNode, state: SelectionState, collection?: Map<number, Set<number>>): void;
    dragSelect(node: ISelectionNode, state: SelectionState): void;
    clear(clearAcriveEl?: boolean): void;
    clearTextSelection(): void;
    restoreTextSelection(): void;
    getSelectedRowsData(): any[];
    /** Returns array of the selected row id's. */
    getSelectedRows(): Array<any>;
    /** Returns array of the rows in indeterminate state. */
    getIndeterminateRows(): Array<any>;
    /** Clears row selection, if filtering is applied clears only selected rows from filtered data. */
    clearRowSelection(event?: any): void;
    /** Select all rows, if filtering is applied select only from filtered data. */
    selectAllRows(event?: any): void;
    /** Select the specified row and emit event. */
    selectRowById(rowID: any, clearPrevSelection?: any, event?: any): void;
    selectPivotRowById(rowID: any, clearPrevSelection: boolean, event?: any): void;
    /** Deselect the specified row and emit event. */
    deselectRow(rowID: any, event?: any): void;
    deselectPivotRowByID(rowID: any, event?: any): void;
    private emitRowSelectionEventPivotGrid;
    /** Select the specified rows and emit event. */
    selectRows(keys: any[], clearPrevSelection?: boolean, event?: any): void;
    deselectRows(keys: any[], event?: any): void;
    /** Select specified rows. No event is emitted. */
    selectRowsWithNoEvent(rowIDs: any[], clearPrevSelection?: any): void;
    /** Deselect specified rows. No event is emitted. */
    deselectRowsWithNoEvent(rowIDs: any[]): void;
    isRowSelected(rowID: any): boolean;
    isPivotRowSelected(rowID: any): boolean;
    isRowInIndeterminateState(rowID: any): boolean;
    /** Select range from last selected row to the current specified row. */
    selectMultipleRows(rowID: any, rowData: any, event?: any): void;
    areAllRowSelected(newSelection?: any): boolean;
    hasSomeRowSelected(): boolean;
    get filteredSelectedRowIds(): any[];
    emitRowSelectionEvent(newSelection: any, added: any, removed: any, event?: any, currSelection?: any): boolean;
    getPivotRowsByIds(ids: any[]): any[];
    getRowDataById(rowID: any): any;
    clearHeaderCBState(): void;
    getRowIDs(data: any): Array<any>;
    getRecordKey(record: any): any;
    /** Clear rowSelection and update checkbox state */
    clearAllSelectedRows(): void;
    /** Returns all data in the grid, with applied filtering and sorting and without deleted rows. */
    get allData(): Array<any>;
    /** Returns array of the selected columns fields. */
    getSelectedColumns(): Array<any>;
    isColumnSelected(field: string): boolean;
    /** Select the specified column and emit event. */
    selectColumn(field: string, clearPrevSelection?: any, selectColumnsRange?: any, event?: any): void;
    /** Select specified columns. And emit event. */
    selectColumns(fields: string[], clearPrevSelection?: any, selectColumnsRange?: any, event?: any): void;
    /** Select range from last clicked column to the current specified column. */
    selectColumnsRange(field: string, event: any): void;
    /** Select specified columns. No event is emitted. */
    selectColumnsWithNoEvent(fields: string[], clearPrevSelection?: any): void;
    /** Deselect the specified column and emit event. */
    deselectColumn(field: string, event?: any): void;
    /** Deselect specified columns. No event is emitted. */
    deselectColumnsWithNoEvent(fields: string[]): void;
    /** Deselect specified columns. And emit event. */
    deselectColumns(fields: string[], event?: any): void;
    emitColumnSelectionEvent(newSelection: any, added: any, removed: any, event?: any): boolean;
    /** Clear columnSelection */
    clearAllSelectedColumns(): void;
    protected areEqualCollections(first: any, second: any): boolean;
    /**
     * (╯°□°）╯︵ ┻━┻
     * Chrome and Chromium don't care about the active
     * range after keyboard navigation, thus this.
     */
    private _moveSelectionChrome;
    private isFilteringApplied;
    private isRowDeleted;
    private pointerOriginHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridSelectionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxGridSelectionService>;
}

declare class IgxRowDirective implements DoCheck, AfterViewInit, OnDestroy {
    grid: GridType;
    selectionService: IgxGridSelectionService;
    element: ElementRef<HTMLElement>;
    cdr: ChangeDetectorRef;
    /**
     * @hidden
     */
    addAnimationEnd: EventEmitter<IgxRowDirective>;
    /**
     * @hidden
     */
    role: string;
    /**
     * @hidden
     */
    metaData: any;
    /**
     *  The data passed to the row component.
     *
     * ```typescript
     * // get the row data for the first selected row
     * let selectedRowData = this.grid.selectedRows[0].data;
     * ```
     */
    get data(): any;
    set data(v: any);
    /**
     * The index of the row.
     *
     * ```typescript
     * // get the index of the second selected row
     * let selectedRowIndex = this.grid.selectedRows[1].index;
     * ```
     */
    index: number;
    /**
     * Sets whether this specific row has disabled functionality for editing and row selection.
     * Default value is `false`.
     * ```typescript
     * this.grid.selectedRows[0].pinned = true;
     * ```
     */
    disabled: boolean;
    /**
     * Sets whether the row is pinned.
     * Default value is `false`.
     * ```typescript
     * this.grid.selectedRows[0].pinned = true;
     * ```
     */
    set pinned(value: boolean);
    /**
     * Gets whether the row is pinned.
     * ```typescript
     * let isPinned = row.pinned;
     * ```
     */
    get pinned(): boolean;
    get hasMergedCells(): boolean;
    /**
     * Gets the expanded state of the row.
     * ```typescript
     * let isExpanded = row.expanded;
     * ```
     */
    get expanded(): boolean;
    /**
     * Expands/collapses the current row.
     *
     * ```typescript
     * this.grid.selectedRows[2].expanded = true;
     * ```
     */
    set expanded(val: boolean);
    get addRowUI(): any;
    get rowHeight(): number;
    /**
     * @hidden
     */
    gridID: string;
    /**
     * @hidden
     */
    _virtDirRow: QueryList<IgxGridForOfDirective<ColumnType, ColumnType[]>>;
    get virtDirRow(): IgxGridForOfDirective<ColumnType, ColumnType[]>;
    /**
     * @hidden
     */
    checkboxElement: IgxCheckboxComponent;
    protected _cells: QueryList<CellType>;
    /**
     * Gets the rendered cells in the row component.
     *
     * ```typescript
     * // get the cells of the third selected row
     * let selectedRowCells = this.grid.selectedRows[2].cells;
     * ```
     */
    get cells(): QueryList<CellType>;
    get dataRowIndex(): number;
    /**
     * @hidden
     */
    get selected(): boolean;
    set selected(value: boolean);
    /**
     * @hidden
     */
    get columns(): ColumnType[];
    /**
     * @hidden
     * @internal
     */
    get viewIndex(): number;
    /**
     * @hidden
     */
    get pinnedColumns(): ColumnType[];
    /**
     * @hidden
     */
    get pinnedStartColumns(): ColumnType[];
    /**
    * @hidden
    */
    get pinnedEndColumns(): ColumnType[];
    /**
     * @hidden
     */
    get isRoot(): boolean;
    /**
     * @hidden
     */
    get hasChildren(): boolean;
    /**
     * @hidden
     */
    get unpinnedColumns(): ColumnType[];
    /**
     * @hidden
     */
    get showRowSelectors(): boolean;
    /** @hidden */
    get dirty(): boolean;
    /**
     * @hidden
     */
    get rowDraggable(): boolean;
    /** @hidden */
    get added(): boolean;
    /** @hidden */
    get deleted(): boolean;
    /**
     * @hidden
     */
    get dragging(): boolean;
    get inEditMode(): boolean;
    /**
     * Gets the ID of the row.
     * A row in the grid is identified either by:
     * - primaryKey data value,
     * - the whole data, if the primaryKey is omitted.
     *
     * ```typescript
     * let rowID = this.grid.selectedRows[2].key;
     * ```
     */
    get key(): any;
    /**
     * The native DOM element representing the row. Could be null in certain environments.
     *
     * ```typescript
     * // get the nativeElement of the second selected row
     * let selectedRowNativeElement = this.grid.selectedRows[1].nativeElement;
     * ```
     */
    get nativeElement(): HTMLElement;
    /**
     * @hidden
     */
    focused: boolean;
    /**
     * @hidden
     * @internal
     */
    defaultCssClass: string;
    /**
     * @hidden
     */
    triggerAddAnimationClass: boolean;
    protected destroy$: Subject<any>;
    protected _data: any;
    protected _addRow: boolean;
    /**
     * @hidden
     * @internal
     */
    onClick(event: MouseEvent): void;
    /**
     * @hidden
     * @internal
     */
    onContextMenu(event: MouseEvent): void;
    /**
     * @hidden
     * @internal
     */
    showActionStrip(): void;
    /**
     * @hidden
     * @internal
     */
    hideActionStrip(): void;
    /**
     * @hidden
     * @internal
     */
    ngAfterViewInit(): void;
    /**
     * @hidden
     * @internal
     */
    ngOnDestroy(): void;
    /**
     * @hidden
     */
    onRowSelectorClick(event: any): void;
    /**
     * Updates the specified row object and the data source record with the passed value.
     *
     * ```typescript
     * // update the second selected row's value
     * let newValue = "Apple";
     * this.grid.selectedRows[1].update(newValue);
     * ```
     */
    update(value: any): void;
    /**
     * Removes the specified row from the grid's data source.
     * This method emits `rowDeleted` event.
     *
     * ```typescript
     * // delete the third selected row from the grid
     * this.grid.selectedRows[2].delete();
     * ```
     */
    delete(): void;
    isCellActive(visibleColumnIndex: any): boolean;
    /**
     * Pins the specified row.
     * This method emits `rowPinning`\`rowPinned` event.
     *
     * ```typescript
     * // pin the selected row from the grid
     * this.grid.selectedRows[0].pin();
     * ```
     */
    pin(): boolean;
    /**
     * Unpins the specified row.
     * This method emits `rowPinning`\`rowPinned` event.
     *
     * ```typescript
     * // unpin the selected row from the grid
     * this.grid.selectedRows[0].unpin();
     * ```
     */
    unpin(): boolean;
    /**
     * @hidden
     */
    get rowCheckboxAriaLabel(): string;
    /**
     * @hidden
     */
    ngDoCheck(): void;
    /**
     * @hidden
     */
    shouldDisplayPinnedChip(col: ColumnType): boolean;
    /**
     * Spawns the add row UI for the specific row.
     *
     * @example
     * ```typescript
     * const row = this.grid1.getRowByIndex(1);
     * row.beginAddRow();
     * ```
     */
    beginAddRow(): void;
    /**
     * @hidden
     */
    triggerAddAnimation(): void;
    /**
     * @hidden
     */
    animationEndHandler(): void;
    protected getMergeCellSpan(col: ColumnType): string;
    protected isSelectionRoot(col: ColumnType): boolean;
    protected isHoveredRoot(col: ColumnType): boolean;
    protected extractRecordKey(rec: any): any;
    protected getRowHeight(): any;
    /**
     * @hidden
     */
    get resolveDragIndicatorClasses(): string;
    /**
     * - state persistence switching all pinned columns resets collection
     * - MRL unpinnedColumns igxFor modes entire child loop on unpin
     */
    protected trackPinnedColumn: typeof trackByIdentity;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowDirective, "[igxRowBaseComponent]", never, { "metaData": { "alias": "metaData"; "required": false; }; "data": { "alias": "data"; "required": false; }; "index": { "alias": "index"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "gridID": { "alias": "gridID"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "addAnimationEnd": "addAnimationEnd"; }, never, never, true, never>;
    static ngAcceptInputType_disabled: unknown;
}

declare class IgxGridActionsBaseDirective implements AfterViewInit {
    protected iconService: IgxIconService;
    protected differs: IterableDiffers;
    /** @hidden @internal **/
    buttons: QueryList<IgxGridActionButtonComponent>;
    /**
     * Gets/Sets if the action buttons will be rendered as menu items. When in menu, items will be rendered with text label.
     *
     * @example
     * ```html
     *  <igx-grid-pinning-actions [asMenuItems]='true'></igx-grid-pinning-actions>
     *  <igx-grid-editing-actions [asMenuItems]='true'></igx-grid-editing-actions>
     * ```
     */
    asMenuItems: boolean;
    /** @hidden @internal **/
    strip: IgxActionStripToken;
    /**
     * @hidden
     * @internal
     */
    get grid(): any;
    /**
     * Getter to be used in template
     *
     * @hidden
     * @internal
     */
    get isRowContext(): boolean;
    /**
     * @hidden
     * @internal
     */
    ngAfterViewInit(): void;
    /**
     * Check if the param is a row from a grid
     *
     * @hidden
     * @internal
     * @param context
     */
    protected isRow(context: any): context is IgxRowDirective;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridActionsBaseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGridActionsBaseDirective, "[igxGridActionsBase]", never, { "asMenuItems": { "alias": "asMenuItems"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_asMenuItems: unknown;
}

/**
 * Grid Editing Actions for the Action Strip
 *
 * @igxParent IgxActionStripComponent
 */
declare class IgxGridEditingActionsComponent extends IgxGridActionsBaseDirective {
    /**
     * Host `class.igx-action-strip` binding.
     *
     * @hidden
     * @internal
     */
    cssClass: string;
    /**
     * An input to enable/disable action strip row adding button
     */
    set addRow(value: boolean);
    get addRow(): boolean;
    /**
     * An input to enable/disable action strip row editing button
     */
    editRow: boolean;
    /**
    * An input to enable/disable action strip row deleting button
    */
    deleteRow: boolean;
    /**
     * Getter if the row is disabled
     *
     * @hidden
     * @internal
     */
    get disabled(): boolean;
    /**
     * Getter if the row is root.
     *
     * @hidden
     * @internal
     */
    get isRootRow(): boolean;
    get hasChildren(): boolean;
    /**
     * An input to enable/disable action strip child row adding button
     */
    addChild: boolean;
    private isMessageShown;
    private _addRow;
    private iconsRendered;
    /**
     * Enter row or cell edit mode depending the grid rowEditable option
     *
     * @example
     * ```typescript
     * this.gridEditingActions.startEdit();
     * ```
     */
    startEdit(event?: any): void;
    /** @hidden @internal **/
    deleteRowHandler(event?: any): void;
    /** @hidden @internal **/
    addRowHandler(event?: any, asChild?: boolean): void;
    /**
     * @hidden
     * @internal
     */
    private registerIcons;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridEditingActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridEditingActionsComponent, "igx-grid-editing-actions", never, { "addRow": { "alias": "addRow"; "required": false; }; "editRow": { "alias": "editRow"; "required": false; }; "deleteRow": { "alias": "deleteRow"; "required": false; }; "addChild": { "alias": "addChild"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_addRow: unknown;
    static ngAcceptInputType_editRow: unknown;
    static ngAcceptInputType_deleteRow: unknown;
    static ngAcceptInputType_addChild: unknown;
}

/**
 * Grid Pinning Actions for the Action Strip
 *
 * @igxParent IgxActionStripComponent
 */
declare class IgxGridPinningActionsComponent extends IgxGridActionsBaseDirective {
    /**
     * Host `class.igx-action-strip` binding.
     *
     * @hidden
     * @internal
     */
    cssClass: string;
    private iconsRendered;
    /**
     * Getter to know if the row is pinned
     *
     * @hidden
     * @internal
     */
    get pinned(): boolean;
    /**
     * Getter to know if the row is in pinned and ghost
     *
     * @hidden
     * @internal
     */
    get inPinnedArea(): boolean;
    /**
     * Getter to know if the row pinning is set to top or bottom
     *
     * @hidden
     * @internal
     */
    get pinnedTop(): boolean;
    /**
     * Pin the row according to the context.
     *
     * @example
     * ```typescript
     * this.gridPinningActions.pin();
     * ```
     */
    pin(event?: any): void;
    /**
     * Unpin the row according to the context.
     *
     * @example
     * ```typescript
     * this.gridPinningActions.unpin();
     * ```
     */
    unpin(event?: any): void;
    scrollToRow(event: any): void;
    private registerSVGIcons;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridPinningActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridPinningActionsComponent, "igx-grid-pinning-actions", never, {}, {}, never, never, true, never>;
}

declare class IgxGridFooterComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridFooterComponent, "igx-grid-footer", never, {}, {}, never, ["*"], true, never>;
}

/**
 * @hidden
 */
declare class IgxGroupByRowTemplateDirective {
    template: TemplateRef<any>;
    static ngTemplateContextGuard(_dir: IgxGroupByRowTemplateDirective, ctx: unknown): ctx is IgxGroupByRowTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGroupByRowTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGroupByRowTemplateDirective, "[igxGroupByRow]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxGridDetailTemplateDirective {
    static ngTemplateContextGuard(_dir: IgxGridDetailTemplateDirective, ctx: unknown): ctx is IgxGridMasterDetailContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridDetailTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGridDetailTemplateDirective, "[igxGridDetail]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxRowExpandedIndicatorDirective {
    static ngTemplateContextGuard(_directive: IgxRowExpandedIndicatorDirective, context: unknown): context is IgxGridRowTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowExpandedIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowExpandedIndicatorDirective, "[igxRowExpandedIndicator]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxRowCollapsedIndicatorDirective {
    static ngTemplateContextGuard(_directive: IgxRowCollapsedIndicatorDirective, context: unknown): context is IgxGridRowTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowCollapsedIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowCollapsedIndicatorDirective, "[igxRowCollapsedIndicator]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxHeaderExpandedIndicatorDirective {
    static ngTemplateContextGuard(_directive: IgxHeaderExpandedIndicatorDirective, context: unknown): context is IgxGridTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxHeaderExpandedIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxHeaderExpandedIndicatorDirective, "[igxHeaderExpandedIndicator]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxHeaderCollapsedIndicatorDirective {
    static ngTemplateContextGuard(_directive: IgxHeaderCollapsedIndicatorDirective, context: unknown): context is IgxGridTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxHeaderCollapsedIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxHeaderCollapsedIndicatorDirective, "[igxHeaderCollapsedIndicator]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxExcelStyleHeaderIconDirective {
    static ngTemplateContextGuard(_directive: IgxExcelStyleHeaderIconDirective, context: unknown): context is IgxGridHeaderTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelStyleHeaderIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxExcelStyleHeaderIconDirective, "[igxExcelStyleHeaderIcon]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxSortHeaderIconDirective {
    static ngTemplateContextGuard(_directive: IgxSortHeaderIconDirective, context: unknown): context is IgxGridHeaderTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxSortHeaderIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxSortHeaderIconDirective, "[igxSortHeaderIcon]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxSortAscendingHeaderIconDirective {
    static ngTemplateContextGuard(_directive: IgxSortAscendingHeaderIconDirective, context: unknown): context is IgxGridHeaderTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxSortAscendingHeaderIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxSortAscendingHeaderIconDirective, "[igxSortAscendingHeaderIcon]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxSortDescendingHeaderIconDirective {
    static ngTemplateContextGuard(_directive: IgxSortDescendingHeaderIconDirective, context: unknown): context is IgxGridHeaderTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxSortDescendingHeaderIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxSortDescendingHeaderIconDirective, "[igxSortDescendingHeaderIcon]", never, {}, {}, never, never, true, never>;
}
/** @hidden */
declare class IgxGridLoadingTemplateDirective {
    static ngTemplateContextGuard(_directive: IgxGridLoadingTemplateDirective, context: unknown): context is IgxGridTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridLoadingTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGridLoadingTemplateDirective, "[igxGridLoading]", never, {}, {}, never, never, true, never>;
}
/** @hidden */
declare class IgxGridEmptyTemplateDirective {
    static ngTemplateContextGuard(_directive: IgxGridEmptyTemplateDirective, context: unknown): context is IgxGridTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridEmptyTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGridEmptyTemplateDirective, "[igxGridEmpty]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxGroupAreaDropDirective extends IgxDropDirective {
    private groupArea;
    hovered: boolean;
    onDragEnter(event: any): void;
    onDragLeave(event: any): void;
    private closestParentByAttr;
    private columnBelongsToGrid;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGroupAreaDropDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGroupAreaDropDirective, "[igxGroupAreaDrop]", never, {}, {}, never, never, true, never>;
}

/**
 * Injection token for setting the debounce time used in filtering row inputs.
 * @hidden
 */
declare const INPUT_DEBOUNCE_TIME: InjectionToken<number>;
/**
 * @hidden
 */
declare class IgxGridFilteringRowComponent implements OnInit, AfterViewInit, OnDestroy {
    filteringService: IgxFilteringService;
    ref: ElementRef<HTMLElement>;
    cdr: ChangeDetectorRef;
    protected platform: PlatformUtil;
    get column(): ColumnType;
    set column(val: ColumnType);
    get value(): any;
    set value(val: any);
    protected get filteringElementsSize(): _Size;
    defaultCSSClass: boolean;
    protected defaultFilterUI: TemplateRef<any>;
    protected defaultDateUI: TemplateRef<any>;
    protected defaultTimeUI: TemplateRef<any>;
    protected defaultDateTimeUI: TemplateRef<any>;
    protected input: ElementRef<HTMLInputElement>;
    protected dropDownConditions: IgxDropDownComponent;
    protected chipsArea: IgxChipsAreaComponent;
    protected dropDownOperators: QueryList<IgxDropDownComponent>;
    protected inputGroup: ElementRef<HTMLElement>;
    protected picker: IgxDatePickerComponent | IgxTimePickerComponent;
    protected inputGroupPrefix: ElementRef<HTMLElement>;
    protected container: ElementRef<HTMLElement>;
    protected operand: ElementRef<HTMLElement>;
    protected closeButton: ElementRef<HTMLElement>;
    get nativeElement(): HTMLElement;
    showArrows: boolean;
    expression: IFilteringExpression;
    expressionsList: Array<ExpressionUI>;
    private _positionSettings;
    private _conditionsOverlaySettings;
    private _operatorsOverlaySettings;
    private chipsAreaWidth;
    private chipAreaScrollOffset;
    private _column;
    private isKeyPressed;
    private isComposing;
    private _cancelChipClick;
    private _value;
    /** switch to icon buttons when width is below 432px */
    private readonly NARROW_WIDTH_THRESHOLD;
    private inputSubject;
    private $destroyer;
    private readonly DEBOUNCE_TIME;
    ngOnInit(): void;
    onKeydownHandler(evt: KeyboardEvent): void;
    ngAfterViewInit(): void;
    get disabled(): boolean;
    get template(): TemplateRef<any>;
    get type(): "number" | "text";
    get conditions(): any;
    get isUnaryCondition(): boolean;
    get placeholder(): string;
    /**
     * Event handler for keydown on the input group's prefix.
     */
    onPrefixKeyDown(event: KeyboardEvent): void;
    /**
     * Event handler for keydown on the input.
     */
    onInputKeyDown(event: KeyboardEvent): void;
    /**
     * Event handler for keyup on the input.
     */
    onInputKeyUp(): void;
    /**
     * Event handler for input on the input.
     */
    onInput(eventArgs: any): void;
    private handleInputChange;
    /**
     * Event handler for compositionstart on the input.
     */
    onCompositionStart(): void;
    /**
     * Event handler for compositionend on the input.
     */
    onCompositionEnd(): void;
    /**
     * Event handler for input click event.
     */
    onInputClick(): void;
    /**
     * Returns the filtering operation condition for a given value.
     */
    getCondition(value: string): IFilteringOperation;
    /**
     * Returns the translated condition name for a given value.
     */
    translateCondition(value: string): string;
    /**
     * Returns the icon name of the current condition.
     */
    getIconName(): string;
    /**
     * Returns whether a given condition is selected in dropdown.
     */
    isConditionSelected(conditionName: string): boolean;
    /**
     * Clears the current filtering.
     */
    clearFiltering(): void;
    /**
     * Commits the value of the input.
     */
    commitInput(): void;
    /**
     * Clears the value of the input.
     */
    clearInput(event?: MouseEvent): void;
    /**
     * Event handler for keydown on clear button.
     */
    onClearKeyDown(eventArgs: KeyboardEvent): void;
    /**
     * Event handler for click on clear button.
     */
    onClearClick(): void;
    /**
     * Event handler for keydown on commit button.
     */
    onCommitKeyDown(eventArgs: KeyboardEvent): void;
    /**
     * Event handler for click on commit button.
     */
    onCommitClick(event?: MouseEvent): void;
    /**
     * Event handler for focusout on the input group.
     */
    onInputGroupFocusout(): void;
    /**
     * Closes the filtering edit row.
     */
    close(): void;
    /**
     *  Event handler for date picker's selection.
     */
    onDateSelected(value: Date): void;
    /** @hidden @internal */
    inputGroupPrefixClick(event: MouseEvent): void;
    /**
     * Opens the conditions dropdown.
     */
    toggleConditionsDropDown(target: any): void;
    /**
     * Opens the logic operators dropdown.
     */
    toggleOperatorsDropDown(eventArgs: any, index: any): void;
    /**
     * Event handler for change event in conditions dropdown.
     */
    onConditionsChanged(eventArgs: any): void;
    onChipPointerdown(args: any, chip: IgxChipComponent): void;
    onChipClick(args: any, item: ExpressionUI): void;
    toggleChip(item: ExpressionUI): void;
    /**
     * Event handler for chip keydown event.
     */
    onChipKeyDown(eventArgs: KeyboardEvent, item: ExpressionUI): void;
    /**
     * Scrolls the first chip into view if the tab key is pressed on the left arrow.
     */
    onLeftArrowKeyDown(event: KeyboardEvent): void;
    /**
     * Event handler for chip removed event.
     */
    onChipRemoved(eventArgs: IBaseChipEventArgs, item: ExpressionUI): void;
    /**
     * Event handler for logic operator changed event.
     */
    onLogicOperatorChanged(eventArgs: ISelectionEventArgs, expression: ExpressionUI): void;
    /**
     * Scrolls the chips into the chip area when left or right arrows are pressed.
     */
    scrollChipsOnArrowPress(arrowPosition: string): void;
    /**
     * @hidden
     * Resets the chips area
     * @memberof IgxGridFilteringRowComponent
     */
    resetChipsArea(): void;
    /** @hidden @internal */
    focusEditElement(): void;
    ngOnDestroy(): void;
    private showHideArrowButtons;
    private addExpression;
    private removeExpression;
    private resetExpression;
    private scrollChipsWhenAddingExpression;
    private transform;
    private scrollChipsOnRemove;
    private conditionChangedCallback;
    private unaryConditionChangedCallback;
    private filter;
    private editorFocused;
    private get isColumnFiltered();
    get isNarrowWidth(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridFilteringRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridFilteringRowComponent, "igx-grid-filtering-row", never, { "column": { "alias": "column"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 *
 * For all intents & purposes treat this component as what a <thead> usually is in the default <table> element.
 *
 * This container holds the grid header elements and their behavior/interactions.
 *
 * @hidden @internal
 */
declare class IgxGridHeaderRowComponent implements DoCheck {
    protected ref: ElementRef<HTMLElement>;
    protected cdr: ChangeDetectorRef;
    /** The grid component containing this element. */
    grid: GridType;
    /** Pinned columns of the grid at start. */
    pinnedStartColumnCollection: ColumnType[];
    /** Pinned columns of the grid at end. */
    pinnedEndColumnCollection: ColumnType[];
    /** Unpinned columns of the grid. */
    unpinnedColumnCollection: ColumnType[];
    get activeDescendant(): string;
    hasMRL: boolean;
    width: number;
    /**
     * Header groups inside the header row.
     *
     * @remarks
     * Note: These are only the top level header groups in case there are multi-column headers
     * or a specific column layout. If you want to get the flattened collection use the `groups`
     * property below.
     *
     * @hidden @internal
     * */
    _groups: QueryList<IgxGridHeaderGroupComponent>;
    /**
     * The flattened header groups collection.
     *
     * @hidden @internal
     */
    get groups(): IgxGridHeaderGroupComponent[];
    /** Header components in the header row. */
    get headers(): IgxGridHeaderComponent[];
    /** Filtering cell components in the header row. */
    get filters(): IgxGridFilteringCellComponent[];
    /**
     * Gets a list of all visible leaf columns in the grid.
     *
     * @hidden @internal
     */
    get visibleLeafColumns(): ColumnType[];
    /**
    * @hidden
    * @internal
    */
    get isLeafHeaderAriaHidden(): boolean;
    /** The virtualized part of the header row containing the unpinned header groups. */
    headerContainer: IgxGridForOfDirective<ColumnType, ColumnType[]>;
    get headerForOf(): IgxGridForOfDirective<ColumnType, ColumnType[]>;
    headerDragContainer: ElementRef<HTMLElement>;
    headerSelectorContainer: ElementRef<HTMLElement>;
    headerGroupContainer: ElementRef<HTMLElement>;
    headSelectorBaseTemplate: TemplateRef<IgxHeadSelectorTemplateContext>;
    filterRow: IgxGridFilteringRowComponent;
    /**
     * Expand/collapse all child grids area in a hierarchical grid.
     * `undefined` in the base and tree grids.
     *
     * @internal @hidden
     */
    headerHierarchyExpander: ElementRef<HTMLElement>;
    get navigation(): any;
    get nativeElement(): HTMLElement;
    /**
     * Returns whether the current grid instance is a hierarchical grid.
     * as only hierarchical grids have the `isHierarchicalRecord` method.
     *
     * @hidden @internal
     */
    get isHierarchicalGrid(): boolean;
    get indentationCSSClasses(): string;
    get rowSelectorsContext(): IgxHeadSelectorTemplateContext;
    /**
     * This hook exists as a workaround for the unfortunate fact
     * that when we have pinned columns in the grid, the unpinned columns headers
     * are affected by a delayed change detection cycle after a horizontal scroll :(
     * Thus, we tell the parent grid change detector to check us at each cycle.
     *
     * @hidden @internal
     */
    ngDoCheck(): void;
    /**
     * @hidden @internal
     */
    scroll(event: Event): void;
    headerRowSelection(event: MouseEvent): void;
    /** state persistence switching all pinned columns resets collection */
    protected trackPinnedColumn: typeof trackByIdentity;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridHeaderRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridHeaderRowComponent, "igx-grid-header-row", never, { "grid": { "alias": "grid"; "required": false; }; "pinnedStartColumnCollection": { "alias": "pinnedStartColumnCollection"; "required": false; }; "pinnedEndColumnCollection": { "alias": "pinnedEndColumnCollection"; "required": false; }; "unpinnedColumnCollection": { "alias": "unpinnedColumnCollection"; "required": false; }; "hasMRL": { "alias": "hasMRL"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_hasMRL: unknown;
}

declare class SortingIndexPipe implements PipeTransform {
    transform(columnField: string, sortingExpressions: ISortingExpression[]): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<SortingIndexPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SortingIndexPipe, "sortingIndex", true>;
}
declare class IgxHeaderGroupStylePipe implements PipeTransform {
    transform(styles: {
        [prop: string]: any;
    }, column: ColumnType, _: number): {
        [prop: string]: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxHeaderGroupStylePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxHeaderGroupStylePipe, "igxHeaderGroupStyle", true>;
}

/**
 * @hidden
 */
declare class IgxRowDragDirective extends IgxDragDirective implements OnDestroy {
    set data(value: any);
    get data(): any;
    private subscription$;
    private _rowDragStarted;
    private get row();
    onPointerDown(event: any): void;
    onPointerMove(event: any): void;
    onPointerUp(event: any): void;
    protected createGhost(pageX: any, pageY: any): void;
    private _unsubscribe;
    private endDragging;
    private transitionEndEvent;
    private get isHierarchicalGrid();
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowDragDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowDragDirective, "[igxRowDrag]", never, { "data": { "alias": "igxRowDrag"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxDragIndicatorIconDirective {
    static ngTemplateContextGuard(_directive: IgxDragIndicatorIconDirective, context: unknown): context is IgxGridEmptyTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDragIndicatorIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxDragIndicatorIconDirective, "[igxDragIndicatorIcon]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
declare class IgxRowDragGhostDirective {
    templateRef: TemplateRef<IgxGridRowDragGhostContext>;
    static ngTemplateContextGuard(_directive: IgxRowDragGhostDirective, context: unknown): context is IgxGridRowDragGhostContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowDragGhostDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowDragGhostDirective, "[igxRowDragGhost]", never, {}, {}, never, never, true, never>;
}

/**
 * @hidden
 * @internal
 */
declare class IgxRowSelectorDirective {
    templateRef: TemplateRef<IgxRowSelectorTemplateContext>;
    static ngTemplateContextGuard(_directive: IgxRowSelectorDirective, context: unknown): context is IgxRowSelectorTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowSelectorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowSelectorDirective, "[igxRowSelector]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGroupByRowSelectorDirective {
    templateRef: TemplateRef<IgxGroupByRowSelectorTemplateContext>;
    static ngTemplateContextGuard(_directive: IgxGroupByRowSelectorDirective, context: unknown): context is IgxGroupByRowSelectorTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGroupByRowSelectorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGroupByRowSelectorDirective, "[igxGroupByRowSelector]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxHeadSelectorDirective {
    templateRef: TemplateRef<IgxHeadSelectorTemplateContext>;
    static ngTemplateContextGuard(_directive: IgxHeadSelectorDirective, context: unknown): context is IgxHeadSelectorTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxHeadSelectorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxHeadSelectorDirective, "[igxHeadSelector]", never, {}, {}, never, never, true, never>;
}

declare enum DragScrollDirection {
    NONE = 0,
    LEFT = 1,
    TOP = 2,
    RIGHT = 3,
    BOTTOM = 4,
    TOPLEFT = 5,
    TOPRIGHT = 6,
    BOTTOMLEFT = 7,
    BOTTOMRIGHT = 8
}
/**
 * An internal directive encapsulating the drag scroll behavior in the grid.
 *
 * @hidden @internal
 */
declare class IgxGridDragSelectDirective implements OnInit, OnDestroy {
    private ref;
    private zone;
    dragStop: EventEmitter<boolean>;
    dragScroll: EventEmitter<{
        left: number;
        top: number;
    }>;
    get activeDrag(): boolean;
    set activeDrag(val: boolean);
    get nativeElement(): HTMLElement;
    protected end$: Subject<any>;
    protected lastDirection: DragScrollDirection;
    protected _interval$: Observable<any>;
    protected _sub: Subscription;
    private _activeDrag;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    protected startDragSelection: (ev: PointerEvent) => void;
    protected stopDragSelection: () => void;
    protected _measureDimensions(x: number, y: number): {
        direction: DragScrollDirection;
        delta: {
            left: number;
            top: number;
        };
    };
    protected unsubscribe(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridDragSelectDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGridDragSelectDirective, "[igxGridDragSelect]", never, { "activeDrag": { "alias": "igxGridDragSelect"; "required": false; }; }, { "dragStop": "dragStop"; "dragScroll": "dragScroll"; }, never, never, true, never>;
    static ngAcceptInputType_activeDrag: unknown;
}

interface IGridState {
    columns?: IColumnState[];
    filtering?: IFilteringExpressionsTree;
    advancedFiltering?: IFilteringExpressionsTree;
    paging?: IPagingState;
    moving?: boolean;
    sorting?: ISortingExpression[];
    groupBy?: IGroupingState;
    cellSelection?: GridSelectionRange[];
    rowSelection?: any[];
    columnSelection?: string[];
    rowPinning?: any[];
    pinningConfig?: IPinningConfig;
    expansion?: any[];
    rowIslands?: IGridStateCollection[];
    id?: string;
    pivotConfiguration?: IPivotConfiguration;
}
interface IGridStateCollection {
    id: string;
    parentRowID: any;
    state: IGridState;
}
interface IGridStateOptions {
    columns?: boolean;
    filtering?: boolean;
    advancedFiltering?: boolean;
    sorting?: boolean;
    groupBy?: boolean;
    paging?: boolean;
    cellSelection?: boolean;
    rowSelection?: boolean;
    columnSelection?: boolean;
    rowPinning?: boolean;
    pinningConfig?: boolean;
    expansion?: boolean;
    rowIslands?: boolean;
    moving?: boolean;
    pivotConfiguration?: boolean;
}
interface IColumnState {
    pinned: boolean;
    sortable: boolean;
    filterable: boolean;
    editable: boolean;
    sortingIgnoreCase: boolean;
    filteringIgnoreCase: boolean;
    headerClasses: string;
    headerGroupClasses: string;
    maxWidth: string;
    groupable: boolean;
    hidden: boolean;
    dataType: GridColumnDataType;
    hasSummary: boolean;
    field: string;
    width: any;
    header: string;
    resizable: boolean;
    searchable: boolean;
    columnGroup: boolean;
    columnLayout?: boolean;
    rowStart?: number;
    rowEnd?: number;
    colStart?: number;
    colEnd?: number;
    /**
     * @deprecated
     */
    parent?: any;
    key: string;
    parentKey: string;
    disableHiding: boolean;
    disablePinning: boolean;
    collapsible?: boolean;
    expanded?: boolean;
    visibleWhenCollapsed?: boolean;
}
type GridFeatures = keyof IGridStateOptions;
declare class IgxGridStateBaseDirective {
    grid: GridType;
    protected viewRef: ViewContainerRef;
    protected envInjector: EnvironmentInjector;
    protected injector: Injector;
    private featureKeys;
    private state;
    private currGrid;
    protected _options: IGridStateOptions;
    private FEATURES;
    /**
     *  An object with options determining if a certain feature state should be saved.
     * ```html
     * <igx-grid [igxGridState]="options"></igx-grid>
     * ```
     * ```typescript
     * public options = {selection: false, advancedFiltering: false};
     * ```
     */
    get options(): IGridStateOptions;
    set options(value: IGridStateOptions);
    /**
     * Gets the state of a feature or states of all grid features, unless a certain feature is disabled through the `options` property.
     *
     * @param `serialize` determines whether the returned object will be serialized to JSON string. Default value is true.
     * @param `feature` string or array of strings determining the features to be added in the state. If skipped, all features are added.
     * @returns Returns the serialized to JSON string IGridState object, or the non-serialized IGridState object.
     * ```html
     * <igx-grid [igxGridState]="options"></igx-grid>
     * ```
     * ```typescript
     * @ViewChild(IgxGridStateDirective, { static: true }) public state;
     * let state = this.state.getState(); // returns string
     * let state = this.state(false) // returns `IGridState` object
     * ```
     */
    protected getStateInternal(serialize?: boolean, features?: GridFeatures | GridFeatures[]): IGridState | string;
    /**
     * Restores grid features' state based on the IGridState object passed as an argument.
     *
     * @param IGridState object to restore state from.
     * @returns
     * ```html
     * <igx-grid [igxGridState]="options"></igx-grid>
     * ```
     * ```typescript
     * @ViewChild(IgxGridStateDirective, { static: true }) public state;
     * this.state.setState(gridState);
     * ```
     */
    protected setStateInternal(state: IGridState, features?: GridFeatures | GridFeatures[]): void;
    /**
     * Builds an IGridState object.
     */
    private buildState;
    /**
     * The method that calls corresponding methods to restore features from the passed IGridState object.
     */
    private restoreGridState;
    private restoreFeatures;
    /**
     * Returns a collection of all grid features.
     */
    private applyFeatures;
    /**
     * This method restores complex objects in the pivot dimensions
     * Like the IgxPivotDateDimension and filters.
     */
    private restoreDimensions;
    /**
     * This method restores the IgxPivotDateDimension with its default functions and resource strings.
     */
    private restoreDateDimension;
    /**
     * Returns if this is a IgxPivotDateDimension.
     */
    private isDateDimension;
    /**
     * This method restores complex objects in the pivot values.
     * Like the default aggregator methods.
     */
    private restoreValues;
    /**
     * This method builds a rehydrated IExpressionTree from a provided object.
     */
    private createExpressionsTreeFromObject;
    protected stringifyCallback(key: string, val: any): any;
    private getColumnGroupKey;
    private getFeature;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridStateBaseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGridStateBaseDirective, never, never, { "options": { "alias": "options"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IgxGridStateDirective extends IgxGridStateBaseDirective {
    private static ngAcceptInputType_options;
    /**
     *  An object with options determining if a certain feature state should be saved.
     * ```html
     * <igx-grid [igxGridState]="options"></igx-grid>
     * ```
     * ```typescript
     * public options = {selection: false, advancedFiltering: false};
     * ```
     */
    get options(): IGridStateOptions;
    set options(value: IGridStateOptions);
    /**
     * Gets the state of a feature or states of all grid features, unless a certain feature is disabled through the `options` property.
     *
     * @param `serialize` determines whether the returned object will be serialized to JSON string. Default value is true.
     * @param `feature` string or array of strings determining the features to be added in the state. If skipped, all features are added.
     * @returns Returns the serialized to JSON string IGridState object, or the non-serialized IGridState object.
     * ```html
     * <igx-grid [igxGridState]="options"></igx-grid>
     * ```
     * ```typescript
     * @ViewChild(IgxGridStateDirective, { static: true }) public state;
     * let state = this.state.getState(); // returns string
     * let state = this.state(false) // returns `IGridState` object
     * ```
     */
    getState(serialize?: boolean, features?: GridFeatures | GridFeatures[]): IGridState | string;
    /**
     * Restores grid features' state based on the IGridState object passed as an argument.
     *
     * @param IGridState object to restore state from.
     * @returns
     * ```html
     * <igx-grid [igxGridState]="options"></igx-grid>
     * ```
     * ```typescript
     * @ViewChild(IgxGridStateDirective, { static: true }) public state;
     * this.state.setState(gridState);
     * ```
     */
    setState(state: IGridState | string, features?: GridFeatures | GridFeatures[]): void;
    /**
     *  Event emitted when set state is called with a string.
     * Returns the parsed state object so that it can be further modified before applying to the grid.
     * ```typescript
     * this.state.stateParsed.subscribe(parsedState => parsedState.sorting.forEach(x => x.strategy = NoopSortingStrategy.instance()});
     * ```
     */
    stateParsed: EventEmitter<IGridState>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridStateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGridStateDirective, "[igxGridState]", never, { "options": { "alias": "igxGridState"; "required": false; }; }, { "stateParsed": "stateParsed"; }, never, never, true, never>;
}

declare class IgxExcelTextDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxExcelTextDirective, "[excelText],excel-text", never, {}, {}, never, never, true, never>;
}
declare class IgxCSVTextDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxCSVTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxCSVTextDirective, "[csvText],csv-text", never, {}, {}, never, never, true, never>;
}
declare class IgxPdfTextDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxPdfTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxPdfTextDirective, "[pdfText],pdf-text", never, {}, {}, never, never, true, never>;
}
/**
 * Provides a way to template the title portion of the toolbar in the grid.
 *
 * @igxModule IgxGridToolbarModule
 * @igxParent IgxGridToolbarComponent
 *
 * @example
 * ```html
 * <igx-grid-toolbar-title>My custom title</igx-grid-toolbar-title>
 * ```
 */
declare class IgxGridToolbarTitleComponent {
    /**
     * Host `class.igx-grid-toolbar__title` binding.
     *
     * @hidden
     * @internal
     */
    cssClass: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridToolbarTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridToolbarTitleComponent, "igx-grid-toolbar-title", never, {}, {}, never, ["*"], true, never>;
}
/**
 * Provides a way to template the action portion of the toolbar in the grid.
 *
 * @igxModule IgxGridToolbarModule
 * @igxParent IgxGridToolbarComponent
 *
 * @example
 * ```html
 * <igx-grid-toolbar-actions>
 *  <some-toolbar-action-here />
 * </igx-grid-toolbar-actions>
 * ```
 */
declare class IgxGridToolbarActionsComponent {
    /**
     * Host `class.igx-grid-toolbar__actions` binding.
     *
     * @hidden
     * @internal
     */
    cssClass: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridToolbarActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridToolbarActionsComponent, "igx-grid-toolbar-actions", never, {}, {}, never, ["*"], true, never>;
}
interface IgxGridToolbarTemplateContext {
    $implicit: GridType;
}
declare class IgxGridToolbarDirective {
    template: TemplateRef<IgxGridToolbarTemplateContext>;
    static ngTemplateContextGuard(_dir: IgxGridToolbarDirective, ctx: unknown): ctx is IgxGridToolbarTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridToolbarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGridToolbarDirective, "[igxGridToolbar]", never, {}, {}, never, never, true, never>;
}

/**
 * Provides a context-aware container component for UI operations for the grid components.
 *
 * @igxModule IgxGridToolbarModule
 * @igxParent IgxGridComponent, IgxTreeGridComponent, IgxHierarchicalGridComponent, IgxPivotGridComponent
 *
 */
declare class IgxGridToolbarComponent implements OnDestroy {
    private api;
    private iconService;
    private element;
    /**
     * When enabled, shows the indeterminate progress bar.
     *
     * @remarks
     * By default this will be toggled, when the default exporter component is present
     * and an exporting is in progress.
     */
    showProgress: boolean;
    /**
     * Gets/sets the grid component for the toolbar component.
     *
     * @deprecated since version 17.1.0. No longer required to be set for the Hierarchical Grid child grid template
     *
     * @remarks
     * Usually you should not set this property in the context of the default grid/tree grid.
     * The only grids that demands this to be set are the hierarchical child grids. For additional
     * information check the toolbar topic.
     */
    get grid(): GridType;
    set grid(value: GridType);
    /** Returns the native DOM element of the toolbar component */
    get nativeElement(): HTMLElement;
    /**
     * @hidden
     * @internal
     */
    hasActions: IgxGridToolbarActionsComponent;
    /**
     * @hidden
     * @internal
     */
    defaultStyle: boolean;
    protected _grid: GridType;
    protected sub: Subscription;
    constructor();
    /** @hidden @internal */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridToolbarComponent, "igx-grid-toolbar", never, { "showProgress": { "alias": "showProgress"; "required": false; }; "grid": { "alias": "grid"; "required": false; }; }, {}, ["hasActions"], ["[igxGridToolbarTitle],igx-grid-toolbar-title,igc-grid-toolbar-title", "*", "[igxGridToolbarActions],igx-grid-toolbar-actions,igc-grid-toolbar-actions"], true, never>;
    static ngAcceptInputType_showProgress: unknown;
}

/**
 * Provides a pre-configured button to open the advanced filtering dialog of the grid.
 *
 *
 * @igxModule IgxGridToolbarModule
 * @igxParent IgxGridToolbarComponent, IgxGridToolbarActionsComponent
 *
 * @example
 * ```html
 * <igx-grid-toolbar-advanced-filtering></igx-grid-toolbar-advanced-filtering>
 * <igx-grid-toolbar-advanced-filtering>Custom text</igx-grid-toolbar-advanced-filtering>
 * ```
 */
declare class IgxGridToolbarAdvancedFilteringComponent implements OnInit {
    private toolbar;
    protected numberOfColumns: number;
    /**
     * Returns the grid containing this component.
     * @hidden @internal
     */
    get grid(): igniteui_angular_grids_core.GridType;
    overlaySettings: OverlaySettings;
    /**
     * @hidden
     */
    ngOnInit(): void;
    protected extractUniqueFieldNamesFromFilterTree(filteringTree?: IFilteringExpressionsTree): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridToolbarAdvancedFilteringComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridToolbarAdvancedFilteringComponent, "igx-grid-toolbar-advanced-filtering", never, { "overlaySettings": { "alias": "overlaySettings"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/** @hidden @internal */
declare abstract class IgxToolbarToken {
    abstract grid: GridType;
    abstract showProgress: boolean;
}

/**
 * Base class for the pinning/hiding column and exporter actions.
 *
 * @hidden @internal
 */
declare abstract class BaseToolbarDirective implements OnDestroy {
    protected toolbar: IgxToolbarToken;
    /**
     * Sets the height of the column list in the dropdown.
     */
    columnListHeight: string;
    /**
     * Title text for the column action component
     */
    title: string;
    /**
     * The placeholder text for the search input.
     */
    prompt: string;
    /**
     * Sets overlay settings
     */
    set overlaySettings(overlaySettings: OverlaySettings);
    /**
     * Returns overlay settings
     */
    get overlaySettings(): OverlaySettings;
    /**
     * Emits an event before the toggle container is opened.
     */
    opening: EventEmitter<ToggleViewCancelableEventArgs>;
    /**
     * Emits an event after the toggle container is opened.
     */
    opened: EventEmitter<ToggleViewEventArgs>;
    /**
     * Emits an event before the toggle container is closed.
     */
    closing: EventEmitter<ToggleViewEventArgs>;
    /**
     * Emits an event after the toggle container is closed.
     */
    closed: EventEmitter<ToggleViewEventArgs>;
    /**
     * Emits when after a column's checked state is changed
     */
    columnToggle: EventEmitter<IColumnToggledEventArgs>;
    private $destroy;
    private $sub;
    private _overlaySettings;
    /**
     * Returns the grid containing this component.
     * @hidden @internal
     */
    get grid(): igniteui_angular_grids_core.GridType;
    /** @hidden @internal **/
    ngOnDestroy(): void;
    /** @hidden @internal */
    toggle(anchorElement: HTMLElement, toggleRef: IgxToggleDirective, actions?: IgxColumnActionsComponent): void;
    /** @hidden @internal */
    focusSearch(columnActions: HTMLElement): void;
    private _setupListeners;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseToolbarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseToolbarDirective, never, never, { "columnListHeight": { "alias": "columnListHeight"; "required": false; }; "title": { "alias": "title"; "required": false; }; "prompt": { "alias": "prompt"; "required": false; }; "overlaySettings": { "alias": "overlaySettings"; "required": false; }; }, { "opening": "opening"; "opened": "opened"; "closing": "closing"; "closed": "closed"; "columnToggle": "columnToggle"; }, never, never, true, never>;
}
/**
 * @hidden @internal
 * Base class for pinning/hiding column actions
 */
declare abstract class BaseToolbarColumnActionsDirective extends BaseToolbarDirective {
    hideFilter: boolean;
    filterCriteria: string;
    columnDisplayOrder: ColumnDisplayOrder;
    columnsAreaMaxHeight: string;
    uncheckAllText: string;
    checkAllText: string;
    indentetion: number;
    buttonText: string;
    protected columnActionsUI: IgxColumnActionsComponent;
    checkAll(): void;
    uncheckAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseToolbarColumnActionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseToolbarColumnActionsDirective, never, never, { "hideFilter": { "alias": "hideFilter"; "required": false; }; "filterCriteria": { "alias": "filterCriteria"; "required": false; }; "columnDisplayOrder": { "alias": "columnDisplayOrder"; "required": false; }; "columnsAreaMaxHeight": { "alias": "columnsAreaMaxHeight"; "required": false; }; "uncheckAllText": { "alias": "uncheckAllText"; "required": false; }; "checkAllText": { "alias": "checkAllText"; "required": false; }; "indentetion": { "alias": "indentetion"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_hideFilter: unknown;
}

/**
 * Objects of this class are used to configure the CSV exporting process.
 */
declare class IgxCsvExporterOptions extends IgxExporterOptionsBase {
    private _valueDelimiter;
    private _fileType;
    constructor(fileName: string, fileType: CsvFileTypes);
    private static getExtensionFromFileType;
    /**
     * Gets the value delimiter which will be used for the exporting operation.
     * ```typescript
     * let delimiter = this.exportOptions.valueDelimiter;
     * ```
     *
     * @memberof IgxCsvExporterOptions
     */
    get valueDelimiter(): any;
    /**
     * Sets a value delimiter which will overwrite the default delimiter of the selected export format.
     * ```typescript
     * this.exportOptions.valueDelimiter = '|';
     * ```
     *
     * @memberof IgxCsvExporterOptions
     */
    set valueDelimiter(value: any);
    /**
     * Gets the CSV export format.
     * ```typescript
     * let filetype = this.exportOptions.fileType;
     * ```
     *
     * @memberof IgxCsvExporterOptions
     */
    get fileType(): any;
    /**
     * Sets the CSV export format.
     * ```typescript
     * this.exportOptions.fileType = CsvFileTypes.TAB;
     * ```
     *
     * @memberof IgxCsvExporterOptions
     */
    set fileType(value: any);
    private setFileType;
    private setDelimiter;
}
/**
 * This enumeration is used to configure the default value separator
 * as well as the default file extension used when performing CSV exporting.
 */
declare enum CsvFileTypes {
    /**
     * Character Separated Values, default separator is "comma", default file extension is .csv
     */
    CSV = 0,
    /**
     * Tab Separated Values, default separator is tab, default file extension is .tsv
     */
    TSV = 1,
    /**
     * Tab Separated Values, default separator is tab, default file extension is .tab
     */
    TAB = 2
}

/**
 * Objects of this class are used to configure the Excel exporting process.
 */
declare class IgxExcelExporterOptions extends IgxExporterOptionsBase {
    /**
     * Specifies if column pinning should be ignored. If ignoreColumnsOrder is set to true,
     * this option will always be considered as set to true.
     * ```typescript
     * let ignorePinning = this.exportOptions.ignorePinning;
     * this.exportOptions.ignorePinning = true;
     * ```
     *
     * @memberof IgxExcelExporterOptions
     */
    ignorePinning: boolean;
    /**
     * Specifies whether the exported data should be formatted as Excel table. (True by default)
     * ```typescript
     * let exportAsTable = this.exportOptions.exportAsTable;
     * this.exportOptions.exportAsTable = false;
     * ```
     *
     * @memberof IgxExcelExporterOptions
     */
    exportAsTable: boolean;
    private _columnWidth;
    private _rowHeight;
    private _worksheetName;
    constructor(fileName: string);
    /**
     * Gets the width of the columns in the exported excel file.
     * ```typescript
     * let width = this.exportOptions.columnWidth;
     * ```
     *
     * @memberof IgxExcelExporterOptions
     */
    get columnWidth(): number;
    /**
     * Sets the width of the columns in the exported excel file. If left unspecified,
     * the width of the column or the default width of the excel columns will be used.
     * ```typescript
     * this.exportOptions.columnWidth = 55;
     * ```
     *
     * @memberof IgxExcelExporterOptions
     */
    set columnWidth(value: number);
    /**
     * Gets the height of the rows in the exported excel file.
     * ```typescript
     * let height = this.exportOptions.rowHeight;
     * ```
     *
     * @memberof IgxExcelExporterOptions
     */
    get rowHeight(): number;
    /**
     * Sets the height of the rows in the exported excel file. If left unspecified or 0,
     * the default height of the excel rows will be used.
     * ```typescript
     * this.exportOptions.rowHeight = 25;
     * ```
     *
     * @memberof IgxExcelExporterOptions
     */
    set rowHeight(value: number);
    /**
     * Gets the name of the worksheet in the exported excel file.
     * ```typescript
     * let worksheetName = this.exportOptions.worksheetName;
     * ```
     *
     * @memberof IgxExcelExporterOptions
     */
    get worksheetName(): string;
    /**
     * Sets the name of the worksheet in the exported excel file.
     * ```typescript
     * this.exportOptions.worksheetName = "Worksheet";
     * ```
     *
     * @memberof IgxExcelExporterOptions
     */
    set worksheetName(value: string);
}

/**
 * Objects of this class are used to configure the PDF exporting process.
 */
declare class IgxPdfExporterOptions extends IgxExporterOptionsBase {
    /**
     * Specifies the page orientation. (portrait or landscape, landscape by default)
     * ```typescript
     * let pageOrientation = this.exportOptions.pageOrientation;
     * this.exportOptions.pageOrientation = 'portrait';
     * ```
     *
     * @memberof IgxPdfExporterOptions
     */
    pageOrientation: 'portrait' | 'landscape';
    /**
     * Specifies the page size. (a4, a3, letter, legal, etc., a4 by default)
     * ```typescript
     * let pageSize = this.exportOptions.pageSize;
     * this.exportOptions.pageSize = 'letter';
     * ```
     *
     * @memberof IgxPdfExporterOptions
     */
    pageSize: string;
    /**
     * Specifies whether to show table borders. (True by default)
     * ```typescript
     * let showTableBorders = this.exportOptions.showTableBorders;
     * this.exportOptions.showTableBorders = false;
     * ```
     *
     * @memberof IgxPdfExporterOptions
     */
    showTableBorders: boolean;
    /**
     * Specifies the font size for the table content. (10 by default)
     * ```typescript
     * let fontSize = this.exportOptions.fontSize;
     * this.exportOptions.fontSize = 12;
     * ```
     *
     * @memberof IgxPdfExporterOptions
     */
    fontSize: number;
    constructor(fileName: string);
}

type IgxExporterOptions = IgxCsvExporterOptions | IgxExcelExporterOptions | IgxPdfExporterOptions;
interface IgxExporterEvent {
    exporter: IgxBaseExporter;
    options: IgxExporterOptions;
    grid: GridType;
    cancel: boolean;
}
/**
 * Provides a pre-configured exporter component for the grid.
 *
 * @remarks
 * This component still needs the actual exporter service(s) provided in the DI chain
 * in order to export something.
 *
 * @igxModule IgxGridToolbarModule
 * @igxParent IgxGridToolbarComponent, IgxGridToolbarActionsComponent
 *
 */
declare class IgxGridToolbarExporterComponent extends BaseToolbarDirective {
    private excelExporter;
    private csvExporter;
    private pdfExporter;
    /**
     * Show entry for CSV export.
     */
    exportCSV: boolean;
    /**
     * Show entry for Excel export.
     */
    exportExcel: boolean;
    /**
     * Show entry for PDF export.
     */
    exportPDF: boolean;
    /**
     * The name for the exported file.
     */
    filename: string;
    /**
     * Emitted when starting an export operation. Re-emitted additionally
     * by the grid itself.
     */
    exportStarted: EventEmitter<IgxExporterEvent>;
    /**
     * Emitted on successful ending of an export operation.
     */
    exportEnded: EventEmitter<void>;
    /**
     * Indicates whether there is an export in progress.
     */
    protected isExporting: boolean;
    protected exportClicked(type: 'excel' | 'csv' | 'pdf', toggleRef?: IgxToggleDirective): void;
    /**
     * Export the grid's data
     * @param type File type to export
     */
    export(type: 'excel' | 'csv' | 'pdf'): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridToolbarExporterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridToolbarExporterComponent, "igx-grid-toolbar-exporter", never, { "exportCSV": { "alias": "exportCSV"; "required": false; }; "exportExcel": { "alias": "exportExcel"; "required": false; }; "exportPDF": { "alias": "exportPDF"; "required": false; }; "filename": { "alias": "filename"; "required": false; }; }, { "exportStarted": "exportStarted"; "exportEnded": "exportEnded"; }, never, ["*", "[excelText],excel-text", "[csvText],csv-text", "[pdfText],pdf-text"], true, never>;
    static ngAcceptInputType_exportCSV: unknown;
    static ngAcceptInputType_exportExcel: unknown;
    static ngAcceptInputType_exportPDF: unknown;
}

/**
 * Provides a pre-configured column hiding component for the grid.
 *
 *
 * @igxModule IgxGridToolbarModule
 * @igxParent IgxGridToolbarComponent, IgxGridToolbarActionsComponent
 *
 * @example
 * ```html
 *  <igx-grid-toolbar-hiding></igx-grid-toolbar-hiding>
 * ```
 */
declare class IgxGridToolbarHidingComponent extends BaseToolbarColumnActionsDirective {
    private set content(value);
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridToolbarHidingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridToolbarHidingComponent, "igx-grid-toolbar-hiding", never, {}, {}, never, never, true, never>;
}

/**
 * Provides a pre-configured column pinning component for the grid.
 *
 *
 * @igxModule IgxGridToolbarModule
 * @igxParent IgxGridToolbarComponent, IgxGridToolbarActionsComponent
 *
 * @example
 * ```html
 *  <igx-grid-toolbar-pinning></igx-grid-toolbar-pinning>
 * ```
 */
declare class IgxGridToolbarPinningComponent extends BaseToolbarColumnActionsDirective {
    private set content(value);
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridToolbarPinningComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridToolbarPinningComponent, "igx-grid-toolbar-pinning", never, {}, {}, never, never, true, never>;
}

declare abstract class BaseRow implements RowType {
    index: number;
    /**
     * The grid that contains the row.
     */
    grid: GridType;
    protected _data?: any;
    /**
     * Returns the view index calculated per the grid page.
     */
    get viewIndex(): number;
    /**
     * Gets the row key.
     * A row in the grid is identified either by:
     * - primaryKey data value,
     * - the whole rowData, if the primaryKey is omitted.
     *
     * ```typescript
     * let rowKey = row.key;
     * ```
     */
    get key(): any;
    /**
     * Gets if this represents add row UI
     *
     * ```typescript
     * let isAddRow = row.addRowUI;
     * ```
     */
    get addRowUI(): boolean;
    /** Gets the validation status and errors, if any.
    * ```typescript
    * let validation = row.validation;
    * let errors = validation.errors;
    * ```
    */
    get validation(): IGridValidationState;
    /**
     * The data record that populates the row.
     *
     * ```typescript
     * let rowData = row.data;
     * ```
     */
    get data(): any;
    /**
     * Returns if the row is currently in edit mode.
     */
    get inEditMode(): boolean;
    /**
     * Gets whether the row is pinned.
     * Default value is `false`.
     * ```typescript
     * const isPinned = row.pinned;
     * ```
     */
    get pinned(): boolean;
    /**
     * Sets whether the row is pinned.
     * Default value is `false`.
     * ```typescript
     * row.pinned = !row.pinned;
     * ```
     */
    set pinned(val: boolean);
    /**
     * Gets the row expanded/collapsed state.
     *
     * ```typescript
     * const isExpanded = row.expanded;
     * ```
     */
    get expanded(): boolean;
    /**
     * Expands/collapses the row.
     *
     * ```typescript
     * row.expanded = true;
     * ```
     */
    set expanded(val: boolean);
    /**
     * Gets whether the row is selected.
     * Default value is `false`.
     * ```typescript
     * row.selected = true;
     * ```
     */
    get selected(): boolean;
    /**
     * Sets whether the row is selected.
     * Default value is `false`.
     * ```typescript
     * row.selected = !row.selected;
     * ```
     */
    set selected(val: boolean);
    /**
     * Returns if the row is in delete state.
     */
    get deleted(): boolean;
    /**
     * Returns if the row has child rows. Always return false for IgxGridRow.
     */
    get hasChildren(): boolean;
    get disabled(): boolean;
    /**
     * Gets the rendered cells in the row component.
     */
    get cells(): CellType[];
    /**
     * Pins the specified row.
     * This method emits `onRowPinning` event.
     *
     * ```typescript
     * // pin the selected row from the grid
     * this.grid.selectedRows[0].pin();
     * ```
     */
    pin(): boolean;
    /**
     * Unpins the specified row.
     * This method emits `onRowPinning` event.
     *
     * ```typescript
     * // unpin the selected row from the grid
     * this.grid.selectedRows[0].unpin();
     * ```
     */
    unpin(): boolean;
    /**
     * Updates the specified row object and the data source record with the passed value.
     *
     * ```typescript
     * // update the second selected row's value
     * let newValue = "Apple";
     * this.grid.selectedRows[1].update(newValue);
     * ```
     */
    update(value: any): void;
    /**
     * Removes the specified row from the grid's data source.
     * This method emits `onRowDeleted` event.
     *
     * ```typescript
     * // delete the third selected row from the grid
     * this.grid.selectedRows[2].delete();
     * ```
     */
    delete(): void;
}
declare class IgxGridRow extends BaseRow implements RowType {
    grid: GridType;
    index: number;
    /**
     * @hidden
     */
    constructor(grid: GridType, index: number, data?: any);
    /**
     * Returns the view index calculated per the grid page.
     */
    get viewIndex(): number;
    /**
     * Returns the parent row, if grid is grouped.
     */
    get parent(): RowType;
}
declare class IgxTreeGridRow extends BaseRow implements RowType {
    grid: GridType;
    index: number;
    private _treeRow?;
    /**
     * @hidden
     */
    constructor(grid: GridType, index: number, data?: any, _treeRow?: ITreeGridRecord);
    /**
     * Returns the view index calculated per the grid page.
     */
    get viewIndex(): number;
    /**
     *  The data passed to the row component.
     *
     * ```typescript
     * let selectedRowData = this.grid.selectedRows[0].data;
     * ```
     */
    get data(): any;
    /**
     * Returns the child rows.
     */
    get children(): RowType[];
    /**
     * Returns the parent row.
     */
    get parent(): RowType;
    /**
     * Returns true if child rows exist. Always return false for IgxGridRow.
     */
    get hasChildren(): boolean;
    /**
     * The `ITreeGridRecord` with metadata about the row in the context of the tree grid.
     *
     * ```typescript
     * const rowParent = this.treeGrid.getRowByKey(1).treeRow.parent;
     * ```
     */
    get treeRow(): ITreeGridRecord;
    /**
     * Gets whether the row is pinned.
     *
     * ```typescript
     * let isPinned = row.pinned;
     * ```
     */
    get pinned(): boolean;
    /**
     * Sets whether the row is pinned.
     * Default value is `false`.
     * ```typescript
     * row.pinned = !row.pinned;
     * ```
     */
    set pinned(val: boolean);
    /**
     * Gets whether the row is expanded.
     *
     * ```typescript
     * let esExpanded = row.expanded;
     * ```
     */
    get expanded(): boolean;
    /**
     * Expands/collapses the row.
     *
     * ```typescript
     * row.expanded = true;
     * ```
     */
    set expanded(val: boolean);
    get disabled(): boolean;
    private getRootParent;
}
declare class IgxHierarchicalGridRow extends BaseRow implements RowType {
    grid: GridType;
    index: number;
    /**
     * @hidden
     */
    constructor(grid: GridType, index: number, data?: any);
    /**
     * Returns true if row islands exist.
     */
    get hasChildren(): boolean;
    /**
     * Returns the view index calculated per the grid page.
     */
    get viewIndex(): number;
    /**
     * Gets the rendered cells in the row component.
     */
    get cells(): CellType[];
}
declare class IgxGroupByRow implements RowType {
    private _groupRow?;
    /**
     * Returns the row index.
     */
    index: number;
    /**
     * The grid that contains the row.
     */
    grid: GridType;
    /**
     * Returns always true, because this is in instance of an IgxGroupByRow.
     */
    isGroupByRow: boolean;
    /**
     * The IGroupByRecord object, representing the group record, if the row is a GroupByRow.
     */
    get groupRow(): IGroupByRecord;
    /**
     * Returns the child rows.
     */
    get children(): RowType[];
    /**
     * Returns the view index calculated per the grid page.
     */
    get viewIndex(): number;
    /**
     * @hidden
     */
    constructor(grid: GridType, index: number, _groupRow?: IGroupByRecord);
    /**
     * Gets whether the row is selected.
     * Default value is `false`.
     * ```typescript
     * row.selected = true;
     * ```
     */
    get selected(): boolean;
    /**
     * Sets whether the row is selected.
     * Default value is `false`.
     * ```typescript
     * row.selected = !row.selected;
     * ```
     */
    set selected(val: boolean);
    /**
     * Gets/sets whether the group row is expanded.
     * ```typescript
     * const groupRowExpanded = groupRow.expanded;
     * ```
     */
    get expanded(): boolean;
    set expanded(value: boolean);
    isActive(): boolean;
    /**
     * Toggles the group row expanded/collapsed state.
     * ```typescript
     * groupRow.toggle()
     * ```
     */
    toggle(): void;
    private get gridAPI();
}
declare class IgxSummaryRow implements RowType {
    private _summaries?;
    /**
     * Returns the row index.
     */
    index: number;
    /**
     * The grid that contains the row.
     */
    grid: GridType;
    /**
     * Returns always true, because this is in instance of an IgxGroupByRow.
     */
    isSummaryRow: boolean;
    /**
     * The IGroupByRecord object, representing the group record, if the row is a GroupByRow.
     */
    get summaries(): Map<string, IgxSummaryResult[]>;
    /**
     * Returns the view index calculated per the grid page.
     */
    get viewIndex(): number;
    /**
     * @hidden
     */
    constructor(grid: GridType, index: number, _summaries?: Map<string, IgxSummaryResult[]>);
    private getRootParent;
}

declare class IgxGridCell implements CellType {
    /**
     * Returns the grid containing the cell.
     *
     * @memberof IgxGridCell
     */
    grid: GridType;
    private _row;
    private _rowIndex;
    private _column;
    /**
     * @hidden
     */
    constructor(grid: GridType, row: number | RowType, column: ColumnType);
    /**
     * Returns the row containing the cell.
     * ```typescript
     * let row = this.cell.row;
     * ```
     *
     * @memberof IgxGridCell
     */
    get row(): RowType;
    /**
     * Returns the column of the cell.
     * ```typescript
     * let column = this.cell.column;
     * ```
     *
     * @memberof IgxGridCell
     */
    get column(): ColumnType;
    /**
     * Gets the current edit value while a cell is in edit mode.
     * ```typescript
     * let editValue = this.cell.editValue;
     * ```
     *
     * @memberof IgxGridCell
     */
    get editValue(): any;
    /**
     * Sets the current edit value while a cell is in edit mode.
     * Only for cell editing mode.
     * ```typescript
     * this.cell.editValue = value;
     * ```
     *
     * @memberof IgxGridCell
     */
    set editValue(value: any);
    /**
     * Gets the validation status and errors, if any.
     * ```typescript
     * let validation = this.cell.validation;
     * let errors = validation.errors;
     * ```
     */
    get validation(): IGridValidationState;
    /**
     * Returns whether the cell is editable..
     *
     * @memberof IgxGridCell
     */
    get editable(): boolean;
    /**
     * Gets the width of the cell.
     * ```typescript
     * let cellWidth = this.cell.width;
     * ```
     *
     * @memberof IgxGridCell
     */
    get width(): string;
    /**
     * Returns the cell value.
     *
     * @memberof IgxGridCell
     */
    get value(): any;
    /**
     * Updates the cell value.
     *
     * @memberof IgxGridCell
     */
    set value(val: any);
    /**
     * Gets the cell id.
     * A cell in the grid is identified by:
     * - rowID - primaryKey data value or the whole rowData, if the primaryKey is omitted.
     * - rowIndex - the row index
     * - columnID - column index
     *
     * ```typescript
     * let cellID = cell.id;
     * ```
     *
     * @memberof IgxGridCell
     */
    get id(): any;
    /**
     * Returns if the row is currently in edit mode.
     *
     * @memberof IgxGridCell
     */
    get editMode(): boolean;
    /**
     * Starts/ends edit mode for the cell.
     *
     * ```typescript
     * cell.editMode  = !cell.editMode;
     * ```
     *
     * @memberof IgxGridCell
     */
    set editMode(value: boolean);
    /**
     * Gets whether the cell is selected.
     * ```typescript
     * let isSelected = this.cell.selected;
     * ```
     *
     *
     * @memberof IgxGridCell
     */
    get selected(): boolean;
    /**
     * Selects/deselects the cell.
     * ```typescript
     * this.cell.selected = true.
     * ```
     *
     *
     * @memberof IgxGridCell
     */
    set selected(val: boolean);
    get active(): boolean;
    /**
     * Updates the cell value.
     *
     * ```typescript
     * cell.update(newValue);
     * ```
     *
     * @memberof IgxGridCell
     */
    update(val: any): void;
    protected get selectionNode(): ISelectionNode;
    private isCellInEditMode;
    private endEdit;
}

/** @hidden @internal */
declare class IgxRowEditTemplateDirective {
    static ngTemplateContextGuard(_directive: IgxRowEditTemplateDirective, context: unknown): context is IgxGridRowEditTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowEditTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowEditTemplateDirective, "[igxRowEdit]", never, {}, {}, never, never, true, never>;
}
/** @hidden @internal */
declare class IgxRowEditTextDirective {
    static ngTemplateContextGuard(_directive: IgxRowEditTextDirective, context: unknown): context is IgxGridRowEditTextTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowEditTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowEditTextDirective, "[igxRowEditText]", never, {}, {}, never, never, true, never>;
}
/** @hidden @internal */
declare class IgxRowAddTextDirective {
    static ngTemplateContextGuard(_directive: IgxRowAddTextDirective, context: unknown): context is IgxGridEmptyTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowAddTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowAddTextDirective, "[igxRowAddText]", never, {}, {}, never, never, true, never>;
}
/** @hidden @internal */
declare class IgxRowEditActionsDirective {
    static ngTemplateContextGuard(_directive: IgxRowEditActionsDirective, context: unknown): context is IgxGridRowEditActionsTemplateContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowEditActionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowEditActionsDirective, "[igxRowEditActions]", never, {}, {}, never, never, true, never>;
}
/** @hidden @internal */
declare class IgxRowEditTabStopDirective {
    grid: igniteui_angular_grids_core.GridType;
    element: ElementRef<any>;
    private currentCellIndex;
    handleTab(event: KeyboardEvent): void;
    handleEscape(event: KeyboardEvent): void;
    handleEnter(event: KeyboardEvent): void;
    /**
     * Moves focus to first/last editable cell in the editable row and put the cell in edit mode.
     * If cell is out of view first scrolls to the cell
     *
     * @param event keyboard event containing information about whether SHIFT key was pressed
     */
    private move;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRowEditTabStopDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRowEditTabStopDirective, "[igxRowEditTabStop]", never, {}, {}, never, never, true, never>;
}

/**
 * Use the function to get a random UUID string when secure context is not guaranteed making crypto.randomUUID unavailable.
 * @returns A random UUID string.
 */
declare function getUUID(): `${string}-${string}-${string}-${string}-${string}`;

interface GridStyleCSSProperty {
    [prop: string]: any;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGridCellStyleClassesPipe implements PipeTransform {
    transform(cssClasses: GridStyleCSSProperty, _: any, data: any, field: string, index: number, __: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridCellStyleClassesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridCellStyleClassesPipe, "igxCellStyleClasses", true>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGridCellStylesPipe implements PipeTransform {
    transform(styles: GridStyleCSSProperty, _: any, data: any, field: string, index: number, __: number): GridStyleCSSProperty;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridCellStylesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridCellStylesPipe, "igxCellStyles", true>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGridCellImageAltPipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridCellImageAltPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridCellImageAltPipe, "igxCellImageAlt", true>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGridRowClassesPipe implements PipeTransform {
    private grid;
    row: RowType;
    constructor();
    transform(cssClasses: GridStyleCSSProperty, row: RowType, editMode: boolean, selected: boolean, dirty: boolean, deleted: boolean, dragging: boolean, index: number, mrl: boolean, merged: boolean, filteredOut: boolean, _rowData: any, _: number): Set<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridRowClassesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridRowClassesPipe, "igxGridRowClasses", true>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGridRowStylesPipe implements PipeTransform {
    private grid;
    transform(styles: GridStyleCSSProperty, rowData: any, index: number, __: number): GridStyleCSSProperty;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridRowStylesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridRowStylesPipe, "igxGridRowStyles", true>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGridNotGroupedPipe implements PipeTransform {
    transform(value: any[]): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridNotGroupedPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridNotGroupedPipe, "igxNotGrouped", true>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGridTopLevelColumns implements PipeTransform {
    transform(value: any[]): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridTopLevelColumns, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridTopLevelColumns, "igxTopLevel", true>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGridFilterConditionPipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridFilterConditionPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridFilterConditionPipe, "filterCondition", true>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGridTransactionPipe implements PipeTransform {
    private grid;
    transform(collection: any[], _id: string, _pipeTrigger: number): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridTransactionPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridTransactionPipe, "gridTransaction", true>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxGridPaginatorOptionsPipe implements PipeTransform {
    transform(values: Array<number>): number[];
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridPaginatorOptionsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridPaginatorOptionsPipe, "paginatorOptions", true>;
}
/**
 * @hidden
 * @internal
 */
declare class IgxHasVisibleColumnsPipe implements PipeTransform {
    transform(values: any[], hasVisibleColumns: any): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxHasVisibleColumnsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxHasVisibleColumnsPipe, "visibleColumns", true>;
}
/**
 * @hidden
 */
declare class IgxGridRowPinningPipe implements PipeTransform {
    private grid;
    transform(collection: any[], id: string, isPinned: boolean, _pipeTrigger: number): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridRowPinningPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridRowPinningPipe, "gridRowPinning", true>;
}
declare class IgxGridDataMapperPipe implements PipeTransform {
    transform(data: any[], field: string, _: number, val: any, isNestedPath: boolean): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridDataMapperPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridDataMapperPipe, "dataMapper", true>;
}
declare class IgxStringReplacePipe implements PipeTransform {
    transform(value: string, search: string | RegExp, replacement: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxStringReplacePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxStringReplacePipe, "igxStringReplace", true>;
}
declare class IgxGridTransactionStatePipe implements PipeTransform {
    transform(row_id: any, field: string, rowEditable: boolean, transactions: any, _: any, __: any, ___: any): unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridTransactionStatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridTransactionStatePipe, "transactionState", true>;
}
declare class IgxColumnFormatterPipe implements PipeTransform {
    transform(value: any, formatter: (v: any, data: any, columnData?: any) => any, rowData: any, columnData?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnFormatterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxColumnFormatterPipe, "columnFormatter", true>;
}
declare class IgxSummaryFormatterPipe implements PipeTransform {
    transform(summaryResult: IgxSummaryResult, summaryOperand: IgxSummaryOperand, summaryFormatter: (s: IgxSummaryResult, o: IgxSummaryOperand) => any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxSummaryFormatterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxSummaryFormatterPipe, "summaryFormatter", true>;
}
declare class IgxGridAddRowPipe implements PipeTransform {
    private grid;
    transform(collection: any, isPinned: boolean, _pipeTrigger: number): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridAddRowPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGridAddRowPipe, "gridAddRow", true>;
}

declare class NoopPivotDimensionsStrategy implements IPivotDimensionStrategy {
    private static _instance;
    static instance(): NoopPivotDimensionsStrategy;
    process(collection: any[], _: IPivotDimension[], __: IPivotValue[]): any[];
}
declare class PivotRowDimensionsStrategy implements IPivotDimensionStrategy {
    private static _instance;
    static instance(): PivotRowDimensionsStrategy;
    process(collection: any, rows: IPivotDimension[], values: IPivotValue[], cloneStrategy: IDataCloneStrategy, pivotKeys?: IPivotKeys): IPivotGridRecord[];
}
declare class PivotColumnDimensionsStrategy implements IPivotDimensionStrategy {
    private static _instance;
    static instance(): PivotRowDimensionsStrategy | PivotColumnDimensionsStrategy;
    process(collection: IPivotGridRecord[], columns: IPivotDimension[], values: IPivotValue[], cloneStrategy: IDataCloneStrategy, pivotKeys?: IPivotKeys): any[];
    private processHierarchy;
    private groupColumns;
    private applyAggregates;
    private getLeafs;
}
declare class DimensionValuesFilteringStrategy extends FilteringStrategy {
    private fields?;
    /**
     * Creates a new instance of FormattedValuesFilteringStrategy.
     *
     * @param fields An array of column field names that should be formatted.
     * If omitted the values of all columns which has formatter will be formatted.
     */
    constructor(fields?: string[]);
    protected getFieldValue(rec: any, fieldName: string, _isDate?: boolean, _isTime?: boolean, grid?: PivotGridType): any;
    getFilterItems(column: ColumnType, tree: IFilteringExpressionsTree): Promise<IgxFilterItem[]>;
    private _getFilterItems;
    private _getDimensionValueHierarchy;
}

/** @hidden */
declare class IgxGridSummaryService {
    grid: GridType;
    rootSummaryID: string;
    summaryHeight: number;
    maxSummariesLength: number;
    groupingExpressions: any[];
    retriggerRootPipe: number;
    deleteOperation: boolean;
    protected summaryCacheMap: Map<string, Map<string, any[]>>;
    recalculateSummaries(): void;
    clearSummaryCache(args?: any): void;
    removeSummaries(rowID: any, columnName?: any): void;
    removeSummariesCachePerColumn(columnName: any): void;
    calcMaxSummaryHeight(): number;
    calculateSummaries(rowID: any, data: any, groupRecord: any): Map<string, any[]>;
    resetSummaryHeight(): void;
    updateSummaryCache(groupingArgs: any): void;
    get hasSummarizedColumns(): boolean;
    private deleteSummaryCache;
    private getSummaryID;
    private removeAllTreeGridSummaries;
    private compareGroupingExpressions;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridSummaryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxGridSummaryService>;
}

declare class IgxSummaryCellComponent {
    private element;
    summaryResults: IgxSummaryResult[];
    column: ColumnType;
    firstCellIndentation: number;
    hasSummary: boolean;
    summaryFormatter: (summaryResult: IgxSummaryResult, summaryOperand: IgxSummaryOperand) => any;
    summaryTemplate: TemplateRef<any>;
    /** @hidden */
    active: boolean;
    rowIndex: number;
    get visibleColumnIndex(): number;
    get attrCellID(): string;
    activate(): void;
    protected get selectionNode(): ISelectionNode;
    get width(): string;
    get nativeElement(): any;
    get columnDatatype(): GridColumnDataType;
    get itemHeight(): any;
    /**
     * @hidden
     */
    get grid(): any;
    /**
     * @hidden @internal
     */
    get currencyCode(): string;
    /**
     * @hidden @internal
     */
    get currencySymbol(): string;
    /** cached single summary res after filter resets collection */
    protected trackSummaryResult: typeof trackByIdentity;
    translateSummary(summary: IgxSummaryResult): string;
    /**
     * @hidden @internal
     */
    formatSummaryResult(summary: IgxSummaryResult): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxSummaryCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxSummaryCellComponent, "igx-grid-summary-cell", never, { "summaryResults": { "alias": "summaryResults"; "required": false; }; "column": { "alias": "column"; "required": false; }; "firstCellIndentation": { "alias": "firstCellIndentation"; "required": false; }; "hasSummary": { "alias": "hasSummary"; "required": false; }; "summaryFormatter": { "alias": "summaryFormatter"; "required": false; }; "summaryTemplate": { "alias": "summaryTemplate"; "required": false; }; "active": { "alias": "active"; "required": false; }; "rowIndex": { "alias": "rowIndex"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_hasSummary: unknown;
}

declare class IgxSummaryRowComponent implements DoCheck {
    grid: GridType;
    element: ElementRef<HTMLElement>;
    cdr: ChangeDetectorRef;
    summaries: Map<string, IgxSummaryResult[]>;
    gridID: any;
    index: number;
    firstCellIndentation: number;
    get dataRowIndex(): number;
    get minHeight(): number;
    _summaryCells: QueryList<IgxSummaryCellComponent>;
    get summaryCells(): QueryList<IgxSummaryCellComponent>;
    set summaryCells(cells: QueryList<IgxSummaryCellComponent>);
    /**
     * @hidden
     */
    virtDirRow: IgxGridForOfDirective<ColumnType, ColumnType[]>;
    ngDoCheck(): void;
    get nativeElement(): HTMLElement;
    getColumnSummaries(columnName: string): IgxSummaryResult[];
    /**
     * @hidden
     * @internal
     */
    isCellActive(visibleColumnIndex: any): boolean;
    /**
     * @hidden
     */
    get pinnedColumns(): ColumnType[];
    /**
     * @hidden
     */
    get pinnedStartColumns(): ColumnType[];
    /**
     * @hidden
     */
    get pinnedEndColumns(): ColumnType[];
    /**
     * @hidden
     */
    get unpinnedColumns(): ColumnType[];
    getContext(row: any, cols: any): {
        $implicit: any;
        columns: any;
    };
    /** state persistence switching all pinned columns resets collection */
    protected trackPinnedColumn: typeof trackByIdentity;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxSummaryRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxSummaryRowComponent, "igx-grid-summary-row", never, { "summaries": { "alias": "summaries"; "required": false; }; "gridID": { "alias": "gridID"; "required": false; }; "index": { "alias": "index"; "required": false; }; "firstCellIndentation": { "alias": "firstCellIndentation"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IgxSummaryDataPipe implements PipeTransform {
    private grid;
    transform(id: string, trigger?: number): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxSummaryDataPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxSummaryDataPipe, "igxGridSummaryDataPipe", true>;
}

/**
 * @hidden
 * @internal
 */
declare class IgxColumnMovingDragDirective extends IgxDragDirective implements OnDestroy {
    private cms;
    column: ColumnType;
    get draggable(): boolean;
    get icon(): HTMLElement;
    private subscription$;
    private _ghostClass;
    private ghostImgIconClass;
    private ghostImgIconGroupClass;
    private columnSelectedClass;
    constructor();
    ngOnDestroy(): void;
    onEscape(event: Event): void;
    onPointerDown(event: Event): void;
    onPointerMove(event: Event): void;
    onPointerUp(event: Event): void;
    protected createGhost(pageX: number, pageY: number): void;
    private _unsubscribe;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnMovingDragDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnMovingDragDirective, "[igxColumnMovingDrag]", never, { "column": { "alias": "igxColumnMovingDrag"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IgxColumnMovingDropDirective extends IgxDropDirective implements OnDestroy {
    private cms;
    set data(val: ColumnType | IgxForOfDirective<ColumnType, ColumnType[]>);
    get column(): ColumnType;
    get isDropTarget(): boolean;
    get horizontalScroll(): IgxGridForOfDirective<ColumnType, ColumnType[]>;
    get nativeElement(): any;
    private _dropPos;
    private _dropIndicator;
    private _lastDropIndicator;
    private _column;
    private _displayContainer;
    private _dragLeave;
    private _dropIndicatorClass;
    constructor();
    ngOnDestroy(): void;
    onDragOver(event: any): void;
    onDragEnter(event: any): void;
    onDragLeave(event: any): void;
    onDragDrop(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnMovingDropDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnMovingDropDirective, "[igxColumnMovingDrop]", never, { "data": { "alias": "igxColumnMovingDrop"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @hidden
 * @internal
 */
declare class IgxColumnResizerDirective implements OnInit, OnDestroy {
    element: ElementRef<HTMLElement>;
    document: Document;
    zone: NgZone;
    restrictHResizeMin: number;
    restrictHResizeMax: number;
    restrictResizerTop: number;
    resizeEnd: Subject<MouseEvent>;
    resizeStart: Subject<MouseEvent>;
    resize: Subject<any>;
    private _left;
    private _ratio;
    private _destroy;
    get ratio(): number;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    set left(val: number);
    set top(val: number);
    onMouseup(event: MouseEvent): void;
    onMousedown(event: MouseEvent, resizeHandleTarget: HTMLElement): void;
    onMousemove(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxColumnResizerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxColumnResizerDirective, "[igxResizer]", never, { "restrictHResizeMin": { "alias": "restrictHResizeMin"; "required": false; }; "restrictHResizeMax": { "alias": "restrictHResizeMax"; "required": false; }; "restrictResizerTop": { "alias": "restrictResizerTop"; "required": false; }; }, { "resizeEnd": "resizeEnd"; "resizeStart": "resizeStart"; "resize": "resize"; }, never, never, true, never>;
}

declare class IgxGridColumnResizerComponent {
    colResizingService: IgxColumnResizingService;
    restrictResizerTop: number;
    resizer: IgxColumnResizerDirective;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridColumnResizerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridColumnResizerComponent, "igx-grid-column-resizer", never, { "restrictResizerTop": { "alias": "restrictResizerTop"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @hidden
 * @internal
 */
declare class IgxPivotColumnResizingService extends IgxColumnResizingService {
    /**
     * @hidden
     */
    rowHeaderGroup: PivotRowHeaderGroupType;
    /**
     * @hidden
     */
    getColumnHeaderRenderedWidth(): any;
    protected _handlePixelResize(diff: number, column: ColumnType): void;
    protected _handlePercentageResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxPivotColumnResizingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxPivotColumnResizingService>;
}

/**
 * @hidden
 * @internal
 */
declare class IgxResizeHandleDirective implements AfterViewInit, OnDestroy {
    protected zone: NgZone;
    protected element: ElementRef<any>;
    colResizingService: IgxColumnResizingService;
    /**
     * @hidden
     */
    column: ColumnType;
    /**
     * @hidden
     */
    protected _dblClick: boolean;
    /**
     * @hidden
     */
    private destroy$;
    private readonly DEBOUNCE_TIME;
    /**
     * @hidden
     */
    onDoubleClick(): void;
    /**
     * @hidden
     */
    ngOnDestroy(): void;
    /**
     * @hidden
     */
    ngAfterViewInit(): void;
    /**
     * @hidden
     */
    private _onResizeAreaMouseDown;
    /**
     * @hidden
     */
    protected initResizeService(event?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxResizeHandleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxResizeHandleDirective, "[igxResizeHandle]", never, { "column": { "alias": "igxResizeHandle"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @hidden
 * @internal
 */
declare class IgxPivotResizeHandleDirective extends IgxResizeHandleDirective {
    colResizingService: IgxPivotColumnResizingService;
    /**
     * @hidden
     */
    set pivotColumn(value: ColumnType);
    get pivotColumn(): ColumnType;
    /**
     * @hidden
     */
    rowHeaderGroup: PivotRowHeaderGroupType;
    /**
     * @hidden
     */
    onDoubleClick(): void;
    /**
     * @hidden
     */
    protected initResizeService(event?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxPivotResizeHandleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxPivotResizeHandleDirective, "[igxPivotResizeHandle]", never, { "pivotColumn": { "alias": "igxPivotResizeHandle"; "required": false; }; "rowHeaderGroup": { "alias": "igxPivotResizeHandleHeader"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IgxPivotGridColumnResizerComponent extends IgxGridColumnResizerComponent {
    colResizingService: IgxPivotColumnResizingService;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxPivotGridColumnResizerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxPivotGridColumnResizerComponent, "igx-pivot-grid-column-resizer", never, {}, {}, never, never, true, never>;
}

declare class IgxGridBodyDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridBodyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGridBodyDirective, "[igxGridBody]", never, {}, {}, never, never, true, never>;
}
/**
 * @hidden
 */
interface RowEditPositionSettings extends PositionSettings {
    container?: HTMLElement;
}
/**
 * @hidden
 */
declare class RowEditPositionStrategy extends ConnectedPositioningStrategy {
    isTop: boolean;
    isTopInitialPosition: any;
    settings: RowEditPositionSettings;
    position(contentElement: HTMLElement, size: {
        width: number;
        height: number;
    }, document?: Document, initialCall?: boolean, target?: Point | HTMLElement): void;
}

/**
 * Providing reference to `IgxGridCellComponent`:
 * ```typescript
 * @ViewChild('grid', { read: IgxGridComponent })
 *  public grid: IgxGridComponent;
 * ```
 * ```typescript
 *  let column = this.grid.columnList.first;
 * ```
 * ```typescript
 *  let cell = column.cells[0];
 * ```
 */
declare class IgxGridCellComponent implements OnInit, OnChanges, OnDestroy, CellType, AfterViewInit {
    protected selectionService: IgxGridSelectionService;
    grid: igniteui_angular_grids_core.GridType;
    protected overlayService: IgxOverlayService;
    cdr: ChangeDetectorRef;
    private element;
    protected zone: NgZone;
    private touchManager;
    protected platformUtil: PlatformUtil;
    private _destroy$;
    /**
     * @hidden
     * @internal
     */
    get isEmptyAddRowCell(): boolean;
    /**
     * @hidden
     * @internal
     */
    errorTooltip: QueryList<IgxTooltipDirective>;
    /**
     * @hidden
     * @internal
     */
    errorIcon: IgxIconComponent;
    /**
     * Gets the default error template.
     * @hidden @internal
     */
    defaultErrorTemplate: TemplateRef<any>;
    /**
     * Gets the column of the cell.
     * ```typescript
     *  let cellColumn = this.cell.column;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    column: ColumnType;
    /**
     * @hidden
     * @internal
     */
    isPlaceholder: boolean;
    /**
        Gets whether this cell is a merged cell.
     */
    isMerged: boolean;
    /**
     * @hidden
     * @internal
     */
    protected get formGroup(): FormGroup;
    /**
     * @hidden
     * @internal
     */
    intRow: IgxRowDirective;
    /**
     * Gets the row of the cell.
     * ```typescript
     * let cellRow = this.cell.row;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get row(): RowType;
    /**
     * Gets the data of the row of the cell.
     * ```typescript
     * let rowData = this.cell.rowData;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    rowData: any;
    /**
     * @hidden
     * @internal
     */
    columnData: any;
    /**
     * Sets/gets the template of the cell.
     * ```html
     * <ng-template #cellTemplate igxCell let-value>
     *   <div style="font-style: oblique; color:blueviolet; background:red">
     *       <span>{{value}}</span>
     *   </div>
     * </ng-template>
     * ```
     * ```typescript
     * @ViewChild('cellTemplate',{read: TemplateRef})
     * cellTemplate: TemplateRef<any>;
     * ```
     * ```typescript
     * this.cell.cellTemplate = this.cellTemplate;
     * ```
     * ```typescript
     * let template =  this.cell.cellTemplate;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    cellTemplate: TemplateRef<any>;
    cellValidationErrorTemplate: TemplateRef<any>;
    pinnedIndicator: TemplateRef<any>;
    /**
     * Sets/gets the cell value.
     * ```typescript
     * this.cell.value = "Cell Value";
     * ```
     * ```typescript
     * let cellValue = this.cell.value;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    value: any;
    /**
     * Gets the cell formatter.
     * ```typescript
     * let cellForamatter = this.cell.formatter;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    formatter: (value: any, rowData?: any, columnData?: any) => any;
    /**
     * Gets the cell template context object.
     * ```typescript
     *  let context = this.cell.context();
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get context(): IgxCellTemplateContext;
    /**
     * Gets the cell template.
     * ```typescript
     * let template = this.cell.template;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get template(): TemplateRef<any>;
    /**
     * Gets the pinned indicator template.
     * ```typescript
     * let template = this.cell.pinnedIndicatorTemplate;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get pinnedIndicatorTemplate(): TemplateRef<any>;
    /**
     * Gets the `id` of the grid in which the cell is stored.
     * ```typescript
     * let gridId = this.cell.gridID;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get gridID(): any;
    /**
     * Gets the `index` of the row where the cell is stored.
     * ```typescript
     * let rowIndex = this.cell.rowIndex;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get rowIndex(): number;
    /**
     * Gets the `index` of the cell column.
     * ```typescript
     * let columnIndex = this.cell.columnIndex;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get columnIndex(): number;
    /**
     * Returns the column visible index.
     * ```typescript
     * let visibleColumnIndex = this.cell.visibleColumnIndex;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get visibleColumnIndex(): number;
    set visibleColumnIndex(val: number);
    /**
     * Gets the ID of the cell.
     * ```typescript
     * let cellID = this.cell.cellID;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get cellID(): {
        rowID: any;
        columnID: number;
        rowIndex: number;
    };
    get attrCellID(): string;
    get title(): any;
    get booleanClass(): any;
    /**
     * Returns a reference to the nativeElement of the cell.
     * ```typescript
     * let cellNativeElement = this.cell.nativeElement;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get nativeElement(): HTMLElement;
    /**
     * @hidden
     * @internal
     */
    get cellSelectionMode(): GridSelectionMode;
    set cellSelectionMode(value: GridSelectionMode);
    /**
     * @hidden
     * @internal
     */
    set lastSearchInfo(value: ISearchInfo);
    /**
     * @hidden
     * @internal
     */
    lastPinned: boolean;
    /**
     * @hidden
     * @internal
     */
    firstPinned: boolean;
    /**
     * Returns whether the cell is in edit mode.
     */
    editMode: boolean;
    /**
     * Sets/get the `role` property of the cell.
     * Default value is `"gridcell"`.
     * ```typescript
     * this.cell.role = 'grid-cell';
     * ```
     * ```typescript
     * let cellRole = this.cell.role;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    role: string;
    /**
     * Gets whether the cell is editable.
     * ```typescript
     * let isCellReadonly = this.cell.readonly;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get readonly(): boolean;
    /** @hidden @internal */
    get ariaDescribeBy(): string;
    /** @hidden @internal */
    get ariaErrorMessage(): string;
    /**
     * @hidden
     * @internal
     */
    get isInvalid(): boolean;
    /**
     * @hidden
     * @internal
     */
    get isValidAfterEdit(): boolean;
    /**
     * Gets the formControl responsible for value changes and validation for this cell.
     */
    protected get formControl(): FormControl;
    get gridRowSpan(): number;
    get gridColumnSpan(): number;
    get rowEnd(): number;
    get colEnd(): number;
    get rowStart(): number;
    get colStart(): number;
    /**
     * Gets the width of the cell.
     * ```typescript
     * let cellWidth = this.cell.width;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    width: string;
    /**
     * @hidden
     */
    active: boolean;
    get ariaSelected(): boolean;
    /**
     * Gets whether the cell is selected.
     * ```typescript
     * let isSelected = this.cell.selected;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get selected(): boolean;
    /**
     * Selects/deselects the cell.
     * ```typescript
     * this.cell.selected = true.
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    set selected(val: boolean);
    /**
     * Gets whether the cell column is selected.
     * ```typescript
     * let isCellColumnSelected = this.cell.columnSelected;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get columnSelected(): boolean;
    /**
     * Sets the current edit value while a cell is in edit mode.
     * Only for cell editing mode.
     * ```typescript
     * this.cell.editValue = value;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    set editValue(value: any);
    /**
     * Gets the current edit value while a cell is in edit mode.
     * Only for cell editing mode.
     * ```typescript
     * let editValue = this.cell.editValue;
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    get editValue(): any;
    /**
     * Returns whether the cell is editable.
     */
    get editable(): boolean;
    /**
     * @hidden
     */
    displayPinnedChip: boolean;
    protected get minHeight(): number;
    protected get ariaRowIndex(): number;
    protected get ariaColIndex(): number;
    protected defaultCellTemplate: TemplateRef<any>;
    protected emptyCellTemplate: TemplateRef<any>;
    protected defaultPinnedIndicator: TemplateRef<any>;
    protected inlineEditorTemplate: TemplateRef<any>;
    protected addRowCellTemplate: TemplateRef<any>;
    protected set highlight(value: IgxTextHighlightDirective);
    protected get highlight(): IgxTextHighlightDirective;
    protected get selectionNode(): ISelectionNode;
    /**
     * Sets/gets the highlight class of the cell.
     * Default value is `"igx-highlight"`.
     * ```typescript
     * let highlightClass = this.cell.highlightClass;
     * ```
     * ```typescript
     * this.cell.highlightClass = 'igx-cell-highlight';
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    highlightClass: string;
    /**
     * Sets/gets the active highlight class class of the cell.
     * Default value is `"igx-highlight__active"`.
     * ```typescript
     * let activeHighlightClass = this.cell.activeHighlightClass;
     * ```
     * ```typescript
     * this.cell.activeHighlightClass = 'igx-cell-highlight_active';
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    activeHighlightClass: string;
    /** @hidden @internal */
    get step(): number;
    /** @hidden @internal */
    get currencyCode(): string;
    /** @hidden @internal */
    get currencyCodeSymbol(): string;
    protected _lastSearchInfo: ISearchInfo;
    private _highlight;
    private _cellSelection;
    private _vIndex;
    /**
     * @hidden
     * @internal
     */
    onDoubleClick: (event: MouseEvent) => void;
    /**
     * @hidden
     * @internal
     */
    onClick(event: MouseEvent): void;
    /**
     * @hidden
     * @internal
     */
    ngOnInit(): void;
    ngAfterViewInit(): void;
    /**
     * @hidden
     * @internal
     */
    errorShowing: boolean;
    private openErrorTooltip;
    /**
     * @hidden
     * @internal
     */
    ngOnDestroy(): void;
    /**
     * @hidden
     * @internal
     */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * @hidden @internal
     */
    private resizeAndRepositionOverlayById;
    /**
     * Starts/ends edit mode for the cell.
     *
     * ```typescript
     * cell.setEditMode(true);
     * ```
     */
    setEditMode(value: boolean): void;
    /**
     * Sets new value to the cell.
     * ```typescript
     * this.cell.update('New Value');
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    update(val: any): void;
    /**
     *
     * @hidden
     * @internal
     */
    pointerdown: (event: PointerEvent) => void;
    /**
     *
     * @hidden
     * @internal
     */
    pointerenter: (event: PointerEvent) => void;
    /**
     * @hidden
     * @internal
     */
    focusout: () => void;
    private closeErrorTooltip;
    /**
     * @hidden
     * @internal
     */
    pointerup: (event: PointerEvent) => void;
    /**
     * @hidden
     * @internal
     */
    activate(event: FocusEvent | KeyboardEvent): void;
    /**
     * If the provided string matches the text in the cell, the text gets highlighted.
     * ```typescript
     * this.cell.highlightText('Cell Value', true);
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    highlightText(text: string, caseSensitive?: boolean, exactMatch?: boolean): number;
    /**
     * Clears the highlight of the text in the cell.
     * ```typescript
     * this.cell.clearHighLight();
     * ```
     *
     * @memberof IgxGridCellComponent
     */
    clearHighlight(): void;
    /**
     * @hidden
     * @internal
     */
    calculateSizeToFit(range: any): number;
    /**
     * @hidden
     * @internal
     */
    get searchMetadata(): Map<string, any>;
    /**
     * @hidden
     * @internal
     */
    private _updateCRUDStatus;
    private addPointerListeners;
    private removePointerListeners;
    private getCellType;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridCellComponent, "igx-grid-cell", never, { "column": { "alias": "column"; "required": false; }; "isPlaceholder": { "alias": "isPlaceholder"; "required": false; }; "isMerged": { "alias": "isMerged"; "required": false; }; "intRow": { "alias": "intRow"; "required": false; }; "row": { "alias": "row"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; "columnData": { "alias": "columnData"; "required": false; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; }; "cellValidationErrorTemplate": { "alias": "cellValidationErrorTemplate"; "required": false; }; "pinnedIndicator": { "alias": "pinnedIndicator"; "required": false; }; "value": { "alias": "value"; "required": false; }; "formatter": { "alias": "formatter"; "required": false; }; "visibleColumnIndex": { "alias": "visibleColumnIndex"; "required": false; }; "cellSelectionMode": { "alias": "cellSelectionMode"; "required": false; }; "lastSearchInfo": { "alias": "lastSearchInfo"; "required": false; }; "lastPinned": { "alias": "lastPinned"; "required": false; }; "firstPinned": { "alias": "firstPinned"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "width": { "alias": "width"; "required": false; }; "active": { "alias": "active"; "required": false; }; "displayPinnedChip": { "alias": "displayPinnedChip"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_editMode: unknown;
}

/**
 * An internal component representing a base group-by drop area.
 *
 * @hidden @internal
 */
declare abstract class IgxGroupByAreaDirective {
    private ref;
    protected platform: PlatformUtil;
    /**
     * The drop area template if provided by the parent grid.
     * Otherwise, uses the default internal one.
     */
    dropAreaTemplate: TemplateRef<void>;
    defaultClass: boolean;
    /** The parent grid containing the component. */
    grid: FlatGridType | GridType;
    /**
     * The group-by expressions provided by the parent grid.
     */
    get expressions(): IGroupingExpression[];
    set expressions(value: IGroupingExpression[]);
    /**
     * The default message for the default drop area template.
     * Obviously, if another template is provided, this is ignored.
     */
    get dropAreaMessage(): string;
    set dropAreaMessage(value: string);
    expressionsChange: EventEmitter<IGroupingExpression[]>;
    chips: QueryList<IgxChipComponent>;
    chipExpressions: IGroupingExpression[];
    /** The native DOM element. Used in sizing calculations. */
    get nativeElement(): any;
    private _expressions;
    private _dropAreaMessage;
    get dropAreaVisible(): boolean;
    handleKeyDown(id: string, event: KeyboardEvent): void;
    handleClick(id: string): void;
    onDragDrop(event: any): void;
    protected getReorderedExpressions(chipsArray: IgxChipComponent[]): any[];
    protected updateGroupSorting(id: string): void;
    protected expressionsChanged(): void;
    abstract handleReorder(event: IChipsAreaReorderEventArgs): any;
    abstract handleMoveEnd(): any;
    abstract groupBy(expression: IGroupingExpression): any;
    abstract clearGrouping(name: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGroupByAreaDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGroupByAreaDirective, never, never, { "dropAreaTemplate": { "alias": "dropAreaTemplate"; "required": false; }; "grid": { "alias": "grid"; "required": false; }; "expressions": { "alias": "expressions"; "required": false; }; "dropAreaMessage": { "alias": "dropAreaMessage"; "required": false; }; }, { "expressionsChange": "expressionsChange"; }, never, never, true, never>;
}
/**
 * A pipe to circumvent the use of getters/methods just to get some additional
 * information from the grouping expression and pass it to the chip representing
 * that expression.
 *
 * @hidden @internal
 */
declare class IgxGroupByMetaPipe implements PipeTransform {
    transform(key: string, grid: GridType, _pipeTrigger?: number): {
        groupable: boolean;
        title: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGroupByMetaPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxGroupByMetaPipe, "igxGroupByMeta", true>;
}

/**
 * An internal component representing the group-by drop area for the igx-grid component.
 *
 * @hidden @internal
 */
declare class IgxGridGroupByAreaComponent extends IgxGroupByAreaDirective {
    sortingExpressions: ISortingExpression[];
    /** The parent grid containing the component. */
    grid: FlatGridType;
    handleReorder(event: IChipsAreaReorderEventArgs): void;
    handleMoveEnd(): void;
    groupBy(expression: IGroupingExpression): void;
    clearGrouping(name: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridGroupByAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxGridGroupByAreaComponent, "igx-grid-group-by-area", never, { "sortingExpressions": { "alias": "sortingExpressions"; "required": false; }; "grid": { "alias": "grid"; "required": false; }; }, {}, never, never, true, never>;
}

/** @hidden */
declare class IgxGridMRLNavigationService extends IgxGridNavigationService {
    isValidPosition(rowIndex: number, colIndex: number): boolean;
    shouldPerformVerticalScroll(targetRowIndex: number, visibleColIndex: number): boolean;
    isColumnFullyVisible(visibleColIndex: number): boolean;
    getVerticalScrollPositions(rowIndex: number, visibleIndex: number): {
        topOffset: number;
        rowTop: any;
        rowBottom: any;
    };
    performHorizontalScrollToCell(visibleColumnIndex: number, cb?: () => void): void;
    performVerticalScrollToCell(rowIndex: number, visibleColIndex: number, cb?: () => void): void;
    getNextHorizontalCellPosition(previous?: boolean): {
        row: number;
        column: number;
    };
    getNextVerticalPosition(previous?: boolean): {
        row: number;
        column: any;
    };
    headerNavigation(event: KeyboardEvent): void;
    /**
     * @hidden
     * @internal
     */
    layout(visibleIndex: any): {
        colStart: number;
        rowStart: number;
        colEnd: number;
        rowEnd: number;
        columnVisibleIndex: number;
    };
    protected getNextPosition(rowIndex: number, colIndex: number, key: string, shift: boolean, ctrl: boolean, event: KeyboardEvent): {
        rowIndex: number;
        colIndex: number;
    };
    protected horizontalNav(event: KeyboardEvent, key: string, rowIndex: number, tag: GridKeydownTargetType): void;
    private isParentColumnFullyVisible;
    private getChildColumnScrollPositions;
    private getNextRowIndex;
    private getPreviousRowIndex;
    private get lastIndexPerRow();
    private get firstIndexPerRow();
    private get lastLayoutIndex();
    private get scrollTop();
    private lastColIndexPerMRLBlock;
    private lastRowStartPerBlock;
    private rowEnd;
    private parentByChildIndex;
    private hasNextHorizontalPosition;
    private hasNextVerticalPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridMRLNavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxGridMRLNavigationService>;
}

/**
 * @hidden
 */
declare class GridBaseAPIService<T extends GridType> implements GridServiceType {
    crudService: IgxGridCRUDService;
    cms: IgxColumnMovingService;
    grid: T;
    protected destroyMap: Map<string, Subject<boolean>>;
    get_column_by_name(name: string): ColumnType;
    get_summary_data(): any[] | null;
    /**
     * @hidden
     * @internal
     */
    getRowData(rowID: any): any;
    get_row_index_in_data(rowID: any, dataCollection?: any[]): number;
    get_row_by_key(rowSelector: any): RowType;
    get_row_by_index(rowIndex: number): RowType;
    /**
     * Gets the rowID of the record at the specified data view index
     *
     * @param index
     * @param dataCollection
     */
    get_rec_id_by_index(index: number, dataCollection?: any[]): any;
    get_cell_by_key(rowSelector: any, field: string): CellType;
    get_cell_by_index(rowIndex: number, columnID: number | string): CellType;
    get_cell_by_visible_index(rowIndex: number, columnIndex: number): CellType;
    update_cell(cell: IgxCell): IGridEditEventArgs;
    update_row(row: IgxEditRow, value: any, event?: Event): IGridEditEventArgs;
    sort(expression: ISortingExpression): void;
    sort_decoupled(expression: IGroupingExpression): void;
    sort_multiple(expressions: ISortingExpression[]): void;
    sort_groupBy_multiple(expressions: ISortingExpression[]): void;
    clear_sort(fieldName: string): void;
    clear_groupby(_name?: string | Array<string>): void;
    should_apply_number_style(column: ColumnType): boolean;
    get_data(): any[];
    get_all_data(includeTransactions?: boolean): any[];
    get_filtered_data(): any[];
    addRowToData(rowData: any, _parentID?: any): void;
    deleteRowFromData(rowID: any, index: number): void;
    deleteRowById(rowId: any): any;
    get_row_id(rowData: any): any;
    row_deleted_transaction(rowID: any): boolean;
    get_row_expansion_state(record: any): boolean;
    set_row_expansion_state(rowID: any, expanded: boolean, event?: Event): void;
    get_rec_by_id(rowID: any): any;
    /**
     * Returns the index of the record in the data view by pk or -1 if not found or primaryKey is not set.
     *
     * @param pk
     * @param dataCollection
     */
    get_rec_index_by_id(pk: string | number, dataCollection?: any[]): number;
    allow_expansion_state_change(rowID: any, expanded: any): boolean;
    prepare_sorting_expression(stateCollections: Array<Array<any>>, expression: ISortingExpression): void;
    prepare_grouping_expression(stateCollections: Array<Array<any>>, expression: IGroupingExpression): void;
    remove_grouping_expression(_fieldName: any): void;
    filterDataByExpressions(expressionsTree: IFilteringExpressionsTree): any[];
    sortDataByExpressions(data: any[], expressions: ISortingExpression[]): any[];
    pin_row(rowID: any, index?: number, row?: RowType): void;
    unpin_row(rowID: any, row: RowType): void;
    get_pin_row_event_args(rowID: any, index?: number, row?: RowType, pinned?: boolean): IPinRowEventArgs;
    /**
     * Updates related row of provided grid's data source with provided new row value
     *
     * @param grid Grid to update data for
     * @param rowID ID of the row to update
     * @param rowValueInDataSource Initial value of the row as it is in data source
     * @param rowCurrentValue Current value of the row as it is with applied previous transactions
     * @param rowNewValue New value of the row
     */
    protected updateData(grid: any, rowID: any, rowValueInDataSource: any, rowCurrentValue: any, rowNewValue: {
        [x: string]: any;
    }): void;
    protected update_row_in_array(value: any, rowID: any, index: number): void;
    protected getSortStrategyPerColumn(fieldName: string): igniteui_angular_core.ISortingStrategy;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridBaseAPIService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GridBaseAPIService<any>>;
}

declare class PivotUtil {
    static processGroups(recs: IPivotGridRecord[], dimension: IPivotDimension, pivotKeys: IPivotKeys, cloneStrategy: IDataCloneStrategy): void;
    static flattenGroups(data: IPivotGridRecord[], dimension: IPivotDimension, expansionStates: any, defaultExpand: boolean, parent?: IPivotDimension, parentRec?: IPivotGridRecord): void;
    static flattenGroupsHorizontally(data: IPivotGridRecord[], dimension: IPivotDimension, expansionStates: any, defaultExpand: boolean, visibleDimensions: IPivotDimension[], summariesPosition: PivotSummaryPosition, parent?: IPivotDimension, parentRec?: IPivotGridRecord): void;
    static assignLevels(dims: any): void;
    static getFieldsHierarchy(data: any[], dimensions: IPivotDimension[], dimensionType: PivotDimensionType, pivotKeys: IPivotKeys, cloneStrategy: IDataCloneStrategy): Map<string, any>;
    static sort(data: IPivotGridRecord[], expressions: ISortingExpression[], sorting?: IGridSortingStrategy): any[];
    static extractValueFromDimension(dim: IPivotDimension, recData: any): any;
    static getDimensionDepth(dim: IPivotDimension): number;
    static extractValuesForRow(dims: IPivotDimension[], recData: any, pivotKeys: IPivotKeys, cloneStrategy: IDataCloneStrategy): Map<string, any>;
    static extractValuesForColumn(dims: IPivotDimension[], recData: any, pivotKeys: IPivotKeys, path?: any[]): Map<string, any>;
    static flatten(arr: any, lvl?: number): any;
    static applyAggregations(rec: IPivotGridRecord, hierarchies: any, values: any, pivotKeys: IPivotKeys): void;
    protected static applyAggregationRecordData(aggregationData: any, groupName: string, rec: IPivotGridRecord, pivotKeys: IPivotKeys): void;
    static aggregate(records: any, values: IPivotValue[]): {};
    static getAggregatorForType(aggregate: IPivotAggregator, dataType: GridColumnDataType): (members: any[], data?: any[]) => any;
    static processHierarchy(hierarchies: any, pivotKeys: any, level?: number, rootData?: boolean): IPivotGridRecord[];
    static getDirectLeafs(records: IPivotGridRecord[]): any[];
    static getRecordKey(rec: IPivotGridRecord, currentDim: IPivotDimension): string;
    static buildExpressionTree(config: IPivotConfiguration): FilteringExpressionsTree;
    private static collectRecords;
    private static applyHierarchyChildren;
    static getAggregateList(val: IPivotValue, grid: PivotGridType): IPivotAggregator[];
    static getAggregatorsForValue(value: IPivotValue, grid: PivotGridType): IPivotAggregator[];
    static updateColumnTypeByAggregator(columns: any[], value: IPivotValue, isSingleValue: boolean): void;
    private static getColumnDataTypeForValue;
}

interface IPivotDateDimensionOptions {
    /** Enables/Disables total value of all periods. */
    total?: boolean;
    /** Enables/Disables dimensions per year from provided periods. */
    years?: boolean;
    quarters?: boolean;
    /** Enables/Disables dimensions per month from provided periods. */
    months?: boolean;
    /** Enabled/Disables dimensions for the full date provided */
    fullDate?: boolean;
}
declare class IgxPivotDateDimension implements IPivotDimension {
    /** Enables/Disables a particular dimension from pivot structure. */
    enabled: boolean;
    /**
     * Gets/Sets data type
     */
    dataType?: GridColumnDataType;
    /** Default options. */
    defaultOptions: {
        total: boolean;
        years: boolean;
        months: boolean;
        fullDate: boolean;
    };
    /**
     * Gets/Sets the resource strings.
     *
     * @remarks
     * By default it uses EN resources.
     */
    set resourceStrings(value: IGridResourceStrings);
    get resourceStrings(): IGridResourceStrings;
    /**
     * Gets/Sets the base dimension that is used by this class to determine the other dimensions and their values.
     * Having base dimension set is required in order for the Date Dimensions to show.
     */
    get baseDimension(): IPivotDimension;
    set baseDimension(value: IPivotDimension);
    /**
     * Gets/Sets the options for the predefined date dimensions whether to show quarter, years and etc.
     */
    get options(): IPivotDateDimensionOptions;
    set options(value: IPivotDateDimensionOptions);
    /** @hidden @internal */
    childLevel?: IPivotDimension;
    /** @hidden @internal */
    memberName: string;
    displayName: string;
    private _resourceStrings;
    private _baseDimension;
    private _options;
    private _monthIntl;
    /**
     * Creates additional pivot date dimensions based on a provided dimension describing date data:
     *
     * @param inDateDimension Base dimension that is used by this class to determine the other dimensions and their values.
     * @param inOptions Options for the predefined date dimensions whether to show quarter, years and etc.
     * @example
     * ```typescript
     * // Displays only years as parent dimension to the base dimension provided.
     * new IgxPivotDateDimension({ memberName: 'Date', enabled: true }, { total: false, months: false });
     * ```
     */
    constructor(inBaseDimension?: IPivotDimension, inOptions?: IPivotDateDimensionOptions);
    protected initialize(inBaseDimension: any, inOptions: any): void;
    /** @hidden @internal */
    memberFunction: (_data: any) => string;
}

declare class IgxPivotAggregate {
    /**
     * Gets array with default aggregator function for base aggregation.
     * ```typescript
     * IgxPivotAggregate.aggregators();
     * ```
     *
     * @memberof IgxPivotAggregate
     */
    static aggregators(): Array<IPivotAggregator>;
    /**
     * Counts all the records in the data source.
     * If filtering is applied, counts only the filtered records.
     * ```typescript
     * IgxSummaryOperand.count(dataSource);
     * ```
     *
     * @memberof IgxPivotAggregate
     */
    static count(members: number[]): number;
}
declare class IgxPivotNumericAggregate extends IgxPivotAggregate {
    /**
     * Gets array with default aggregator function for numeric aggregation.
     * ```typescript
     * IgxPivotAggregate.aggregators();
     * ```
     *
     * @memberof IgxPivotAggregate
     */
    static aggregators(): IPivotAggregator[];
    /**
     * Returns the minimum numeric value in the provided data records.
     * If filtering is applied, returns the minimum value in the filtered data records.
     * ```typescript
     * IgxPivotNumericAggregate.min(members, data);
     * ```
     *
     * @memberof IgxPivotNumericAggregate
     */
    static min(members: number[]): number;
    /**
     * Returns the maximum numeric value in the provided data records.
     * If filtering is applied, returns the maximum value in the filtered data records.
     * ```typescript
     * IgxPivotNumericAggregate.max(data);
     * ```
     *
     * @memberof IgxPivotNumericAggregate
     */
    static max(members: number[]): number;
    /**
     * Returns the sum of the numeric values in the provided data records.
     * If filtering is applied, returns the sum of the numeric values in the data records.
     * ```typescript
     * IgxPivotNumericAggregate.sum(data);
     * ```
     *
     * @memberof IgxPivotNumericAggregate
     */
    static sum(members: number[]): number;
    /**
     * Returns the average numeric value in the data provided data records.
     * If filtering is applied, returns the average numeric value in the filtered data records.
     * ```typescript
     * IgxPivotNumericAggregate.average(data);
     * ```
     *
     * @memberof IgxPivotNumericAggregate
     */
    static average(members: number[]): number;
}
declare class IgxPivotDateAggregate extends IgxPivotAggregate {
    /**
     * Gets array with default aggregator function for date aggregation.
     * ```typescript
     * IgxPivotDateAggregate.aggregators();
     * ```
     *
     * @memberof IgxPivotAggregate
     */
    static aggregators(): IPivotAggregator[];
    /**
     * Returns the latest date value in the data records.
     * If filtering is applied, returns the latest date value in the filtered data records.
     * ```typescript
     * IgxPivotDateAggregate.latest(data);
     * ```
     *
     * @memberof IgxPivotDateAggregate
     */
    static latest(members: any[]): any;
    /**
     * Returns the earliest date value in the data records.
     * If filtering is applied, returns the latest date value in the filtered data records.
     * ```typescript
     * IgxPivotDateAggregate.earliest(data);
     * ```
     *
     * @memberof IgxPivotDateAggregate
     */
    static earliest(members: any[]): any;
}
declare class IgxPivotTimeAggregate extends IgxPivotAggregate {
    /**
     * Gets array with default aggregator function for time aggregation.
     * ```typescript
     * IgxPivotTimeAggregate.aggregators();
     * ```
     *
     * @memberof IgxPivotAggregate
     */
    static aggregators(): IPivotAggregator[];
    /**
     * Returns the latest time value in the data records. Compare only the time part of the date.
     * If filtering is applied, returns the latest time value in the filtered data records.
     * ```typescript
     * IgxPivotTimeAggregate.latestTime(data);
     * ```
     *
     * @memberof IgxPivotTimeAggregate
     */
    static latestTime(members: any[]): any;
    /**
     * Returns the earliest time value in the data records. Compare only the time part of the date.
     * If filtering is applied, returns the earliest time value in the filtered data records.
     * ```typescript
     * IgxPivotTimeAggregate.earliestTime(data);
     * ```
     *
     * @memberof IgxPivotTimeAggregate
     */
    static earliestTime(members: any[]): any;
}

/**
 * @hidden
 */
declare function WatchChanges(): PropertyDecorator;
declare function WatchColumnChanges(): PropertyDecorator;
declare function notifyChanges(repaint?: boolean): (_: any, key: string, propDesc?: PropertyDescriptor) => any;

/**
 * @hidden
 */
declare class ExportUtilities {
    static getKeysFromData(data: any[]): string[];
    static saveBlobToFile(blob: Blob, fileName: any): void;
    static stringToArrayBuffer(s: string): ArrayBuffer;
    static isSpecialData(data: any): boolean;
    static hasValue(value: any): boolean;
    static isNullOrWhitespaces(value: string): boolean;
    static sanitizeValue(value: any): string;
}

interface ICsvExportEndedEventArgs extends IBaseEventArgs {
    csvData?: string;
}
/**
 * **Ignite UI for Angular CSV Exporter Service** -
 * [Documentation](https://www.infragistics.com/products/ignite-ui-angular/angular/components/exporter-csv)
 *
 * The Ignite UI for Angular CSV Exporter service can export data in a Character Separated Values format from
 * both raw data (array) or from an `IgxGrid`.
 *
 * Example:
 * ```typescript
 * public localData = [
 *   { Name: "Eric Ridley", Age: "26" },
 *   { Name: "Alanis Brook", Age: "22" },
 *   { Name: "Jonathan Morris", Age: "23" }
 * ];
 *
 * constructor(private csvExportService: IgxCsvExporterService) {
 * }
 *
 * const opt: IgxCsvExporterOptions = new IgxCsvExporterOptions("FileName", CsvFileTypes.CSV);
 * this.csvExportService.exportData(this.localData, opt);
 * ```
 */
declare class IgxCsvExporterService extends IgxBaseExporter {
    /**
     * This event is emitted when the export process finishes.
     * ```typescript
     * this.exporterService.exportEnded.subscribe((args: ICsvExportEndedEventArgs) => {
     * // put event handler code here
     * });
     * ```
     *
     * @memberof IgxCsvExporterService
     */
    exportEnded: EventEmitter<ICsvExportEndedEventArgs>;
    private _stringData;
    protected exportDataImplementation(data: IExportRecord[], options: IgxCsvExporterOptions, done: () => void): void;
    private saveFile;
    private exportFile;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxCsvExporterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxCsvExporterService>;
}

/**
 * @hidden
 */
declare class CharSeparatedValueData {
    private _data;
    private columns;
    private _headerRecord;
    private _dataRecords;
    private _eor;
    private _delimiter;
    private _escapeCharacters;
    private _delimiterLength;
    private _isSpecialData;
    constructor(_data: any[], valueDelimiter: string, columns?: IColumnInfo[]);
    prepareData(key?: any[]): string;
    prepareDataAsync(done: (result: string) => void): void;
    private processField;
    private processHeaderRecord;
    private processRecord;
    private processDataRecords;
    private processDataRecordsAsync;
    private setDelimiter;
}

interface IExcelExportEndedEventArgs extends IBaseEventArgs {
    xlsx?: Object;
}
/**
 * **Ignite UI for Angular Excel Exporter Service** -
 * [Documentation](https://www.infragistics.com/products/ignite-ui-angular/angular/components/exporter_excel.html)
 *
 * The Ignite UI for Angular Excel Exporter service can export data in Microsoft® Excel® format from both raw data
 * (array) or from an `IgxGrid`.
 *
 * Example:
 * ```typescript
 * public localData = [
 *   { Name: "Eric Ridley", Age: "26" },
 *   { Name: "Alanis Brook", Age: "22" },
 *   { Name: "Jonathan Morris", Age: "23" }
 * ];
 *
 * constructor(private excelExportService: IgxExcelExporterService) {
 * }
 *
 * this.excelExportService.exportData(this.localData, new IgxExcelExporterOptions("FileName"));
 * ```
 */
declare class IgxExcelExporterService extends IgxBaseExporter {
    /**
     * This event is emitted when the export process finishes.
     * ```typescript
     * this.exporterService.exportEnded.subscribe((args: IExcelExportEndedEventArgs) => {
     * // put event handler code here
     * });
     * ```
     *
     * @memberof IgxExcelExporterService
     */
    exportEnded: EventEmitter<IExcelExportEndedEventArgs>;
    private static populateZipFileConfig;
    protected exportDataImplementation(data: IExportRecord[], options: IgxExcelExporterOptions, done: () => void): void;
    private saveFile;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxExcelExporterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxExcelExporterService>;
}

interface IPdfExportEndedEventArgs extends IBaseEventArgs {
    pdf?: jsPDF;
}
/**
 * **Ignite UI for Angular PDF Exporter Service** -
 * [Documentation](https://www.infragistics.com/products/ignite-ui-angular/angular/components/exporter_pdf.html)
 *
 * The Ignite UI for Angular PDF Exporter service can export data in PDF format from both raw data
 * (array) or from an `IgxGrid`.
 *
 * Example:
 * ```typescript
 * public localData = [
 *   { Name: "Eric Ridley", Age: "26" },
 *   { Name: "Alanis Brook", Age: "22" },
 *   { Name: "Jonathan Morris", Age: "23" }
 * ];
 *
 * constructor(private pdfExportService: IgxPdfExporterService) {
 * }
 *
 * this.pdfExportService.exportData(this.localData, new IgxPdfExporterOptions("FileName"));
 * ```
 */
declare class IgxPdfExporterService extends IgxBaseExporter {
    /**
     * This event is emitted when the export process finishes.
     * ```typescript
     * this.exporterService.exportEnded.subscribe((args: IPdfExportEndedEventArgs) => {
     * // put event handler code here
     * });
     * ```
     *
     * @memberof IgxPdfExporterService
     */
    exportEnded: EventEmitter<IPdfExportEndedEventArgs>;
    protected exportDataImplementation(data: IExportRecord[], options: IgxPdfExporterOptions, done: () => void): void;
    private drawMultiLevelHeaders;
    private drawHierarchicalChildren;
    private drawTableHeaders;
    private drawDataRow;
    private saveFile;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxPdfExporterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxPdfExporterService>;
}

declare const IGX_GRID_COMMON_DIRECTIVES: readonly [typeof IgxRowDirective, typeof IgxGridFooterComponent, typeof IgxAdvancedFilteringDialogComponent, typeof IgxRowExpandedIndicatorDirective, typeof IgxRowCollapsedIndicatorDirective, typeof IgxHeaderExpandedIndicatorDirective, typeof IgxHeaderCollapsedIndicatorDirective, typeof IgxExcelStyleHeaderIconDirective, typeof IgxSortAscendingHeaderIconDirective, typeof IgxSortDescendingHeaderIconDirective, typeof IgxSortHeaderIconDirective, typeof IgxGridEmptyTemplateDirective, typeof IgxGridLoadingTemplateDirective, typeof IgxDragIndicatorIconDirective, typeof IgxRowDragGhostDirective, typeof IgxGridStateDirective, typeof IgxGridHeaderComponent, typeof IgxGridHeaderGroupComponent, typeof IgxGridHeaderRowComponent, typeof IgxFilterCellTemplateDirective, typeof IgxSummaryTemplateDirective, typeof IgxCellTemplateDirective, typeof IgxCellValidationErrorDirective, typeof IgxCellHeaderTemplateDirective, typeof IgxCellFooterTemplateDirective, typeof IgxCellEditorTemplateDirective, typeof IgxCollapsibleIndicatorTemplateDirective, typeof IgxColumnComponent, typeof IgxColumnGroupComponent, typeof IgxColumnLayoutComponent, typeof IgxColumnActionsComponent, typeof IgxColumnHidingDirective, typeof IgxColumnPinningDirective, typeof IgxRowSelectorDirective, typeof IgxGroupByRowSelectorDirective, typeof IgxHeadSelectorDirective, typeof IgxCSVTextDirective, typeof IgxExcelTextDirective, typeof IgxGridToolbarActionsComponent, typeof IgxGridToolbarAdvancedFilteringComponent, typeof IgxGridToolbarComponent, typeof IgxGridToolbarExporterComponent, typeof IgxGridToolbarHidingComponent, typeof IgxGridToolbarPinningComponent, typeof IgxGridToolbarTitleComponent, typeof IgxGridToolbarDirective, typeof IgxGridExcelStyleFilteringComponent, typeof IgxExcelStyleHeaderComponent, typeof IgxExcelStyleSortingComponent, typeof IgxExcelStylePinningComponent, typeof IgxExcelStyleHidingComponent, typeof IgxExcelStyleSelectingComponent, typeof IgxExcelStyleClearFiltersComponent, typeof IgxExcelStyleConditionalFilterComponent, typeof IgxExcelStyleMovingComponent, typeof IgxExcelStyleSearchComponent, typeof IgxExcelStyleColumnOperationsTemplateDirective, typeof IgxExcelStyleFilterOperationsTemplateDirective, typeof IgxExcelStyleLoadingValuesTemplateDirective, typeof IgxGridPinningActionsComponent, typeof IgxGridEditingActionsComponent, typeof IgxGridActionsBaseDirective, typeof IgxGridActionButtonComponent];

export { ActiveElement, CharSeparatedValueData, ColumnDisplayOrder, CsvFileTypes, DEFAULT_OWNER, DEFAULT_PIVOT_KEYS, DimensionValuesFilteringStrategy, DropPosition, ExportHeaderType, ExportRecordType, ExportUtilities, ExpressionUI, FilterListItem, FilterMode, GRID_LEVEL_COL, GRID_PARENT, GRID_ROOT_SUMMARY, GridBaseAPIService, GridCellMergeMode, GridPagingMode, GridSelectionMode, GridSummaryPosition, IGX_GRID_BASE, IGX_GRID_COMMON_DIRECTIVES, IGX_GRID_SERVICE_BASE, IGX_GRID_VALIDATION_DIRECTIVES, INPUT_DEBOUNCE_TIME, IgxAddRow, IgxAdvancedFilteringDialogComponent, IgxBaseExporter, IgxCSVTextDirective, IgxCell, IgxCellCrudState, IgxCellEditorTemplateDirective, IgxCellFooterTemplateDirective, IgxCellHeaderTemplateDirective, IgxCellTemplateDirective, IgxCellValidationErrorDirective, IgxCollapsibleIndicatorTemplateDirective, IgxColumnActionsBaseDirective, IgxColumnActionsComponent, IgxColumnComponent, IgxColumnEmailValidatorDirective, IgxColumnFormatterPipe, IgxColumnGroupComponent, IgxColumnHidingDirective, IgxColumnLayoutComponent, IgxColumnMaxLengthValidatorDirective, IgxColumnMaxValidatorDirective, IgxColumnMinLengthValidatorDirective, IgxColumnMinValidatorDirective, IgxColumnMovingDragDirective, IgxColumnMovingDropDirective, IgxColumnMovingService, IgxColumnPatternValidatorDirective, IgxColumnPinningDirective, IgxColumnRequiredValidatorDirective, IgxColumnResizerDirective, IgxColumnResizingService, IgxCsvExporterOptions, IgxCsvExporterService, IgxDateSummaryOperand, IgxDragIndicatorIconDirective, IgxEditRow, IgxExcelExporterOptions, IgxExcelExporterService, IgxExcelStyleClearFiltersComponent, IgxExcelStyleColumnOperationsTemplateDirective, IgxExcelStyleConditionalFilterComponent, IgxExcelStyleDateExpressionComponent, IgxExcelStyleFilterOperationsTemplateDirective, IgxExcelStyleHeaderComponent, IgxExcelStyleHeaderIconDirective, IgxExcelStyleHidingComponent, IgxExcelStyleLoadingValuesTemplateDirective, IgxExcelStyleMovingComponent, IgxExcelStylePinningComponent, IgxExcelStyleSearchComponent, IgxExcelStyleSelectingComponent, IgxExcelStyleSortingComponent, IgxExcelTextDirective, IgxExporterOptionsBase, IgxFilterCellTemplateDirective, IgxFilteringService, IgxGridActionButtonComponent, IgxGridActionsBaseDirective, IgxGridAddRowPipe, IgxGridBodyDirective, IgxGridCRUDService, IgxGridCell, IgxGridCellComponent, IgxGridCellImageAltPipe, IgxGridCellStyleClassesPipe, IgxGridCellStylesPipe, IgxGridColumnResizerComponent, IgxGridDataMapperPipe, IgxGridDetailTemplateDirective, IgxGridDragSelectDirective, IgxGridEditingActionsComponent, IgxGridEmptyTemplateDirective, IgxGridExcelStyleFilteringComponent, IgxGridFilterConditionPipe, IgxGridFilteringCellComponent, IgxGridFilteringRowComponent, IgxGridFooterComponent, IgxGridGroupByAreaComponent, IgxGridHeaderComponent, IgxGridHeaderGroupComponent, IgxGridHeaderRowComponent, IgxGridLoadingTemplateDirective, IgxGridMRLNavigationService, IgxGridNavigationService, IgxGridNotGroupedPipe, IgxGridPaginatorOptionsPipe, IgxGridPinningActionsComponent, IgxGridRow, IgxGridRowClassesPipe, IgxGridRowPinningPipe, IgxGridRowStylesPipe, IgxGridSelectionService, IgxGridStateBaseDirective, IgxGridStateDirective, IgxGridSummaryService, IgxGridToolbarActionsComponent, IgxGridToolbarAdvancedFilteringComponent, IgxGridToolbarComponent, IgxGridToolbarDirective, IgxGridToolbarExporterComponent, IgxGridToolbarHidingComponent, IgxGridToolbarPinningComponent, IgxGridToolbarTitleComponent, IgxGridTopLevelColumns, IgxGridTransaction, IgxGridTransactionPipe, IgxGridTransactionStatePipe, IgxGridValidationService, IgxGroupAreaDropDirective, IgxGroupByAreaDirective, IgxGroupByMetaPipe, IgxGroupByRow, IgxGroupByRowSelectorDirective, IgxGroupByRowTemplateDirective, IgxHasVisibleColumnsPipe, IgxHeadSelectorDirective, IgxHeaderCollapsedIndicatorDirective, IgxHeaderExpandedIndicatorDirective, IgxHeaderGroupStylePipe, IgxHierarchicalGridRow, IgxNumberSummaryOperand, IgxPdfExporterOptions, IgxPdfExporterService, IgxPdfTextDirective, IgxPivotAggregate, IgxPivotColumnResizingService, IgxPivotDateAggregate, IgxPivotDateDimension, IgxPivotGridColumnResizerComponent, IgxPivotNumericAggregate, IgxPivotResizeHandleDirective, IgxPivotTimeAggregate, IgxRowAddCrudState, IgxRowAddTextDirective, IgxRowCollapsedIndicatorDirective, IgxRowCrudState, IgxRowDirective, IgxRowDragDirective, IgxRowDragGhostDirective, IgxRowEditActionsDirective, IgxRowEditTabStopDirective, IgxRowEditTemplateDirective, IgxRowEditTextDirective, IgxRowExpandedIndicatorDirective, IgxRowSelectorDirective, IgxSortAscendingHeaderIconDirective, IgxSortDescendingHeaderIconDirective, IgxSortHeaderIconDirective, IgxStringReplacePipe, IgxSummaryDataPipe, IgxSummaryFormatterPipe, IgxSummaryOperand, IgxSummaryRow, IgxSummaryRowComponent, IgxSummaryTemplateDirective, IgxTimeSummaryOperand, IgxToolbarToken, IgxTreeGridRow, NoopPivotDimensionsStrategy, PivotColumnDimensionsStrategy, PivotDimensionType, PivotRowDimensionsStrategy, PivotRowLayoutType, PivotSummaryPosition, PivotUtil, RowEditPositionStrategy, RowPinningPosition, SortingIndexPipe, WatchChanges, WatchColumnChanges, generateExpressionsList, getUUID, notifyChanges };
export type { CellType, ColumnGroupsCache, DimensionValueType, FlatGridType, GridFeatures, GridKeydownTargetType, GridSVGIcon, GridSelectionRange, GridServiceType, GridType, GridValidationTrigger, HeaderType, HierarchicalGridType, IActiveNode, IActiveNodeChangeEventArgs, ICellPosition, IClipboardOptions, IColumnExportingEventArgs, IColumnInfo, IColumnList, IColumnMovingEndEventArgs, IColumnMovingEventArgs, IColumnMovingStartEventArgs, IColumnResizeEventArgs, IColumnResizingEventArgs, IColumnSelectionEventArgs, IColumnSelectionState, IColumnState, IColumnToggledEventArgs, IColumnVisibilityChangedEventArgs, IColumnVisibilityChangingEventArgs, IColumnsAutoGeneratedEventArgs, ICsvExportEndedEventArgs, IDimensionsChange, IExcelExportEndedEventArgs, IExportRecord, IFieldValidationState, IFilteringEventArgs, IGridCellEventArgs, IGridClipboardEvent, IGridContextMenuEventArgs, IGridDataBindable, IGridEditDoneEventArgs, IGridEditEventArgs, IGridFormGroupCreatedEventArgs, IGridKeydownEventArgs, IGridRowEventArgs, IGridScrollEventArgs, IGridState, IGridStateCollection, IGridStateOptions, IGridToolbarExportEventArgs, IGridValidationState, IGridValidationStatusEventArgs, IMultiRowLayoutNode, IPdfExportEndedEventArgs, IPinColumnCancellableEventArgs, IPinColumnEventArgs, IPinRowEventArgs, IPinningConfig, IPivotAggregator, IPivotConfiguration, IPivotConfigurationChangedEventArgs, IPivotDateDimensionOptions, IPivotDimension, IPivotDimensionData, IPivotDimensionStrategy, IPivotGridColumn, IPivotGridGroupRecord, IPivotGridHorizontalGroup, IPivotGridRecord, IPivotKeys, IPivotUISettings, IPivotValue, IRecordValidationState, IRowDataCancelableEventArgs, IRowDataEventArgs, IRowDragEndEventArgs, IRowDragStartEventArgs, IRowExportingEventArgs, IRowSelectionEventArgs, IRowToggleEventArgs, ISearchInfo, ISelectionKeyboardState, ISelectionNode, ISelectionPointerState, ISizeInfo, ISortingEventArgs, IValuesChange, IgxAddRowParent, IgxCellTemplateContext, IgxColumnTemplateContext, IgxExporterEvent, IgxExporterOptions, IgxGridEmptyTemplateContext, IgxGridHeaderTemplateContext, IgxGridMasterDetailContext, IgxGridPaginatorTemplateContext, IgxGridRowDragGhostContext, IgxGridRowEditActionsTemplateContext, IgxGridRowEditTemplateContext, IgxGridRowEditTextTemplateContext, IgxGridRowTemplateContext, IgxGridTemplateContext, IgxGridToolbarTemplateContext, IgxGroupByRowSelectorTemplateContext, IgxGroupByRowSelectorTemplateDetails, IgxGroupByRowTemplateContext, IgxHeadSelectorTemplateContext, IgxHeadSelectorTemplateDetails, IgxPivotGridValueTemplateContext, IgxRowSelectorTemplateContext, IgxRowSelectorTemplateDetails, IgxSummaryTemplateContext, PivotAggregation, PivotAggregationType, PivotGridType, PivotRowHeaderGroupType, RowEditPositionSettings, RowType, SelectionState, TreeGridType, ValidationStatus };