import * as i0 from '@angular/core'; import { TemplateRef, Signal, EventEmitter, ElementRef, InjectionToken, OnDestroy, Injector, OnInit, AfterViewInit, NgZone, OnChanges, SimpleChanges, PipeTransform } from '@angular/core'; import { SearchInput } from '@fundamental-ngx/platform/search-field'; import { DataSource, SelectItem, PresetManagedComponent } from '@fundamental-ngx/platform/shared'; import * as rxjs from 'rxjs'; import { Observable, BehaviorSubject, Subject } from 'rxjs'; import { Nullable, FdDndDropEventMode, FdDndDropType, DropPredicate, DragoverPredicate, FdDropEvent, FocusableGridDirective, FocusableCellPosition, FocusableItemPosition } from '@fundamental-ngx/cdk/utils'; import { ContentDensityObserver, ContentDensityMode } from '@fundamental-ngx/core/content-density'; import { FdLanguageKeyIdentifier } from '@fundamental-ngx/i18n'; import { DatetimeAdapter, FdDate } from '@fundamental-ngx/core/datetime'; import { TableCellDirective } from '@fundamental-ngx/core/table'; import { NgForm } from '@angular/forms'; import { DataSourceParser, DataSource as DataSource$1, DataSourceDirective } from '@fundamental-ngx/cdk/data-source'; type FdpColumnResponsiveState = 'visible' | 'hidden' | 'popping'; declare enum FilterType { INPUT = "input", SINGLE = "single-select", MULTI = "multi-select", CATEGORY = "category", CUSTOM = "custom" } declare enum FilterableColumnDataType { STRING = "string", NUMBER = "number", BOOLEAN = "boolean", DATE = "date" } /** All possible strategies */ declare const FILTER_STRATEGY: { readonly EQ: "equalTo"; readonly CONTAINS: "contains"; readonly BETWEEN: "between"; readonly BEGINS_WITH: "beginsWith"; readonly ENDS_WITH: "endsWith"; readonly GT: "greaterThan"; readonly GTE: "greaterThanOrEqualTo"; readonly LT: "lessThan"; readonly LTE: "lessThanOrEqualTo"; readonly AFTER: "after"; readonly ON_OR_AFTER: "onOrAfter"; readonly BEFORE: "before"; readonly BEFORE_OR_ON: "beforeOrOn"; }; type FilterStrategyType = typeof FILTER_STRATEGY; type FilterStrategy = FilterStrategyType[keyof FilterStrategyType]; declare const FILTER_STRATEGY_LABEL: Record; /** Date Filter Strategies */ declare const FILTER_DATE_STRATEGY: Pick; type FilterDateStrategy = (typeof FILTER_DATE_STRATEGY)[keyof typeof FILTER_DATE_STRATEGY]; declare const FILTER_DATE_STRATEGIES: ReadonlyArray; /** Number Filter Strategies */ declare const FILTER_NUMBER_STRATEGY: Pick; type FilterNumberStrategy = (typeof FILTER_NUMBER_STRATEGY)[keyof typeof FILTER_NUMBER_STRATEGY]; declare const FILTER_NUMBER_STRATEGIES: ReadonlyArray; /** String Filter Strategies */ declare const FILTER_STRING_STRATEGY: Pick; type FilterAllStrategy = (typeof FILTER_STRATEGY)[keyof typeof FILTER_STRATEGY]; type FilterStringStrategy = (typeof FILTER_STRING_STRATEGY)[keyof typeof FILTER_STRING_STRATEGY]; declare const FILTER_STRING_STRATEGIES: ReadonlyArray; /** Boolean Filter Strategies */ declare const FILTER_BOOLEAN_STRATEGY: Pick; type FilterBooleanStrategy = (typeof FILTER_BOOLEAN_STRATEGY)[keyof typeof FILTER_BOOLEAN_STRATEGY]; declare const FILTER_BOOLEAN_STRATEGIES: ReadonlyArray; /** Default Filter Strategies for undefined data type */ declare const FILTER_DEFAULT_STRATEGY: Pick; type FilterDefaultStrategy = (typeof FILTER_DEFAULT_STRATEGY)[keyof typeof FILTER_DEFAULT_STRATEGY]; declare const FILTER_DEFAULT_STRATEGIES: ReadonlyArray; declare const getFilterStrategiesBasedOnDataType: (dataType: FilterableColumnDataType) => readonly FilterStringStrategy[] | readonly FilterDateStrategy[]; declare enum ColumnAlign { START = "start", CENTER = "center", END = "end" } type ColumnAlignValue = 'start' | 'center' | 'end'; declare enum TableRowType { ITEM = "item", GROUP = "group", TREE = "tree" } declare enum SelectionMode { SINGLE = "single", MULTIPLE = "multiple", NONE = "none" } type SelectionModeValue = 'single' | 'multiple' | 'none'; declare enum SortDirection { NONE = "none", ASC = "asc", DESC = "desc" } interface BaseCollectionFilter { field: string; type?: FilterableColumnDataType; value: T; value2?: Nullable; exclude?: boolean; strategy?: FilterStrategy; fieldName?: string; } interface CollectionStringFilter extends BaseCollectionFilter { strategy: FilterStringStrategy; } interface CollectionNumberFilter extends BaseCollectionFilter { strategy: FilterNumberStrategy; } interface CollectionDateFilter extends BaseCollectionFilter { strategy: FilterDateStrategy; } interface CollectionBooleanFilter extends BaseCollectionFilter { strategy: FilterBooleanStrategy; } interface CollectionSelectFilter extends BaseCollectionFilter { strategy: FilterDefaultStrategy; } interface CollectionCustomFilter

extends BaseCollectionFilter<{ [key: string]: any; }> { strategy: P; } type CollectionFilter = CollectionStringFilter | CollectionNumberFilter | CollectionDateFilter | CollectionSelectFilter | CollectionBooleanFilter | CollectionCustomFilter; type CollectionFilterGroupStrategy = 'and' | 'or'; type CollectionFilterAndGroup = CollectionFilter | CollectionFilterGroup; interface CollectionFilterGroup { filters: CollectionFilter[]; strategy: CollectionFilterGroupStrategy; field: string; } interface CollectionGroup { field: string; direction: SortDirection; showAsColumn: boolean; } interface CollectionPage { pageSize: number; currentPage: number; } interface CollectionSort { field: string | null; direction: SortDirection; } interface CollectionState { sortBy: CollectionSort[]; filterBy: CollectionFilter[]; groupBy: CollectionGroup[]; page: CollectionPage; searchInput: SearchInput; } interface TableState extends CollectionState { columns: string[]; columnKeys: string[]; freezeToColumn: string | null; freezeToEndColumn: string | null; scrollTopPosition: number; } interface TableFilterSelectOption { value: any; label: string; children?: TableFilterSelectOption[]; } declare abstract class TableColumn { /** Column unique identifier. */ abstract name: string; /** Column data accessor key. */ abstract key: string; /** Column header label. */ abstract label: string; /** Column footer label. */ abstract footerLabel: string; /** Emits when the label value changes. */ abstract labelValueChanges$: Observable>; /** Cell text alignment. */ abstract align: ColumnAlignValue; /** Toggles sort feature in the column header. */ abstract sortable: boolean; /** Toggles filter feature in the column header. */ abstract filterable: boolean; /** Data type the column represents. */ abstract dataType: FilterableColumnDataType; /** * Optional array of available filter options. * Providing values to this input will cause the filter to change from a text-type input to a select-type input. * */ abstract filterSelectOptions: string[]; /** Width of the column cells. */ abstract width: string; /** Toggles grouping feature in the column header. */ abstract groupable: boolean; /** Toggles freeze/unfreeze feature in the column header. */ abstract freezable: boolean; /** Toggles end column freeze/unfreeze feature in the column header. */ abstract endFreezable: boolean; /** Whether the table cell inside table header should be non-interactive. */ abstract nonInteractive: boolean; /** Initial visibility state of the column. */ abstract visible: boolean; /** Column cell template for readonly mode. */ abstract columnCellTemplate: Nullable>; /** Column cell template for editing mode. */ abstract editableColumnCellTemplate: Nullable>; /** Column header template. */ abstract headerCellTemplate: Nullable>; /** Column header template. */ abstract footerCellTemplate: Nullable>; /** Column header popover template. */ abstract headerCellPopoverTemplate: Nullable>; /** Whether the text should wrap, when text is too long for 1 line. */ abstract noWrap: boolean; /** Whether to apply fd-table-text (text-shadow) to the cell content, if disabled noWrap has no effect. */ abstract applyText: boolean; /** Stores information for the header cell if the ellipsis are visible after the column resize */ abstract headerOverflows: boolean; /** Whether this column is visible */ abstract responsiveState: FdpColumnResponsiveState; /** Column role attribute. */ abstract role: 'cell' | 'rowheader' | 'gridcell'; /** * Whether to announce built-in empty cells to screen readers for columns with column templates. * This provides option to turn off the announcement if the column template already includes its own * */ abstract announceEmptyCell: Signal; /** @hidden */ abstract _freezed: boolean; /** @hidden */ abstract _endFreezed: boolean; } interface TableColumnFreezeInternalEvent { name: TableColumn['name']; endFreezable: TableColumn['endFreezable']; } interface FreezeChange { current: string | null; previous: string | null; end?: boolean; } declare class TableColumnFreezeEvent { source: Table; current: string | null; previous: string | null; /** * Table column freeze event * @param source Table component * @param current Current freezeTo column * @param previous Previous freezeTo column */ constructor(source: Table, current: string | null, previous: string | null); } declare class ColumnsChange { current: string[]; previous: string[]; /** * Columns change event * @param current Current columns * @param previous Previous columns */ constructor(current: string[], previous: string[]); } declare class TableColumnsChangeEvent extends ColumnsChange { source: Table; /** * Table columns change event * @param source Table component * @param current Current columns * @param previous Previous columns */ constructor(source: Table, current: string[], previous: string[]); } declare abstract class BaseTableDataSource implements DataSource { /** * Method for retrieving the data of the provided data source. * @param tableState @see TableState Set of table parameters. * @param parentRows */ abstract fetch(tableState: TableState, parentRows?: TableRow[]): void; /** @hidden */ protected readonly _dataChanges$: BehaviorSubject

; /** @hidden */ protected readonly _onDataRequested$: Subject; /** @hidden */ protected readonly _onDataReceived$: Subject; /** @hidden */ protected _dataLoading: L; /** @hidden */ protected readonly _dataLoading$: BehaviorSubject; /** @hidden */ protected readonly _destroy$: Subject; /** @hidden */ protected constructor(); /** * Emitted when new data has been requested. * @returns Observable */ get dataRequested(): Observable; /** * Emitted when new data has been received. * @returns Observable */ get dataReceived(): Observable; /** * Emitted when loading state has been changed. * @returns Observable. */ get dataLoading(): Observable; /** * Emits when the data from the provider has been changed. * @returns Observable of data source objects. */ get dataChanges(): Observable

; /** @hidden */ get isDataLoading(): L; /** @hidden */ get data(): P; /** @hidden */ open(): Observable

; /** @hidden */ onDataRequested(): Observable; /** @hidden */ onDataReceived(): Observable; /** @hidden */ close(): void; /** * Closes the stream */ unsubscribe(): void; } declare class TableDataSource extends BaseTableDataSource { readonly dataProvider: TableDataProvider; /** * @hidden */ constructor(dataProvider: TableDataProvider); /** * Method for retrieving the data of the provided data source. * @param tableState @see TableState Set of table parameters. */ fetch(tableState: TableState): void; } declare class ChildTableDataSource extends BaseTableDataSource, T[]>, { row?: TableRow; loading: boolean; }[]> { readonly dataProvider: TableChildrenDataProvider; /** * @hidden */ constructor(dataProvider: TableChildrenDataProvider); /** * Method responsible for retrieving the items from the data provider. * Additionaly, it sets the loading state along with the dataLoading and dataChanges streams. * @param tableState * @param parentRows */ fetch(tableState: TableState, parentRows?: TableRow[]): void; } type FdpTableDataSource = T[] | Observable | TableDataSource; type TableRowState = 'editable' | 'readonly'; type TableRowSemanticHighlight = 'valid' | 'warning' | 'information' | 'error'; interface TableRowKeyboardDrag { direction: 'up' | 'down'; event: KeyboardEvent; mode: 'group' | 'shift'; } /** * Table row entity * Used to represent table row in the template */ interface TableRow { /** * Row semantic type */ type: TableRowType.ITEM | TableRowType.GROUP | TableRowType.TREE; /** * Indicates if row is selected. It also supports intermediate state */ checked: boolean | null; checked$?: Observable; /** * Index of a "value" in data source list */ index: number; /** * Data model it represents */ readonly value: T; /** * Reference to a parent if any */ parent: TableRow | null; /** * Nesting level */ level: number; /** * Expandable */ expandable: boolean; /** * Expanded/Collapsed */ expanded: boolean; expanded$?: Observable; childItems$: Observable; childItemsLoading$: BehaviorSubject; stateChanged$: Observable; /** * If item should be hidden. Used to skip rendering */ hidden: boolean; /** * If the row is navigatable */ navigatable: boolean; /** * Row state: readonly or editable. */ state: TableRowState; /** * Children table rows. */ children: TableRow[]; isTree: boolean; setRowType: (type: TableRowType) => void; lastChild?: TableRow; /** Flag indicating that all child rows should be fetched again. */ forceFetch: boolean; } type TableRowClass = string | ((row: T) => string); /** @hidden */ declare function isTableRow(row: TableRow): row is TableRow; declare class TableRowImpl implements TableRow { /** @hidden */ set checked(value: boolean | null); get checked(): boolean | null; /** @hidden */ readonly checked$: Observable; /** @hidden */ readonly childItems$: Observable; /** @hidden */ readonly stateChanged$: BehaviorSubject; /** @hidden */ readonly childItemsLoading$: BehaviorSubject; /** @hidden */ forceFetch: boolean; /** @hidden */ children: TableRow[]; /** @hidden */ expandable: boolean; /** @hidden */ set expanded(value: boolean); get expanded(): boolean; /** @hidden */ readonly expanded$: Observable; /** @hidden */ hidden: boolean; /** @hidden */ index: number; /** @hidden */ level: number; /** @hidden */ navigatable: boolean; /** @hidden */ parent: TableRow | null; /** @hidden */ state: TableRowState; /** @hidden */ type: TableRowType; /** @hidden */ readonly value: T; /** @hidden */ childDataSource: TableDataSource | undefined; /** @hidden */ isTree: boolean; /** @hidden */ lastChild?: TableRow; /** @hidden */ private readonly _expandedSubject; /** @hidden */ private readonly _checkedSubject; /** @hidden */ constructor(row: Partial); /** * Sets the row type and checks whether the row is a tree. * @param type Row type. */ setRowType(type: TableRowType): void; } declare class TableRowsRearrangeEvent { row: T; dropRow: T; previousIndex: number; newIndex: number; insertAt: 'before' | 'after' | null; mode: FdDndDropEventMode; rows: T[]; /** * Table rows rearrange event * @param row Row that was rearranged * @param dropRow Row where the dragged item has been dropped * @param previousIndex Previous index of the row * @param newIndex New index of the row * @param insertAt Whether dragged the row was inserted before or after the dropped row * @param mode Whether the dropped element shifts other items or is grouped with them * @param rows All rows of the table in the state they exist on the datasource */ constructor(row: T, dropRow: T, previousIndex: number, newIndex: number, insertAt: 'before' | 'after' | null, mode: FdDndDropEventMode, rows: T[]); } declare abstract class TableDraggable { abstract dragDropInProgress: boolean; abstract enableRowReordering: boolean; abstract isTreeTable: boolean; abstract dropMode: FdDndDropType; abstract dropPredicate: DropPredicate>; abstract dragoverPredicate: DragoverPredicate>; abstract rowsRearrange: EventEmitter>; abstract draggedRow: TableRow | null; abstract draggedDndIndex: number | null; abstract draggedRowGlobalIndex: number | null; abstract dragRowFromKeyboard(dir: string, event: Event, currentRowIndex: number, mode: 'shift' | 'group'): void; abstract dragDropItemDrop(event: FdDropEvent): void; abstract dragDropStart(draggedItem?: TableRow, dndIndex?: number, globalIndex?: number): void; abstract setTable(table: Table): void; abstract dropCancelled(): void; } declare abstract class TableInitialState { abstract initialSortBy: CollectionSort[]; abstract initialVisibleColumns: string[]; abstract initialFilterBy: CollectionFilter[]; abstract initialGroupBy: CollectionGroup[]; abstract initialPage: number; abstract state: TableState; abstract setTable(table: Table): void; abstract setInitialState(): void; } declare abstract class TableVirtualScroll { abstract rowHeight: number; abstract secondaryRowHeight: number | undefined; abstract virtualScrollTransform$: Observable; abstract virtualScroll: boolean; abstract virtualScrollTotalHeight: number; abstract scrollWholeRows: boolean; abstract setTable(table: Table): void; abstract listenOnVirtualScroll(): void; abstract calculateVirtualScrollRows(): void; } interface UpdatedDndRowsPosition { allRows: TableRow[]; rowsToMove: TableRow[]; rowsAfterDropRow: TableRow[]; dropRowItems: TableRow[]; } interface FilterChange { current: CollectionFilter[]; previous: CollectionFilter[]; } declare class TableFilterChangeEvent { source: Table; current: CollectionFilter[]; previous: CollectionFilter[]; /** * Table filter change event * @param source Table component * @param current Current filters * @param previous Previous filters */ constructor(source: Table, current: CollectionFilter[], previous: CollectionFilter[]); } interface GroupChange { current: CollectionGroup[]; previous: CollectionGroup[]; } declare class TableGroupChangeEvent { source: Table; current: CollectionGroup[]; previous: CollectionGroup[]; /** * Table group change event * @param source Table component * @param current Current groups * @param previous Previous groups */ constructor(source: Table, current: CollectionGroup[], previous: CollectionGroup[]); } declare class PageChange { current: CollectionPage; previous: CollectionPage; /** * Page change event * @param current Current page * @param previous Previous page */ constructor(current: CollectionPage, previous: CollectionPage); } declare class TablePageChangeEvent extends PageChange { source: Table; /** * Table page change event * @param source Table component * @param current Current page * @param previous Previous page */ constructor(source: Table, current: CollectionPage, previous: CollectionPage); } /** * An optional function, that identifies uniqueness of a particular row. * Table component uses it to be able to preserve selection when data list is changed. */ type RowComparator = (left: T, right: T) => boolean; declare class SaveRowsEvent { done: () => void; items: T[]; /** * Table save rows event * @param done Callback function. Call it when newly added items has been saved and new data source fetch is needed. * @param items Array of newly created items. */ constructor(done: () => void, items: T[]); } interface SearchChange { current: SearchInput; previous: SearchInput; } declare class TableSearchChangeEvent { source: Table; current: SearchInput; previous: SearchInput; /** * Table search change event * @param source Table component * @param current Current search (fields, directions) * @param previous Previous search (fields, directions) */ constructor(source: Table, current: SearchInput, previous: SearchInput); } declare class TableSelectionChangeEvent { /** currently selected items */ selection: T[]; /** Items added */ added: T[]; /** Items removed */ removed: T[]; /** Indexes location of additions or removals */ index: number[]; /** Whether `Check/Uncheck` all checkbox was pressed. */ all?: boolean; } declare class TableRowSelectionChangeEvent extends TableSelectionChangeEvent { /** Table component */ source: Table; } interface SortChange { current: CollectionSort[]; previous: CollectionSort[]; } declare class TableSortChangeEvent { source: Table; current: CollectionSort[]; previous: CollectionSort[]; /** * Table sort change event * @param source Table component * @param current Current sort (fields, directions) * @param previous Previous sort (fields, directions) */ constructor(source: Table, current: CollectionSort[], previous: CollectionSort[]); } declare class TableCellActivateEvent { columnIndex: number; row: T; /** * Table cell activate event * @param columnIndex Index of the clicked column * @param row Row that was activated */ constructor(columnIndex: number, row: T); } /** Common properties for table dialogs */ interface TableDialogCommonData { _placeholder?: unknown; } type TreeTableItem = { [key in P]?: FdpTableDataSource; }; type PlatformTableManagedPreset = Partial>; declare class TableRowActivateEvent { index: number; ctrlKey: boolean; row: T; /** * Table row activate event * @param index Index of the activated row * @param ctrlKey Whether control/command key was pressed during the mouse/keyboard event * @param row Row that was activated */ constructor(index: number, ctrlKey: boolean, row: T); } declare class TableRowToggleOpenStateEvent { index: number; row: T; expanded: boolean; /** * Table row toggle open state event * @param index Index of the row * @param row Row that was toggled * @param expanded Expanded state of the row */ constructor(index: number, row: T, expanded: boolean); } type TreeLike = T & { _children?: TreeLike[]; }; interface GroupTableRowValueType { field: string; value: unknown; count: number; } declare abstract class BaseTableDataProvider { abstract fetch(state?: TableState, parentRows?: TableRow[]): Observable

; abstract fetchData(state: TableState, parentRows?: TableRow[]): Observable

; /** Total items count. */ totalItems: number; /** Array of items. */ items: P; /** Date time adapter for date field filtering. */ dateTimeAdapter?: DatetimeAdapter; /** Additional set of filters provided by outside component. */ protected filterBy: CollectionFilterAndGroup[]; /** Additional search query provided by outside component. */ protected searchInput?: SearchInput; /** @hidden */ protected _destroy$: Subject; /** * Method for setting external filtering conditions. * @param filterBy Set of column filters. * @param searchInput Search condition from search field. */ setFilters(filterBy: CollectionFilterAndGroup[], searchInput?: SearchInput): void; /** * Method for filtering the data. * @param items Array of data source items. * @param filters Set of column filters. * @returns Array of filtered items. */ applyFiltering(items: T[], filters: CollectionFilterAndGroup[]): T[]; /** @hidden */ getSelectItemValue(item: any): any; /** * Method which selects appropriate filtering strategy of the field depending on the filter type. * Developers can override this method to extend the filtering functionality. * @param item item of the data source. * @param filters Set of column filters. * @returns Whether or not item should be included in data array. */ getFilteringStrategy(item: T, filters: CollectionFilterAndGroup[]): boolean; /** * Method which filters item depending on applied condition result. * Developers can override this method to extend its functionality * @param item Item to apply conditions to. * @param filter Column filter. * @returns {boolean} Whether this item should be present in filtered array of items. */ collectionFilterStrategy(item: T, filter: CollectionFilter): boolean; /** * Method which applies group filtering conditions for the item. * @param item Item to apply conditions to. * @param filter Filter group. * @returns {boolean} Whether this item should be present in filtered items array. */ collectionFilterGroupStrategy(item: T, filter: CollectionFilterGroup): boolean; /** * Applies search of the search term for visible table columns. * Developers can override this method to extend the filtering functionality. * @param items data source items array. * @param tableState @see TableState Set of table parameters. * @returns filtered data source items array. */ search(items: T[], { searchInput, columnKeys }: TableState): T[]; /** * String filtering strategy * @param item data source array item. * @param filter filter object * @returns whether or not item should be included in data source array. */ protected filterString(item: T, filter: CollectionStringFilter): boolean; /** * Number filtering strategy * @param item data source array item. * @param filter filter object * @returns whether or not item should be included in data source array. */ protected filterNumber(item: T, filter: CollectionNumberFilter): boolean; /** * Date filtering strategy * @param item data source array item. * @param filter filter object * @param adapter * @returns whether or not item should be included in data source array. */ protected filterDate(item: T, filter: CollectionDateFilter, adapter?: DatetimeAdapter): boolean; /** * Boolean filtering strategy * @param item data source array item. * @param filter filter object * @returns whether or not item should be included in data source array. */ protected filterBoolean(item: T, filter: CollectionBooleanFilter): boolean; /** * Array filtering strategy * @param item data source array item. * @param filter filter object * @returns whether or not item should be included in data source array. */ protected filterArray(item: T, filter: CollectionSelectFilter): boolean; /** @hidden */ protected unsubscribe(): void; } declare class TableDataProvider extends BaseTableDataProvider { /** * Method for retrieving the data. * @param tableState @see TableState Set of table parameters. * @returns Observable with data. */ fetch(tableState?: TableState): Observable; /** * Method for applying filtering and retrieving the data. * @param state @see TableState Set of table parameters. * @returns Observable with filtered data. */ fetchData(state: TableState): Observable; /** * Method for getting all possible options for particular field. * Used for creating select options. * Developers can override this method to extend the filtering functionality. * @param field key of the data item. * @returns Observable with select items. */ getFieldOptions(field: string): Observable; } declare abstract class TableChildrenDataProvider extends BaseTableDataProvider, T[]>> { /** * Method for retrieving the amount of child itemf or a defined row. * @param row * @param state */ abstract rowChildrenCount(row: TableRow, state: TableState): Observable; /** * Method for retrieving the data. * @param tableState @see TableState Set of table parameters. * @param parentRows * @returns Observable with data. */ fetch(tableState?: TableState, parentRows?: TableRow[]): Observable, T[]>>; /** * Method for applying filtering and retrieving the data. * @param state @see TableState Set of table parameters. * @param tableRows * @returns Observable with filtered data. */ fetchData(state: TableState, tableRows?: TableRow[]): Observable, T[]>>; } /** * Table Data Provider based on an array. * * Used to convert array source to the TableDataProvider interface. * */ declare class ArrayTableDataProvider extends TableDataProvider { /** @hidden */ protected items$: BehaviorSubject; /** @hidden */ constructor(items: T[], dateTimeAdapter?: DatetimeAdapter); /** * Method for retrieving the data. * @param tableState @see TableState Set of table parameters. * @returns Observable with data. */ fetch(state?: TableState): Observable; } declare class ArrayTableDataSource extends TableDataSource { /** @hidden */ constructor(data: T[], dateTimeAdapter?: DatetimeAdapter); } declare class TableDataSourceParser implements DataSourceParser> { /** @hidden */ parse(source: DataSource$1): TableDataSource | undefined; } /** * Table Data Provider based on an Observable. * * Used to convert observable source to the TableDataProvider interface. * */ declare class ObservableTableDataProvider extends TableDataProvider { /** @hidden */ protected items$: Observable; /** @hidden */ constructor(items$: Observable, dateTimeAdapter?: DatetimeAdapter); /** * Method for retrieving the data. * @param tableState @see TableState Set of table parameters. * @returns Observable with data. */ fetch(state?: TableState): Observable; } declare class ObservableTableDataSource extends TableDataSource { /** @hidden */ constructor(data: Observable, dateTimeAdapter?: DatetimeAdapter); } interface TableScrollable { /** Get scrollable ElementRef of. */ elementRef: ElementRef; /** Returns observable that emits when a scroll event is fired on the host element. */ getScrollStream(): Observable; /** Returns observable that emits when a vertical scroll event is happened on the host element. */ getVerticalScrollStream(): Observable; /** Returns observable that emits when a horizontal scroll event is happened on the host element. */ getHorizontalScrollStream(): Observable; /** Returns scrollTop position of the host element. */ getScrollTop(): number; /** Returns scrollLeft position of the host element. */ getScrollLeft(): number; /** Set scrollTop position of the host element. */ setScrollTop(scrollTop: number, emitEvent: boolean): void; /** Set scrollLeft position of the host element. */ setScrollLeft(scrollLeft: number, emitEvent: boolean): void; /** Scrolls to overlapped cell. */ scrollToOverlappedCell(rtl: boolean, freezableColumnsSize: number, freezableEndColumnSize: number): void; /** Set Scroll Position during component initialization. */ initializeScrollTop(scrollTop: number): void; } declare const TABLE_SCROLLABLE: InjectionToken; declare class TableScrollDispatcherService implements OnDestroy { /** @hidden */ private _scrollSubject; /** @hidden */ private _verticalScrollSubject; /** @hidden */ private _horizontalScrollSubject; /** @hidden */ private _scrollableSubscriptionsMap; /** @hidden */ register(scrollable: TableScrollable): void; /** @hidden */ deregister(scrollable: TableScrollable): void; /** Scroll stream */ scrolled(): Observable; /** Horizontal scroll stream */ horizontallyScrolled(): Observable; /** Vertical scroll stream */ verticallyScrolled(): Observable; /** @hidden */ ngOnDestroy(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare abstract class Table implements PresetManagedComponent { abstract readonly name: string; abstract readonly id: string; abstract _loadPreviousPages: boolean; abstract pageScrolling: boolean; abstract loadPagesBefore: boolean; abstract pageSize: Nullable; abstract freezeColumnsTo: string; abstract freezeEndColumnsTo: string; /** Event emitted when current preset configuration has been changed. */ abstract presetChanged: EventEmitter; /** Sum of widths of fixed columns (semantic highlighting, selection) */ abstract get _fixedColumnsPadding(): number; /** Freezable column names and their respective indexes */ abstract get _freezableColumns(): ReadonlyMap; /** Freezable column names and their respective indexes */ abstract get _freezableEndColumns(): ReadonlyMap; /** Width of the table element in px */ abstract get _tableWidthPx(): number; abstract get loadingState(): boolean; abstract initialState: TableInitialState | null; /** Table columns definition list */ abstract readonly tableColumnsStream: Observable; abstract readonly injector: Injector; abstract readonly tableContainer: ElementRef; abstract readonly tableScrollMockContainer: ElementRef; abstract readonly tableScrollable: TableScrollable; abstract _virtualScrollDirective: TableVirtualScroll | null; abstract _tableRowsVisible: TableRow[]; abstract _tableRows: TableRow[]; abstract loadedRows$: Signal; abstract _tableCurrentlyRenderedRowsPlaceholder: number[]; abstract _selectionMode: SelectionModeValue; abstract contentDensityObserver: ContentDensityObserver; abstract minimumColumnWidth: number; abstract _focusableGrid: FocusableGridDirective; /** Get table state */ abstract getTableState(): TableState; /** Set table state */ abstract setTableState(tableState: TableState): void; /** Get table columns definition list */ abstract getTableColumns(): TableColumn[]; /** Get a list of visible table columns. */ abstract getVisibleTableColumns(): TableColumn[]; /** Set Sorting rules */ abstract sort(sortRules: CollectionSort[]): void; /** Add Sorting rules to the existing ones */ abstract addSort(sortRules: CollectionSort[]): void; /** Set Filtering rules */ abstract filter(filterRules: CollectionFilter[]): void; /** Add Filter rules to the existing ones */ abstract addFilter(filterRules: CollectionFilter[]): void; /** Set grouping rules */ abstract group(groupRules: CollectionGroup[]): void; /** Add Group rules to the existing ones */ abstract addGroup(groupRules: CollectionGroup[]): void; /** Set table columns */ abstract setColumns(columns: string[]): void; /** Toggle row checked state. */ abstract toggleSelectableRow(rowIndex: number): void; /** Freeze table columns to including */ abstract freezeToColumn(columnKey: string, end?: boolean): void; /** Unfreeze column */ abstract unfreeze(columnKey: string, end?: boolean): void; /** Search in all table columns */ abstract search(searchInput: SearchInput): void; /** Toolbar Sort Settings button visibility */ abstract showSortSettingsInToolbar(showSortSettings: boolean): void; /** Toolbar Filter Settings button visibility */ abstract showFilterSettingsInToolbar(showFilterSettings: boolean): void; /** Toolbar Group Settings button visibility */ abstract showGroupSettingsInToolbar(showGroupSettings: boolean): void; /** Toolbar Columns Settings button visibility */ abstract showColumnSettingsInToolbar(showColumnSettings: boolean): void; /** Toolbar Settings button visibility */ abstract showSettingsInToolbar(showSettings: boolean): void; /** Disable filtering by header column menu */ abstract setHeaderColumnFilteringDisabled(disabled: boolean): void; /** Set current page */ abstract setCurrentPage(currentPage: number): void; /** Gets the max allowed width for all freezable columns */ abstract getMaxAllowedFreezableColumnsWidth(): number; /** Get table data source */ abstract getDataSource(): TableDataSource; /** Manually triggers columns width recalculation */ abstract recalculateTableColumnWidth(): void; /** Fetch data source data. */ abstract fetch(): void; /** Adds empty row for editing at the beginning of the rows array. */ abstract addRow(): void; /** Emits save event and resets editable rows array. */ abstract saveRows(): void; /** Cancels editing and discards newly added rows */ abstract cancelEditing(): void; /** Expand all the rows of the table */ abstract expandAll(): void; /** Collapse all the rows of the table */ abstract collapseAll(): void; /** Sets selected preset. */ abstract setPreset(data: PlatformTableManagedPreset): void; /** Returns current preset. */ abstract getCurrentPreset(): PlatformTableManagedPreset; abstract getCurrentlyRenderedRows(): number[]; abstract setCurrentlyRenderedRows(startIndex: number, length: number): void; abstract toggleExpandableTableRow(row: TableRow, forceFetch?: boolean): any; abstract onTableRowsChanged(): void; abstract refreshDndList(): void; abstract clearTableRows(): void; abstract _onSpyIntersect(intersected: boolean): void; /** Toolbar Sort Settings button click event */ readonly openTableSortSettings: EventEmitter; /** Toolbar Filter Settings button click event */ readonly openTableFilterSettings: EventEmitter; /** Toolbar Group Settings button click event */ readonly openTableGroupSettings: EventEmitter; /** Toolbar Column Settings button click event */ readonly openTableColumnSettings: EventEmitter; /** Event fired when table state changes. */ readonly tableColumnFilterChange: EventEmitter; /** Event fired when empty row added. */ readonly emptyRowAdded: EventEmitter; /** Event fired when save button pressed. */ readonly save: EventEmitter>; /** Event fired when cancel button pressed. */ readonly cancel: EventEmitter; /** Event fired when table is scrolled while using pageScrolling. */ readonly tableScrolled: EventEmitter; } type TableStateChange = TableStateProperty<'sort', SortChange> | TableStateProperty<'page', PageChange> | TableStateProperty<'filter', FilterChange> | TableStateProperty<'group', GroupChange> | TableStateProperty<'freeze', FreezeChange> | TableStateProperty<'columns', ColumnsChange> | TableStateProperty<'search', SearchChange>; type TableStateProperty = { type: T; state: P; }; declare class TableService { /** Table state stream. */ readonly tableState$: BehaviorSubject>; /** @hidden */ readonly _semanticHighlighting$: i0.WritableSignal; /** @hidden */ readonly _isFilteringFromHeaderDisabled$: i0.WritableSignal; /** @hidden */ readonly _isShownNavigationColumn$: i0.WritableSignal; /** @hidden */ readonly _semanticHighlightingColumnWidth$: i0.WritableSignal; /** Visible columns stream. */ readonly visibleColumns$: i0.WritableSignal; /** Visible columns length. */ visibleColumnsLength: i0.Signal; /** Popping columns stream. */ readonly poppingColumns$: i0.WritableSignal; /** Popping columns length. */ _poppingColumnsLength: number; /** Table columns stream. */ readonly tableColumns$: BehaviorSubject; /** @hidden */ readonly tableStateChanges$: rxjs.Observable>; /** Stream that emits when search state changes. */ readonly searchChange$: Subject; /** Stream that emits when sort state changes. */ readonly sortChange$: Subject; /** Stream that emits when filter state changes. */ readonly filterChange$: Subject; /** Stream that emits when group state changes. */ readonly groupChange$: Subject; /** Stream that emits when freeze state changes. */ readonly freezeChange$: Subject; /** Stream that emits when columns state changes. */ readonly columnsChange$: Subject; /** Stream that emits when page state changes. */ readonly pageChange$: Subject; /** Stream that emits when new fetch of data is needed. */ readonly needFetch$: Subject; /** @hidden */ readonly stateChange$: Subject; /** Stream that emits when loading state changes. */ readonly tableLoading$: BehaviorSubject; /** Listen for soft changes in table subcomponents (mostly table column) */ readonly markForCheck$: Subject; /** Listen for immediate changes in table subcomponents (mostly table column) */ readonly detectChanges$: Subject; /** Sort rules stream. */ readonly sortRules$: i0.WritableSignal>; /** * Filter Rules Map stream. Where key is column key, and value is the associated filter rules. * Many filters can be applied to one column. */ readonly filterRules$: i0.WritableSignal>; /** * Group Rules Map stream. Where key is column key and value is associated group rule */ readonly groupRulesSubject: BehaviorSubject>; /** Group Rules Map signal. */ readonly groupRules$: i0.Signal | undefined>; /** Get current state/settings of the Table. */ getTableState(): TableState; /** Set current state/settings of the Table. */ setTableState(state: TableState): void; /** Set current loading state of the Table. */ setTableLoading(isLoading: boolean): void; /** Notify about changes in table subcomponents (mostly table column) and detect them on next detector check. */ markForCheck(): void; /** Notify about changes in table subcomponents (mostly table column) and detect them immediately. */ detectChanges(): void; /** Search */ search(searchInput: SearchInput): void; /** Set new sort rules */ setSort(sortRules: CollectionSort[] | undefined): void; /** Add sort rules to the existing ones */ addSort(sortRules: CollectionSort[]): void; /** Set new filter rules */ setFilters(filterRules: CollectionFilter[] | undefined): void; /** Add filter rules to the existing ones */ addFilters(rulesToAdd: CollectionFilter[]): void; /** Removes filters for the provided fields */ removeFilters(fields: string[]): void; /** Set group rules */ setGroups(groups: CollectionGroup[] | undefined): void; /** Add group rules to the existing ones */ addGroups(groupsToAdd: CollectionGroup[]): void; /** Freeze table to column */ freezeTo(columnName: string | null, end?: boolean): void; /** Set table columns */ setColumns(columns: string[], keys: string[]): void; /** Set page. */ setCurrentPage(currentPage: number): void; /** Set items per page. */ setItemsPerPage(itemsPerPage: number, resetPageNumber?: boolean): void; /** Returns default table state. */ getDefaultState(): TableState; /** * Shares visible columns array across listeners. * @param columns Visible columns to share. */ setVisibleColumns(columns: TableColumn[]): void; /** * Shares popping columns array across listeners. * @param columns Popping columns to share. */ setPoppingColumns(columns: TableColumn[]): void; /** * Constructs grouping rules based on the table state. * @param state Table state. */ buildGroupRulesMap(state?: TableState): void; /** * Constructs sorting rules based on the table state. * @param state Table state */ buildSortRulesMap(state?: TableState): void; /** * Constructs filter rules based on the table state. * @param state Table state. */ buildFilterRulesMap(state?: TableState): void; /** Reset all filter rules */ resetFilters(): void; /** * Constructs base table config. */ constructTableMetadata(): void; /** @hidden */ private _getFieldName; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } interface FdpTableBreakpoint { min: number; max: number; visibility: FdpColumnResponsiveState; } declare class TableResponsiveService { private readonly _table; private readonly _tableService; private readonly _elmRef; /** @hidden */ private readonly _responsiveBreakpoints; /** @hidden */ private readonly _destroyRef; /** @hidden */ private _resizeSubscription; /** @hidden */ constructor(_table: Table, _tableService: TableService, _elmRef: ElementRef); /** * Registers responsive column with it's breakpoint configuration. * @param column Table Column * @param breakpoints Breakpoint configuration. */ registerResponsiveColumn(column: TableColumn, breakpoints: Record): void; /** * @hidden * Transforms plain breakpoints into a list with minimal/maximal element width with it's visibility state. */ private _normalizeBreakpoints; /** * @hidden * Listens to the table element resize and calculates columns visibility based on the current breakpoint. */ private _listenToTableResize; /** @hidden */ private _processResponsiveColumns; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } declare class PlatformTableColumnResponsiveDirective { private readonly _responsiveTableService; private readonly _column; /** * Responsive breakpoints configuration. * @param value where key is minimal table with and value is a column visibility type. */ set breakpoints(value: Record); get breakpoints(): Record; /** @hidden */ private _breakpoints; /** @hidden */ constructor(_responsiveTableService: TableResponsiveService, _column: TableColumn | null); static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } interface TableCellHeaderPopoverDirectiveContext { $implicit: Signal[]>; } declare class TableCellHeaderPopoverDirective { templateRef: TemplateRef; /** @hidden */ constructor(templateRef: TemplateRef); /** @hidden */ static ngTemplateContextGuard(directive: TableCellHeaderPopoverDirective, context: unknown): context is TableCellHeaderPopoverDirectiveContext; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } type TableColumnResizableSide = 'start' | 'end' | 'both'; declare const TABLE_CELL_RESIZABLE_THRESHOLD_PX = 4; /** * Tracks mouse movement over the cell if the mouse pointer near the side of the cell, informs resize service. */ declare class PlatformTableCellResizableDirective extends TableCellDirective implements OnInit, AfterViewInit, OnDestroy { /** First column can be resized only by its end */ set resizableSide(value: TableColumnResizableSide); /** Column name */ columnName: string; /** @hidden */ private _resizableSide; /** @hidden */ private readonly _isRtl; /** @hidden */ private readonly _tableColumnResizeService; /** @hidden */ private readonly _rtlService; /** @hidden */ private readonly _zone; /** @hidden */ ngOnInit(): void; /** @hidden */ ngAfterViewInit(): void; /** @hidden */ ngOnDestroy(): void; /** @hidden */ private _getResizer; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } declare abstract class EditableTableCell { abstract form: NgForm; } interface FdpCellDefContext { $implicit: T; popping: boolean; rowIndex: number; } /** Column cell container. */ declare class FdpTableCell { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } /** * Cell definition for a platform table. * Captures the template of a column's data row cell as well as cell-specific properties. */ declare class FdpCellDef { templateRef: TemplateRef>; /** Property to support typings. */ fdpCellDefAs: T; /** @hidden */ constructor(templateRef: TemplateRef>); /** @hidden */ static ngTemplateContextGuard(dir: FdpCellDef, ctx: FdpCellDefContext): ctx is FdpCellDefContext; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵdir: i0.ɵɵDirectiveDeclaration, "[fdpCellDef]", never, { "fdpCellDefAs": { "alias": "fdpCellDefAs"; "required": false; }; }, {}, never, never, true, never>; } declare class FdpEditableCellDef { templateRef: TemplateRef; /** @hidden */ constructor(templateRef: TemplateRef); static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } declare class FdpEditableCellFormDirective implements EditableTableCell { form: NgForm; /** @hidden */ constructor(form: NgForm); static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } declare class TableDataSourceDirective extends DataSourceDirective> implements OnDestroy { /** * Data source. * @param source */ set childDataSource(source: ChildTableDataSource | null); get childDataSource(): ChildTableDataSource | null; /** Event emitted when child data source instance being changed. */ childDataSourceChanged: EventEmitter; /** Event emitted when data loading is started. */ readonly onDataRequested: EventEmitter; /** Event emitted when data loading is finished. */ readonly onDataReceived: EventEmitter; /** Total items count stream. */ totalItems$: i0.WritableSignal; /** Items stream. */ items$: BehaviorSubject; /** Child items stream. */ childItems$: Subject, T[]>>; /** @hidden */ _tableDataSource: TableDataSource; /** @hidden */ _firstLoadingDone: boolean; /** @hidden */ _internalLoadingState: boolean; /** @hidden */ _internalChildrenLoadingState: boolean; /** @hidden */ private _childDataSource; /** @hidden */ private _childDsSubscription; /** @hidden */ set totalItems(value: number); get totalItems(): number; /** @hidden for data source handling */ private _tableDsSubscription; /** @hidden */ private _table; /** @hidden */ private readonly initialState; /** @hidden */ private readonly _tableService; /** @hidden */ initializeDataSource(): void; /** @hidden */ ngOnDestroy(): void; /** @hidden */ setTable(table: Table): void; /** * @hidden * Initializes the child data source to fetch child rows. */ private _initializeChildDataSource; /** * @hidden * This is a single point of data entry to the component. We don't want to set data on different * places. If any new data comes in, or you do a search, and you want to pass initial data * its here. */ private _listenToDataSource; /** @hidden */ private _closeDataSource; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵdir: i0.ɵɵDirectiveDeclaration, "[fdpTableDataSource]", never, { "childDataSource": { "alias": "childDataSource"; "required": false; }; }, { "childDataSourceChanged": "childDataSourceChanged"; "onDataRequested": "onDataRequested"; "onDataReceived": "onDataReceived"; }, never, never, true, never>; } declare class TableDraggableDirective extends TableDraggable implements OnDestroy { /** Whether to allow for row reordering on tree tables via drag and drop. */ enableRowReordering: boolean; /** Whether tree mode is enabled. */ isTreeTable: boolean; /** * Row drop mode. */ dropMode: FdDndDropType; /** Predicate function that checks whether the item can be dropped over another item. */ dropPredicate: DropPredicate>; /** * Predicate function that checks whether the item can be dragged over another item. * If the function returns `false`, dragged over item will not be highlighted, and drop event will be canceled. */ dragoverPredicate: DragoverPredicate>; /** Event fired when tree rows rearranged through drag & drop. Consider that rows rearranged with their children rows. */ readonly rowsRearrange: EventEmitter>; /** @hidden */ get _rowsDraggable(): boolean; /** Get the dragged row object during drag operation */ get draggedRow(): TableRow | null; /** Get the DnD index of the dragged row */ get draggedDndIndex(): number | null; /** Get the global index (in _tableRowsVisible) of the dragged row */ get draggedRowGlobalIndex(): number | null; /** @hidden */ dragDropInProgress: boolean; /** @hidden */ private _draggedRowObject; /** @hidden */ private _draggedRowDndIndex; /** @hidden */ private _draggedRowGlobalIndex; /** @hidden */ private _table; /** @hidden */ private readonly _cdr; /** @hidden */ ngOnDestroy(): void; /** Sets table reference. */ setTable(table: Table): void; /** * Initiates drag&drop sequence. */ dragDropStart(draggedItem?: TableRow, dndIndex?: number, globalIndex?: number): void; /** Method called when dnd performed with the keyboard. */ dragRowFromKeyboard(dir: string, event: Event, currentRowIndex: number, mode: 'shift' | 'group'): void; /** Method called when drag&drop event being cancelled. */ dropCancelled(): void; /** Method called when dragged item being dropped. */ dragDropItemDrop(event: FdDropEvent): void; /** * @hidden * Create table rows rearrange event */ _emitRowsRearrangeEvent(row: TableRow, dropRow: TableRow, event: FdDropEvent): void; /** @hidden */ private _setDragInProgress; /** @hidden */ private _isDroppedInsideItself; /** @hidden */ private _dragDropUpdateDragParentRowAttributes; /** @hidden */ private _dragDropUpdateDropRowAttributes; /** @hidden */ private _dragDropRearrangeTreeRows; /** @hidden */ private _getNewDragDropRowsPosition; /** @hidden */ private _handleShiftDropAction; /** @hidden */ private _handleReplaceDropAction; /** @hidden */ private _blockScrolling; /** @hidden */ private _enableScrolling; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵdir: i0.ɵɵDirectiveDeclaration, "fdp-table[isTreeTable], fdp-table[enableRowReordering]", never, { "enableRowReordering": { "alias": "enableRowReordering"; "required": false; }; "isTreeTable": { "alias": "isTreeTable"; "required": false; }; "dropMode": { "alias": "dropMode"; "required": false; }; "dropPredicate": { "alias": "dropPredicate"; "required": false; }; "dragoverPredicate": { "alias": "dragoverPredicate"; "required": false; }; }, { "rowsRearrange": "rowsRearrange"; }, never, never, true, never>; } declare class TableHeaderResizerDirective implements OnInit { /** @hidden */ focusedCellPosition: Nullable; /** @hidden */ private readonly _destroyRef; /** @hidden */ private readonly _rtlService; /** @hidden */ private readonly _isRtl; /** @hidden */ private readonly _elmRef; /** @hidden */ private readonly _tableColumnResizeService; /** @hidden */ private readonly _tableRowService; /** @hidden */ private readonly _zone; /** @hidden */ private readonly _document; /** @hidden */ private _focusinTimerId; /** @hidden */ private get _headerCellFocused(); /** @hidden */ ngOnInit(): void; /** @hidden */ private _onCellFocused; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } interface FdpHeaderCellDefContext { $implicit: T; } /** Column header container. */ declare class FdpTableHeader { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } /** * Header cell definition for a platform table. * Captures the template of a column's data row cell as well as cell-specific properties. */ declare class FdpHeaderCellDef { templateRef: TemplateRef>; /** @hidden */ constructor(templateRef: TemplateRef>); /** @hidden */ static ngTemplateContextGuard(dir: FdpHeaderCellDef, ctx: FdpHeaderCellDefContext): ctx is FdpHeaderCellDefContext; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵdir: i0.ɵɵDirectiveDeclaration, "[fdpHeaderCellDef]", never, {}, {}, never, never, true, never>; } declare class TableInitialStateDirective extends TableInitialState { /** Initial visible columns. Consist of a list of unique column names */ initialVisibleColumns: string[]; /** Initial sort options. */ initialSortBy: CollectionSort[]; /** Initial filter options. */ initialFilterBy: CollectionFilter[]; /** Initial group options. */ initialGroupBy: CollectionGroup[]; /** Initial page. */ initialPage: number; /** * Initial state of table. */ set state(value: TableState); get state(): TableState; /** @hidden */ private _table; /** @hidden */ private readonly _tableService; /** @hidden */ setTable(table: Table): void; /** @hidden */ setInitialState(): void; /** Get current state/settings of the Table. */ getTableState(): TableState; /** Set current state/settings of the Table. */ setTableState(state: TableState): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } /** * Table Scrollable. * That directive should be assigned to table scrollable area. * It registers itself in table scroll dispatcher * and notify once element scrolled. * * For internal usage. */ declare class TableScrollableDirective implements TableScrollable, OnInit, OnDestroy { elementRef: ElementRef; protected scrollDispatcher: TableScrollDispatcherService; protected ngZone: NgZone; /** @hidden */ private _skipEvent; /** @hidden */ private _prevScrollTop; /** @hidden */ private _prevScrollLeft; /** @hidden */ private readonly _destroyRef; /** @hidden */ private readonly _document; /** Scroll events stream */ private _elementScrollStream; /** Vertical scroll stream */ private _elementVerticalScrollStream; /** Horizontal scroll stream */ private _elementHorizontalScrollStream; /** @hidden */ constructor(elementRef: ElementRef, scrollDispatcher: TableScrollDispatcherService, ngZone: NgZone); /** @hidden */ ngOnInit(): void; /** @hidden */ ngOnDestroy(): void; /** Returns observable that emits when a scroll event is fired on the host element. */ getScrollStream(): Observable; /** Returns observable that emits when a vertical scroll event is happened on the host element. */ getVerticalScrollStream(): Observable; /** Returns observable that emits when a horizontal scroll event is happened on the host element. */ getHorizontalScrollStream(): Observable; /** Returns scrollTop position of the host element. */ getScrollTop(): number; /** Returns scrollLeft position of the host element. */ getScrollLeft(): number; /** Set scrollTop position of the host element. */ setScrollTop(scrollTop: number, emitEvent?: boolean): void; /** Set scrollLeft position of the host element. */ setScrollLeft(scrollLeft: number, emitEvent?: boolean): void; /** Scrolls to overlapped cell. */ scrollToOverlappedCell(rtl: boolean, freezableColumnsSize: number, freezableEndColumnSize: number): void; /** Set Scroll Position during component initialization. */ initializeScrollTop(scrollTop: number): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } interface FdpViewSettingsFilterCustomDefContext { $implicit: any; valueChangeEmitter: EventEmitter; contentDensity: ContentDensityMode; } declare class FdpViewSettingsFilterCustomDef { templateRef: TemplateRef; /** @hidden */ constructor(templateRef: TemplateRef); /** @hidden */ static ngTemplateContextGuard(dir: FdpViewSettingsFilterCustomDef, ctx: FdpViewSettingsFilterCustomDefContext): ctx is FdpViewSettingsFilterCustomDefContext; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } declare class TableVirtualScrollDirective extends TableVirtualScroll implements OnChanges, OnDestroy { readonly _tableService: TableService; /** Whether to show only visible rows in matter of performance * false by default, when true setting bodyHeight and rowHeight is required. */ virtualScroll: boolean; /** Cache size for the virtualScroll, default is 40 in each direction */ renderAhead: number; /** Body height. */ bodyHeight: string; /** * Minimum height of the row, required for the virtualScroll, * default is 44px in cozy, 32px in compact and 24px in condensed (set automatically) */ rowHeight: number; /** * Minimum height of the popping column when displayed in pop-in mode. Required when using popping columns and virtual scroll. */ secondaryRowHeight: number | undefined; /** * Whether to scroll whole rows rather than pixel by pixel when the user performs a scroll. * This gives greater performance improvements but also lends to some potentially undesirable UX changes. * A "rowHeight" must be provided when using this feature. */ set scrollWholeRows(value: boolean); get scrollWholeRows(): boolean; /** @hidden */ virtualScrollTotalHeight: number; /** @hidden */ virtualScrollTransform$: BehaviorSubject; /** @hidden */ private _table; /** @hidden */ private _virtualScrollCache; /** @hidden */ private readonly _tableScrollDispatcher; /** @hidden */ private readonly _tableRowService; /** @hidden */ private readonly _dndTableDirective; /** @hidden */ private readonly _destroyRef; /** @hidden */ private _wheelTimeout; /** @hidden */ private _scrollMockTimeout; /** @hidden */ private _lastMockScrollPosition; /** @hidden */ private _focusableGridSubscription; /** @hidden */ private _focusedCell; /** @hidden */ private _previousStartNodeIndex; /** @hidden */ private _scrollWholeRows; /** @hidden */ constructor(_tableService: TableService); /** @hidden */ ngOnChanges(changes: SimpleChanges): void; /** @hidden */ ngOnDestroy(): void; /** Sets table reference. */ setTable(table: Table): void; /** * Calculates rows to be rendered in the table. */ calculateVirtualScrollRows(): void; /** * Initialises scroll listener. */ listenOnVirtualScroll(): void; /** @hidden */ _keydownHandler(event: KeyboardEvent): void; /** @hidden */ private _getNumberOfRowsToDisplay; /** * @hidden * This function is called when the user performs a wheel event. It determines whether or not the user has scrolled * up or down using the event's deltaX property, and scrolls the table by one row. */ private _wheelScrollListenerFunction; /** * @hidden * This function is called when the mock scrollbar (when using 'scrollWholeRows') is moved. It determines if the * scroll was up or down by comparing the current scroll top to the previous scroll top and scrolls rows accordingly. */ private _mockScrollbarListenerFunction; /** * @hidden * This function, used only when 'scrollWholeRows' is truthy, calculates what should be the new starting node, based * off the previous starting node and the provided 'count' parameter. For example if the previous start node was 10 * and the count parameter is -2, the new starting node will be 8. This function also programmatically moves the * mock scrollbar. */ private _scrollRow; /** * @hidden * This function sets rows in the table's viewport depending on the provided starting node. It also sets the table * state scrollTopPosition. */ private _setRows; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵdir: i0.ɵɵDirectiveDeclaration; } declare class SelectionCellStylesPipe implements PipeTransform { /** @hidden */ transform(contentDensity: Nullable, rtl: boolean, semanticHighlightingColumnWidth: number | null): Record; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class TableCellStylesPipe implements PipeTransform { /** @hidden */ transform(column: TableColumn, isRtl: boolean, semanticHighlightingColumnWidth: number | null, selectionColumnWidth: number | null, isFrozenColumn: boolean, isFrozenEndColumn: boolean, prevColumnWidthPx: number | null, columnWidth: string, nextColumnWidthPx: number | null, noBorders?: boolean, noHorizontalBorders?: boolean, noVerticalBorders?: boolean): Record; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class ColumnResizableSidePipe implements PipeTransform { /** @hidden */ transform(columnIndex: number, visibleColumnsLength: number, navigationColumnShown: boolean | null): TableColumnResizableSide; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare class RowClassesPipe implements PipeTransform { /** @hidden */ transform(row: TableRow, rowsClass: TableRowClass): string; /** @hidden */ private _getRowCustomCssClasses; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } /** * @deprecated * Use direct imports of components and directives. */ declare class TableHelpersModule { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵmod: i0.ɵɵNgModuleDeclaration; static ɵinj: i0.ɵɵInjectorDeclaration; } declare const TABLE_RESIZER_BORDER_WIDTH = 3; /** * Service to handle all things related to column resizing: * - Setting resizer * - Processing resize * - Calculating the real columns width */ declare class TableColumnResizeService implements OnDestroy { private readonly _tableScrollDispatcherService; /** Subject that emits new map of fixed columns and their respective width. */ readonly fixedColumsWidthChange: BehaviorSubject>; /** Indicate if resizing process in progress. */ get resizeInProgress(): boolean; /** Resize progress stream. */ readonly resizeInProgress$: BehaviorSubject; /** Whether cell mock should be visible. */ readonly cellMockVisible$: i0.WritableSignal; /** Current column resizer position. */ get resizerPosition(): number; /** Resizer position stream. */ readonly resizerPosition$: BehaviorSubject; /** Observable to notify to run CD */ get markForCheck(): Observable; /** table has fixed width if all of it's columns are fixed */ get fixedWidth(): boolean; /** @hidden */ private _fixedColumnsWidthMap; /** @hidden */ private _columnsCellMap; /** @hidden */ private _visibleColumnNames; /** @hidden */ private _visibleColumnLeftNeighbourMap; /** @hidden */ private _visibleColumnRightNeighbourMap; /** @hidden */ private _visibleColumnLeftOffsetPxMap; /** @hidden */ private _visibleColumnRightOffsetPxMap; /** @hidden */ private _startX; /** @hidden */ private _clientStartX; /** @hidden */ private _resizeInProgress; /** @hidden */ private _resizedColumn; /** @hidden */ private _resizerPosition; /** @hidden */ private _scrollLeft; /** @hidden */ private _markForCheck; /** @hidden */ private _destroyed; /** @hidden */ private _resizerMoveSubscription; /** @hidden */ private _tableRef; /** @hidden */ private _initialTableWidth; /** @hidden */ private readonly _isRtl; /** @hidden */ private readonly _rtlService; /** @hidden */ constructor(_tableScrollDispatcherService: TableScrollDispatcherService); /** @hidden */ ngOnDestroy(): void; /** @hidden */ setTableRef(ref: Table): void; /** @hidden initializes service with data, trigger columns width calculation. */ setColumnNames(visibleColumnNames: string[]): void; /** @hidden */ updateFrozenColumnsWidth(): void; /** @hidden */ updateFrozenColumnsWidthAfterResize(columnName: string, diffX: number): void; /** Retrieves custom column value or returns `unset` */ getColumnWidthStyle(columnName: string): string; /** Previous column name */ getPreviousColumnName(columnName: string): string | undefined; /** Previous column name */ getNextColumnName(columnName: string): string | undefined; /** Overall previous columns width. Used to calculate offset for the absolute positioned cells. */ getPrevColumnsWidth(columnName: string): number; /** Overall next columns width. Used to calculate offset for the absolute positioned cells. */ getNextColumnsWidth(columnName: string): number; /** Register column's cell to get its dimensions in further. */ registerColumnCell(columnName: string, cellElRef: ElementRef): void; /** Unregister column's cell. */ unregisterColumnCell(columnName: string, cellElRef: ElementRef): void; /** Register the value of column width that changed from input */ setCustomWidth(columnName: string, value: string): void; /** Set the appropriate column resizer position. */ setInitialResizerPosition(resizerPosition: number, resizedColumn: string): void; /** Hide the column resizer. */ hideResizer(): void; /** @hidden */ _setInitialTableWidth(): void; /** Handle start resizing. */ startResize(event: MouseEvent): void; /** Handle end resizing. */ finishResize(event: MouseEvent): void; /** Update columns width after resizing, prevent from having too small columns. */ _processResize(diffX: number): void; /** Update column resizer position. */ private _updateResizerPositionOnMouseMove; /** * Check if the header text length goes over the column width. In such case applies text truncation with * ellipsis and make sure we also show a tooltip. * * @private */ private _updateHeaderOverflowState; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵprov: i0.ɵɵInjectableDeclaration; } type ToggleRowModel = { type: 'toggleRow'; row: TableRow; } | { type: 'toggleSingleSelectableRow'; row: TableRow; } | { type: 'toggleMultiSelectRow'; row: TableRow; event?: Event; }; interface CellClickedModel { index: number; row: TableRow; } declare class TableRowService { /** Stream that emits when toggling all selectable rows is needed. */ readonly toggleAllSelectableRows$: Observable; /** Stream that emits when table cell being clicked. */ readonly cellClicked$: Observable; /** Stream that emits when scrolling to overlapped cell is needed. */ readonly scrollToOverlappedCell$: Observable; /** Stream that emits when the table cell being focused. */ readonly cellFocused$: Observable; /** Stream that emits when the table cell being focused. */ readonly cellActivate$: Observable>; /** Toggle row stream. */ readonly toggleRow$: Observable; /** Editable cells map. */ readonly editableCells: Map, EditableTableCell[]>; /** @hidden */ readonly childRowsAdded$: Subject<{ row: TableRow; rowIndex: number; items: T[]; }>; /** Stream to load child items for a particular rows. */ readonly loadChildRows$: Subject[]>; /** @hidden */ private readonly _toggleRowSubject; /** @hidden */ private readonly _scrollToOverlappedCellSubject; /** @hidden */ private readonly _cellClickedSubject; /** @hidden */ private readonly _cellActivateSubject; /** @hidden */ private readonly _cellFocusedSubject; /** @hidden */ private readonly _toggleAllSelectableRowsSubject; /** @hidden */ constructor(); /** `toggleRow$` stream trigger. */ toggleRow(evt: ToggleRowModel): void; /** `scrollToOverlappedCell$` stream trigger. */ scrollToOverlappedCell(): void; /** `cellClicked$` stream trigger. */ cellClicked(evt: CellClickedModel): void; /** @hidden */ cellActivate(columnIndex: number, row: TableRow): void; /** `cellFocused$` stream trigger. */ cellFocused(evt: FocusableItemPosition): void; /** `toggleAllSelectableRows$` stream trigger. */ toggleAllSelectableRows(selectAll: boolean): void; /** Groups the table rows. */ groupTableRows(sourceRows: TableRow[], groups: Iterable, groupRulesMap: Map): TableRow[]; /** Sets editable cells for particular row. */ updateEditableCells(row: TableRow, cells: EditableTableCell[]): void; /** Removes editable cells of particular row. */ removeEditableCells(row: TableRow): void; /** Triggers stream to load child items for a particular rows. */ loadChildRows(rows: TableRow | TableRow[]): void; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵprov: i0.ɵɵInjectableDeclaration>; } declare const ARIA_SORT: Record<`${SortDirection}`, string>; declare class TableColumnSortingDirectionPipe implements PipeTransform { /** @hidden */ transform(sorting: Nullable): string; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵpipe: i0.ɵɵPipeDeclaration; } declare const FDP_TABLE_DRAGGABLE_DIRECTIVE: InjectionToken>; declare const FDP_TABLE_STATE_DIRECTIVE: InjectionToken; declare const FDP_TABLE_VIRTUAL_SCROLL_DIRECTIVE: InjectionToken; declare const DEFAULT_TABLE_PAGE: Readonly; declare const DEFAULT_TABLE_SEARCH_INPUT: Readonly; declare const DEFAULT_TABLE_STATE: Readonly; declare const DEFAULT_HIGHLIGHTING_KEY = "semantic"; declare const EDITABLE_ROW_SEMANTIC_STATE = "information"; declare const SEMANTIC_HIGHLIGHTING_COLUMN_WIDTH = 6; declare const SELECTION_COLUMN_WIDTH: ReadonlyMap; declare const TABLE_COLUMN_MIN_WIDTH = 50; declare const ROW_HEIGHT: ReadonlyMap; /** @hidden */ declare function newTableRow(row: Partial>): TableRow; /** @hidden */ declare function getSelectableRows(rows: TableRow[], selectableKey: string): TableRow[]; /** @hidden */ declare function isSelectableRow(row: TableRow, selectableKey: string): boolean; /** @hidden */ declare function isItemRow(row: TableRow): boolean; /** @hidden */ declare function isTreeRow(row: TableRow): boolean; /** * Since we dont work with the tree, we need to convert incoming tree to * flat format while maintaining original state. * * @hidden */ declare function convertTreeTableRowToFlatList(rows: TableRow[], rowNavigatable: string | boolean): TableRow[]; /** @hidden */ declare function isRowNavigatable(row: T, rowNavigatable: string | boolean): boolean; /** @hidden */ declare function getFreezableColumns(columns: TableColumn[], freezeColumnsTo: string): Map; /** @hidden */ declare function getFreezableEndColumns(columns: TableColumn[], freezeEndColumnsTo: string): Map; /** @hidden */ declare function convertTreeObjectsToTableRows(source: T[], selectionMode: SelectionModeValue, tableRows: TableRow[], rowComparator: RowComparator, relationKey: string, hasChildrenKey: string, selectedKey: string, expandedStateKey: string, rowNavigatable: string | boolean, enableTristateMode?: boolean): TableRow[]; /** * @hidden * Runs `rowComparator` function against checked rows and compares them with the new `source` * If matched, creates an association between the source item and checked status of corresponding row. * * @returns `Map` object with the `checked` status for particular source item */ declare function getSelectionStatusByRowValue(source: T[], selectionMode: SelectionModeValue, tableRows: TableRow[], rowComparator: RowComparator): Map; /** @hidden */ declare function applySelectionToChildren(allRows: Array>, row: TableRow, addedRows: TableRow[], removedRows: TableRow[]): void; /** @hidden */ declare function findRowChildren(row: TableRow, allRows: TableRow[]): TableRow[]; /** * Get row parents path where the first is the direct parent * @param row Row which parents we need to find * @param untilParent Parent to stop a search on. Default is "null" that means look up until the root * @returns parents list [direct parent, ..., ancestor] * @hidden */ declare function getRowParents(row: TableRow, untilParent?: TableRow | null): TableRow[]; /** @hidden */ declare function toDataStream(source: FdpTableDataSource): TableDataSource | undefined; /** * @hidden * Creates an empty column skeleton object. * @returns Column model. */ declare function buildNewRowSkeleton(editableRowSkeleton: T, columns: TableColumn[]): T; /** @hidden */ declare function isGroupRow(row: TableRow): boolean; /** @hidden */ declare function sortTreeLikeGroupedRows(groupedRows: TreeLike[], groupRulesMap: Map): TreeLike[]; /** @hidden */ declare function convertTreeLikeToFlatList(treeLikeList: TreeLike[]): K[]; /** * @hidden * Group table rows and return tree like rows list. * It's intended to be called recursively. * @param rules group rules to group by * @param rows source table rows * @param parent row parent * @param level level of nesting */ declare function createGroupedTableRowsTree(rules: CollectionGroup[], rows: TableRow[], parent?: TableRow | null, level?: number): TreeLike[]; /** @hidden */ declare function convertObjectsToTableRows(source: T[], addedItems: T[], selectedKey: string, rowNavigatable: boolean | string, selectionMode: SelectionModeValue, rows: TableRow[], rowComparator: RowComparator): TableRow[]; /** @hidden */ declare function isTreeRowFirstCell(cellIndex: number, row: TableRow, event?: Event): boolean; declare const filterByString: (rows: TableRow[], filter: CollectionStringFilter) => TableRow[]; declare const filterByNumber: (rows: TableRow[], filter: CollectionNumberFilter) => TableRow[]; declare const filterByDate: (rows: TableRow[], filter: CollectionDateFilter, adapter: DatetimeAdapter) => TableRow[]; declare const filterByBoolean: (rows: TableRow[], filter: CollectionBooleanFilter) => TableRow[]; declare const getUniqueListValuesByKey: (list: T[], key: K) => T[]; declare const getScrollBarWidth: (document: Document) => number; /** @hidden */ declare function isCollectionFilter(item: any): item is CollectionFilter; export { ARIA_SORT, ArrayTableDataProvider, ArrayTableDataSource, BaseTableDataProvider, BaseTableDataSource, ChildTableDataSource, ColumnAlign, ColumnResizableSidePipe, ColumnsChange, DEFAULT_HIGHLIGHTING_KEY, DEFAULT_TABLE_PAGE, DEFAULT_TABLE_SEARCH_INPUT, DEFAULT_TABLE_STATE, EDITABLE_ROW_SEMANTIC_STATE, EditableTableCell, FDP_TABLE_DRAGGABLE_DIRECTIVE, FDP_TABLE_STATE_DIRECTIVE, FDP_TABLE_VIRTUAL_SCROLL_DIRECTIVE, FILTER_BOOLEAN_STRATEGIES, FILTER_BOOLEAN_STRATEGY, FILTER_DATE_STRATEGIES, FILTER_DATE_STRATEGY, FILTER_DEFAULT_STRATEGIES, FILTER_DEFAULT_STRATEGY, FILTER_NUMBER_STRATEGIES, FILTER_NUMBER_STRATEGY, FILTER_STRATEGY, FILTER_STRATEGY_LABEL, FILTER_STRING_STRATEGIES, FILTER_STRING_STRATEGY, FdpCellDef, FdpEditableCellDef, FdpEditableCellFormDirective, FdpHeaderCellDef, FdpTableCell, FdpTableHeader, FdpViewSettingsFilterCustomDef, FilterType, FilterableColumnDataType, ObservableTableDataProvider, ObservableTableDataSource, PageChange, PlatformTableCellResizableDirective, PlatformTableColumnResponsiveDirective, ROW_HEIGHT, RowClassesPipe, SELECTION_COLUMN_WIDTH, SEMANTIC_HIGHLIGHTING_COLUMN_WIDTH, SaveRowsEvent, SelectionCellStylesPipe, SelectionMode, SortDirection, TABLE_CELL_RESIZABLE_THRESHOLD_PX, TABLE_COLUMN_MIN_WIDTH, TABLE_RESIZER_BORDER_WIDTH, TABLE_SCROLLABLE, Table, TableCellActivateEvent, TableCellHeaderPopoverDirective, TableCellStylesPipe, TableChildrenDataProvider, TableColumn, TableColumnFreezeEvent, TableColumnResizeService, TableColumnSortingDirectionPipe, TableColumnsChangeEvent, TableDataProvider, TableDataSource, TableDataSourceDirective, TableDataSourceParser, TableDraggable, TableDraggableDirective, TableFilterChangeEvent, TableGroupChangeEvent, TableHeaderResizerDirective, TableHelpersModule, TableInitialState, TableInitialStateDirective, TablePageChangeEvent, TableResponsiveService, TableRowActivateEvent, TableRowImpl, TableRowSelectionChangeEvent, TableRowService, TableRowToggleOpenStateEvent, TableRowType, TableRowsRearrangeEvent, TableScrollDispatcherService, TableScrollableDirective, TableSearchChangeEvent, TableSelectionChangeEvent, TableService, TableSortChangeEvent, TableVirtualScroll, TableVirtualScrollDirective, applySelectionToChildren, buildNewRowSkeleton, convertObjectsToTableRows, convertTreeLikeToFlatList, convertTreeObjectsToTableRows, convertTreeTableRowToFlatList, createGroupedTableRowsTree, filterByBoolean, filterByDate, filterByNumber, filterByString, findRowChildren, getFilterStrategiesBasedOnDataType, getFreezableColumns, getFreezableEndColumns, getRowParents, getScrollBarWidth, getSelectableRows, getSelectionStatusByRowValue, getUniqueListValuesByKey, isCollectionFilter, isGroupRow, isItemRow, isRowNavigatable, isSelectableRow, isTableRow, isTreeRow, isTreeRowFirstCell, newTableRow, sortTreeLikeGroupedRows, toDataStream }; export type { BaseCollectionFilter, CellClickedModel, CollectionBooleanFilter, CollectionCustomFilter, CollectionDateFilter, CollectionFilter, CollectionFilterAndGroup, CollectionFilterGroup, CollectionFilterGroupStrategy, CollectionGroup, CollectionNumberFilter, CollectionPage, CollectionSelectFilter, CollectionSort, CollectionState, CollectionStringFilter, ColumnAlignValue, FdpCellDefContext, FdpColumnResponsiveState, FdpHeaderCellDefContext, FdpTableBreakpoint, FdpTableDataSource, FdpViewSettingsFilterCustomDefContext, FilterAllStrategy, FilterBooleanStrategy, FilterChange, FilterDateStrategy, FilterDefaultStrategy, FilterNumberStrategy, FilterStrategy, FilterStringStrategy, FreezeChange, GroupChange, GroupTableRowValueType, PlatformTableManagedPreset, RowComparator, SearchChange, SelectionModeValue, SortChange, TableCellHeaderPopoverDirectiveContext, TableColumnFreezeInternalEvent, TableColumnResizableSide, TableDialogCommonData, TableFilterSelectOption, TableRow, TableRowClass, TableRowKeyboardDrag, TableRowSemanticHighlight, TableRowState, TableScrollable, TableState, TableStateChange, TableStateProperty, ToggleRowModel, TreeLike, TreeTableItem, UpdatedDndRowsPosition };