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 { 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';
import { ContentDensityMode } from '@fundamental-ngx/core/content-density';

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<FilterStrategy, FdLanguageKeyIdentifier>;
/** Date Filter Strategies */
declare const FILTER_DATE_STRATEGY: Pick<FilterStrategyType, 'BETWEEN' | 'EQ' | 'AFTER' | 'ON_OR_AFTER' | 'BEFORE' | 'BEFORE_OR_ON'>;
type FilterDateStrategy = (typeof FILTER_DATE_STRATEGY)[keyof typeof FILTER_DATE_STRATEGY];
declare const FILTER_DATE_STRATEGIES: ReadonlyArray<FilterDateStrategy>;
/** Number Filter Strategies */
declare const FILTER_NUMBER_STRATEGY: Pick<FilterStrategyType, 'BETWEEN' | 'EQ' | 'GT' | 'GTE' | 'LT' | 'LTE'>;
type FilterNumberStrategy = (typeof FILTER_NUMBER_STRATEGY)[keyof typeof FILTER_NUMBER_STRATEGY];
declare const FILTER_NUMBER_STRATEGIES: ReadonlyArray<FilterNumberStrategy>;
/** String Filter Strategies */
declare const FILTER_STRING_STRATEGY: Pick<FilterStrategyType, 'BETWEEN' | 'CONTAINS' | 'EQ' | 'BEGINS_WITH' | 'ENDS_WITH' | 'GT' | 'GTE' | 'LT' | 'LTE'>;
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<FilterStringStrategy>;
/** Boolean Filter Strategies */
declare const FILTER_BOOLEAN_STRATEGY: Pick<FilterStrategyType, 'EQ'>;
type FilterBooleanStrategy = (typeof FILTER_BOOLEAN_STRATEGY)[keyof typeof FILTER_BOOLEAN_STRATEGY];
declare const FILTER_BOOLEAN_STRATEGIES: ReadonlyArray<FilterStringStrategy>;
/** Default Filter Strategies for undefined data type */
declare const FILTER_DEFAULT_STRATEGY: Pick<FilterStrategyType, 'EQ'>;
type FilterDefaultStrategy = (typeof FILTER_DEFAULT_STRATEGY)[keyof typeof FILTER_DEFAULT_STRATEGY];
declare const FILTER_DEFAULT_STRATEGIES: ReadonlyArray<FilterStringStrategy>;
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<T> {
    field: string;
    type?: FilterableColumnDataType;
    value: T;
    value2?: Nullable<T>;
    exclude?: boolean;
    strategy?: FilterStrategy;
    fieldName?: string;
}
interface CollectionStringFilter extends BaseCollectionFilter<string> {
    strategy: FilterStringStrategy;
}
interface CollectionNumberFilter extends BaseCollectionFilter<number> {
    strategy: FilterNumberStrategy;
}
interface CollectionDateFilter<D = any> extends BaseCollectionFilter<D> {
    strategy: FilterDateStrategy;
}
interface CollectionBooleanFilter extends BaseCollectionFilter<boolean> {
    strategy: FilterBooleanStrategy;
}
interface CollectionSelectFilter extends BaseCollectionFilter<any[]> {
    strategy: FilterDefaultStrategy;
}
interface CollectionCustomFilter<P extends FilterStrategy = FilterDefaultStrategy> extends BaseCollectionFilter<{
    [key: string]: any;
}> {
    strategy: P;
}
type CollectionFilter = CollectionStringFilter | CollectionNumberFilter | CollectionDateFilter | CollectionSelectFilter | CollectionBooleanFilter | CollectionCustomFilter<FilterStrategy>;
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<Nullable<string>>;
    /** 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<TemplateRef<any>>;
    /** Column cell template for editing mode. */
    abstract editableColumnCellTemplate: Nullable<TemplateRef<any>>;
    /** Column header template. */
    abstract headerCellTemplate: Nullable<TemplateRef<any>>;
    /** Column header template. */
    abstract footerCellTemplate: Nullable<TemplateRef<any>>;
    /** Column header popover template. */
    abstract headerCellPopoverTemplate: Nullable<TemplateRef<any>>;
    /** 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<boolean>;
    /** @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<T, P = T[], L = boolean> implements DataSource<T, P, L> {
    /**
     * 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<T>[]): void;
    /** @hidden */
    protected readonly _dataChanges$: BehaviorSubject<P>;
    /** @hidden */
    protected readonly _onDataRequested$: Subject<boolean>;
    /** @hidden */
    protected readonly _onDataReceived$: Subject<boolean>;
    /** @hidden */
    protected _dataLoading: L;
    /** @hidden */
    protected readonly _dataLoading$: BehaviorSubject<L>;
    /** @hidden */
    protected readonly _destroy$: Subject<void>;
    /** @hidden */
    protected constructor();
    /**
     * Emitted when new data has been requested.
     * @returns Observable
     */
    get dataRequested(): Observable<boolean>;
    /**
     * Emitted when new data has been received.
     * @returns Observable
     */
    get dataReceived(): Observable<boolean>;
    /**
     * Emitted when loading state has been changed.
     * @returns Observable.
     */
    get dataLoading(): Observable<L>;
    /**
     * Emits when the data from the provider has been changed.
     * @returns Observable of data source objects.
     */
    get dataChanges(): Observable<P>;
    /** @hidden */
    get isDataLoading(): L;
    /** @hidden */
    get data(): P;
    /** @hidden */
    open(): Observable<P>;
    /** @hidden */
    onDataRequested(): Observable<void>;
    /** @hidden */
    onDataReceived(): Observable<void>;
    /** @hidden */
    close(): void;
    /**
     * Closes the stream
     */
    unsubscribe(): void;
}
declare class TableDataSource<T> extends BaseTableDataSource<T> {
    readonly dataProvider: TableDataProvider<T>;
    /**
     * @hidden
     */
    constructor(dataProvider: TableDataProvider<T>);
    /**
     * 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<T> extends BaseTableDataSource<T, Map<TableRow<T>, T[]>, {
    row?: TableRow<T>;
    loading: boolean;
}[]> {
    readonly dataProvider: TableChildrenDataProvider<T>;
    /**
     * @hidden
     */
    constructor(dataProvider: TableChildrenDataProvider<T>);
    /**
     * 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<T>[]): void;
}

type FdpTableDataSource<T> = T[] | Observable<T[]> | TableDataSource<T>;

type TableRowState = 'editable' | 'readonly';
interface TableRowKeyboardDrag {
    direction: 'up' | 'down';
    event: KeyboardEvent;
    mode: 'group' | 'shift';
}
/**
 * Table row entity
 * Used to represent table row in the template
 */
interface TableRow<T = any> {
    /**
     * 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<TableRow['checked']>;
    /**
     * 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<TableRow['expanded']>;
    childItems$: Observable<T[]>;
    childItemsLoading$: BehaviorSubject<boolean>;
    stateChanged$: Observable<boolean>;
    /**
     * 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<T>[];
    isTree: boolean;
    setRowType: (type: TableRowType) => void;
    lastChild?: TableRow<T>;
    /** Flag indicating that all child rows should be fetched again. */
    forceFetch: boolean;
}
type TableRowClass<T = any> = string | ((row: T) => string);
/** @hidden */
declare function isTableRow<T = any>(row: TableRow<T>): row is TableRow<T>;
declare class TableRowImpl<T> implements TableRow<T> {
    /** @hidden */
    set checked(value: boolean | null);
    get checked(): boolean | null;
    /** @hidden */
    readonly checked$: Observable<boolean>;
    /** @hidden */
    readonly childItems$: Observable<T[]>;
    /** @hidden */
    readonly stateChanged$: BehaviorSubject<boolean>;
    /** @hidden */
    readonly childItemsLoading$: BehaviorSubject<boolean>;
    /** @hidden */
    forceFetch: boolean;
    /** @hidden */
    children: TableRow<T>[];
    /** @hidden */
    expandable: boolean;
    /** @hidden */
    set expanded(value: boolean);
    get expanded(): boolean;
    /** @hidden */
    readonly expanded$: Observable<boolean>;
    /** @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<T> | undefined;
    /** @hidden */
    isTree: boolean;
    /** @hidden */
    lastChild?: TableRow<T>;
    /** @hidden */
    private readonly _expandedSubject;
    /** @hidden */
    private readonly _checkedSubject;
    /** @hidden */
    constructor(row: Partial<TableRow>);
    /**
     * Sets the row type and checks whether the row is a tree.
     * @param type Row type.
     */
    setRowType(type: TableRowType): void;
}

declare class TableRowsRearrangeEvent<T> {
    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<T = any> {
    abstract dragDropInProgress: boolean;
    abstract enableRowReordering: boolean;
    abstract isTreeTable: boolean;
    abstract dropMode: FdDndDropType;
    abstract dropPredicate: DropPredicate<TableRow<T>>;
    abstract dragoverPredicate: DragoverPredicate<TableRow<T>>;
    abstract rowsRearrange: EventEmitter<TableRowsRearrangeEvent<T>>;
    abstract dragRowFromKeyboard(dir: string, event: Event, currentRowIndex: number, mode: 'shift' | 'group'): void;
    abstract dragDropItemDrop(event: FdDropEvent<TableRow>): void;
    abstract dragDropStart(): 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<number>;
    abstract virtualScroll: boolean;
    abstract virtualScrollTotalHeight: number;
    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<T = any> = (left: T, right: T) => boolean;

declare class SaveRowsEvent<T> {
    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<T> {
    /** 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<T> extends TableSelectionChangeEvent<T> {
    /** 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<T> {
    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<T, P extends string> = {
    [key in P]?: FdpTableDataSource<T>;
};

type PlatformTableManagedPreset = Partial<Omit<TableState, 'columnKeys'>>;

declare class TableRowActivateEvent<T> {
    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<T> {
    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> = T & {
    _children?: TreeLike<T>[];
};
interface GroupTableRowValueType {
    field: string;
    value: unknown;
    count: number;
}

declare abstract class BaseTableDataProvider<T, P = T[]> {
    abstract fetch(state?: TableState, parentRows?: TableRow<T>[]): Observable<P>;
    abstract fetchData(state: TableState, parentRows?: TableRow<T>[]): Observable<P>;
    /** Total items count. */
    totalItems: number;
    /** Array of items. */
    items: P;
    /** Date time adapter for date field filtering. */
    dateTimeAdapter?: DatetimeAdapter<any>;
    /** 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<void>;
    /**
     * 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<D = FdDate>(item: T, filter: CollectionDateFilter, adapter?: DatetimeAdapter<D>): 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<T> extends BaseTableDataProvider<T> {
    /**
     * Method for retrieving the data.
     * @param tableState @see TableState Set of table parameters.
     * @returns Observable with data.
     */
    fetch(tableState?: TableState): Observable<T[]>;
    /**
     * 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<T[]>;
    /**
     * 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<SelectItem[]>;
}
declare abstract class TableChildrenDataProvider<T> extends BaseTableDataProvider<T, Map<TableRow<T>, T[]>> {
    /**
     * Method for retrieving the amount of child itemf or a defined row.
     * @param row
     * @param state
     */
    abstract rowChildrenCount(row: TableRow<T>, state: TableState): Observable<number>;
    /**
     * Method for retrieving the data.
     * @param tableState @see TableState Set of table parameters.
     * @param parentRows
     * @returns Observable with data.
     */
    fetch(tableState?: TableState, parentRows?: TableRow<T>[]): Observable<Map<TableRow<T>, 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<T>[]): Observable<Map<TableRow<T>, T[]>>;
}

/**
 * Table Data Provider based on an array.
 *
 * Used to convert array source to the TableDataProvider interface.
 *
 */
declare class ArrayTableDataProvider<T> extends TableDataProvider<T> {
    /** @hidden */
    protected items$: BehaviorSubject<T[]>;
    /** @hidden */
    constructor(items: T[], dateTimeAdapter?: DatetimeAdapter<any>);
    /**
     * Method for retrieving the data.
     * @param tableState @see TableState Set of table parameters.
     * @returns Observable with data.
     */
    fetch(state?: TableState): Observable<T[]>;
}
declare class ArrayTableDataSource<T> extends TableDataSource<T> {
    /** @hidden */
    constructor(data: T[], dateTimeAdapter?: DatetimeAdapter<any>);
}

declare class TableDataSourceParser<T> implements DataSourceParser<T, TableDataSource<T>> {
    /** @hidden */
    parse(source: DataSource$1<T>): TableDataSource<T> | undefined;
}

/**
 * Table Data Provider based on an Observable.
 *
 * Used to convert observable source to the TableDataProvider interface.
 *
 */
declare class ObservableTableDataProvider<T> extends TableDataProvider<T> {
    /** @hidden */
    protected items$: Observable<T[]>;
    /** @hidden */
    constructor(items$: Observable<T[]>, dateTimeAdapter?: DatetimeAdapter<any>);
    /**
     * Method for retrieving the data.
     * @param tableState @see TableState Set of table parameters.
     * @returns Observable with data.
     */
    fetch(state?: TableState): Observable<T[]>;
}
declare class ObservableTableDataSource<T> extends TableDataSource<T> {
    /** @hidden */
    constructor(data: Observable<T[]>, dateTimeAdapter?: DatetimeAdapter<any>);
}

interface TableScrollable {
    /** Get scrollable ElementRef of. */
    elementRef: ElementRef<HTMLElement>;
    /** Returns observable that emits when a scroll event is fired on the host element. */
    getScrollStream(): Observable<Event>;
    /** Returns observable that emits when a vertical scroll event is happened on the host element. */
    getVerticalScrollStream(): Observable<Event>;
    /** Returns observable that emits when a horizontal scroll event is happened on the host element. */
    getHorizontalScrollStream(): Observable<Event>;
    /** 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<TableScrollable>;
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<TableScrollable>;
    /** Horizontal scroll stream */
    horizontallyScrolled(): Observable<TableScrollable>;
    /** Vertical scroll stream */
    verticallyScrolled(): Observable<TableScrollable>;
    /** @hidden */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableScrollDispatcherService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TableScrollDispatcherService>;
}

declare abstract class Table<T = any> implements PresetManagedComponent<PlatformTableManagedPreset> {
    abstract readonly name: string;
    abstract readonly id: string;
    abstract _loadPreviousPages: boolean;
    abstract pageScrolling: boolean;
    abstract loadPagesBefore: boolean;
    abstract pageSize: Nullable<number>;
    abstract freezeColumnsTo: string;
    abstract freezeEndColumnsTo: string;
    /** Event emitted when current preset configuration has been changed. */
    abstract presetChanged: EventEmitter<PlatformTableManagedPreset>;
    /** Sum of widths of fixed columns (semantic highlighting, selection) */
    abstract get _fixedColumnsPadding(): number;
    /** Freezable column names and their respective indexes */
    abstract get _freezableColumns(): ReadonlyMap<string, number>;
    /** Freezable column names and their respective indexes */
    abstract get _freezableEndColumns(): ReadonlyMap<string, number>;
    /** 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<TableColumn[]>;
    abstract readonly injector: Injector;
    abstract readonly tableContainer: ElementRef;
    abstract readonly tableScrollable: TableScrollable;
    abstract _tableRowsVisible: TableRow<T>[];
    abstract _tableRows: TableRow<T>[];
    abstract loadedRows$: Signal<number>;
    abstract _tableCurrentlyRenderedRowsPlaceholder: number[];
    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<T>;
    /** 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<T>, forceFetch?: boolean): any;
    abstract onTableRowsChanged(): void;
    abstract refreshDndList(): void;
    abstract clearTableRows(): void;
    /** Toolbar Sort Settings button click event */
    readonly openTableSortSettings: EventEmitter<void>;
    /** Toolbar Filter Settings button click event */
    readonly openTableFilterSettings: EventEmitter<void>;
    /** Toolbar Group Settings button click event */
    readonly openTableGroupSettings: EventEmitter<void>;
    /** Toolbar Column Settings button click event */
    readonly openTableColumnSettings: EventEmitter<void>;
    /** Event fired when table state changes. */
    readonly tableColumnFilterChange: EventEmitter<any>;
    /** Event fired when empty row added. */
    readonly emptyRowAdded: EventEmitter<void>;
    /** Event fired when save button pressed. */
    readonly save: EventEmitter<SaveRowsEvent<T>>;
    /** Event fired when cancel button pressed. */
    readonly cancel: EventEmitter<void>;
}

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<T = 'sort' | 'page' | 'filter' | 'group' | 'freeze' | 'columns' | 'search', P = SortChange | PageChange | FilterChange | GroupChange | FreezeChange | ColumnsChange> = {
    type: T;
    state: P;
};
declare class TableService {
    /** Table state stream. */
    readonly tableState$: BehaviorSubject<Readonly<TableState>>;
    /** @hidden */
    readonly _semanticHighlighting$: i0.WritableSignal<string>;
    /** @hidden */
    readonly _isFilteringFromHeaderDisabled$: i0.WritableSignal<boolean>;
    /** @hidden */
    readonly _isShownNavigationColumn$: i0.WritableSignal<boolean>;
    /** @hidden */
    readonly _semanticHighlightingColumnWidth$: i0.WritableSignal<number>;
    /** Visible columns stream. */
    readonly visibleColumns$: i0.WritableSignal<TableColumn[]>;
    /** Visible columns length. */
    visibleColumnsLength: i0.Signal<number>;
    /** Popping columns stream. */
    readonly poppingColumns$: i0.WritableSignal<TableColumn[]>;
    /** Popping columns length. */
    _poppingColumnsLength: number;
    /** Table columns stream. */
    readonly tableColumns$: BehaviorSubject<TableColumn[]>;
    /** @hidden */
    readonly tableStateChanges$: rxjs.Observable<Readonly<TableState>>;
    /** Stream that emits when search state changes. */
    readonly searchChange$: Subject<SearchChange>;
    /** Stream that emits when sort state changes. */
    readonly sortChange$: Subject<SortChange>;
    /** Stream that emits when filter state changes. */
    readonly filterChange$: Subject<FilterChange>;
    /** Stream that emits when group state changes. */
    readonly groupChange$: Subject<GroupChange>;
    /** Stream that emits when freeze state changes. */
    readonly freezeChange$: Subject<FreezeChange>;
    /** Stream that emits when columns state changes. */
    readonly columnsChange$: Subject<ColumnsChange>;
    /** Stream that emits when page state changes. */
    readonly pageChange$: Subject<PageChange>;
    /** Stream that emits when new fetch of data is needed. */
    readonly needFetch$: Subject<void>;
    /** @hidden */
    readonly stateChange$: Subject<TableStateChange>;
    /** Stream that emits when loading state changes. */
    readonly tableLoading$: BehaviorSubject<boolean>;
    /** Listen for soft changes in table subcomponents (mostly table column) */
    readonly markForCheck$: Subject<void>;
    /** Listen for immediate changes in table subcomponents (mostly table column) */
    readonly detectChanges$: Subject<void>;
    /** Sort rules stream. */
    readonly sortRules$: i0.WritableSignal<Map<string, CollectionSort>>;
    /**
     * 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<Map<string, CollectionFilter[]>>;
    /**
     * Group Rules Map stream. Where key is column key and value is associated group rule
     */
    readonly groupRulesSubject: BehaviorSubject<Map<string, CollectionGroup>>;
    /** Group Rules Map signal. */
    readonly groupRules$: i0.Signal<Map<string, CollectionGroup> | 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<TableService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TableService>;
}

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<string, FdpColumnResponsiveState>): 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<TableResponsiveService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TableResponsiveService>;
}

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<string, FdpColumnResponsiveState>);
    get breakpoints(): Record<number, FdpColumnResponsiveState>;
    /** @hidden */
    private _breakpoints;
    /** @hidden */
    constructor(_responsiveTableService: TableResponsiveService, _column: TableColumn | null);
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformTableColumnResponsiveDirective, [null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PlatformTableColumnResponsiveDirective, "[fdpTableColumnResponsive]", never, { "breakpoints": { "alias": "fdpTableColumnResponsive"; "required": false; }; }, {}, never, never, true, never>;
}

interface TableCellHeaderPopoverDirectiveContext {
    $implicit: Signal<TemplateRef<any>[]>;
}
declare class TableCellHeaderPopoverDirective {
    templateRef: TemplateRef<TableCellHeaderPopoverDirectiveContext>;
    /** @hidden */
    constructor(templateRef: TemplateRef<TableCellHeaderPopoverDirectiveContext>);
    /** @hidden */
    static ngTemplateContextGuard(directive: TableCellHeaderPopoverDirective, context: unknown): context is TableCellHeaderPopoverDirectiveContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellHeaderPopoverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellHeaderPopoverDirective, "[fdpTableCellHeaderPopover]", never, {}, {}, never, never, true, never>;
}

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 */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _getResizer;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformTableCellResizableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PlatformTableCellResizableDirective, "[fdpTableCellResizable]", never, { "resizableSide": { "alias": "fdpTableCellResizable"; "required": false; }; "columnName": { "alias": "columnName"; "required": false; }; }, {}, never, never, true, never>;
}

declare abstract class EditableTableCell {
    abstract form: NgForm;
}

interface FdpCellDefContext<T = any> {
    $implicit: T;
    popping: boolean;
    rowIndex: number;
}
/** Column cell container. */
declare class FdpTableCell {
    static ɵfac: i0.ɵɵFactoryDeclaration<FdpTableCell, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FdpTableCell, "fdp-table-cell", never, {}, {}, never, never, true, never>;
}
/**
 * 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<T = any> {
    templateRef: TemplateRef<FdpCellDefContext<T>>;
    /** Property to support typings. */
    fdpCellDefAs: T;
    /** @hidden */
    constructor(templateRef: TemplateRef<FdpCellDefContext<T>>);
    /** @hidden */
    static ngTemplateContextGuard<T>(dir: FdpCellDef<T>, ctx: FdpCellDefContext): ctx is FdpCellDefContext<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FdpCellDef<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FdpCellDef<any>, "[fdpCellDef]", never, { "fdpCellDefAs": { "alias": "fdpCellDefAs"; "required": false; }; }, {}, never, never, true, never>;
}
declare class FdpEditableCellDef {
    templateRef: TemplateRef<any>;
    /** @hidden */
    constructor(templateRef: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<FdpEditableCellDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FdpEditableCellDef, "[fdpEditableCellDef]", never, {}, {}, never, never, true, never>;
}
declare class FdpEditableCellFormDirective implements EditableTableCell {
    form: NgForm;
    /** @hidden */
    constructor(form: NgForm);
    static ɵfac: i0.ɵɵFactoryDeclaration<FdpEditableCellFormDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FdpEditableCellFormDirective, "[fdpEditableCellForm]", never, {}, {}, never, never, true, never>;
}

declare class TableDataSourceDirective<T> extends DataSourceDirective<T, TableDataSource<T>> implements OnDestroy {
    /**
     * Data source.
     * @param source
     */
    set childDataSource(source: ChildTableDataSource<T> | null);
    get childDataSource(): ChildTableDataSource<T> | null;
    /** Event emitted when child data source instance being changed. */
    childDataSourceChanged: EventEmitter<void>;
    /** Event emitted when data loading is started. */
    readonly onDataRequested: EventEmitter<void>;
    /** Event emitted when data loading is finished. */
    readonly onDataReceived: EventEmitter<void>;
    /** Total items count stream. */
    totalItems$: i0.WritableSignal<number>;
    /** Items stream. */
    items$: BehaviorSubject<T[]>;
    /** Child items stream. */
    childItems$: Subject<Map<TableRow<T>, T[]>>;
    /** @hidden */
    _tableDataSource: TableDataSource<T>;
    /** @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<TableDataSourceDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableDataSourceDirective<any>, "[fdpTableDataSource]", never, { "childDataSource": { "alias": "childDataSource"; "required": false; }; }, { "childDataSourceChanged": "childDataSourceChanged"; "onDataRequested": "onDataRequested"; "onDataReceived": "onDataReceived"; }, never, never, true, never>;
}

declare class TableDraggableDirective<T = any> extends TableDraggable<T> 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<TableRow<T>>;
    /**
     * 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<TableRow<T>>;
    /** Event fired when tree rows rearranged through drag & drop. Consider that rows rearranged with their children rows. */
    readonly rowsRearrange: EventEmitter<TableRowsRearrangeEvent<T>>;
    /** @hidden */
    get _rowsDraggable(): boolean;
    /** @hidden */
    dragDropInProgress: boolean;
    /** @hidden */
    private _table;
    /** @hidden */
    private readonly _ngZone;
    /** @hidden */
    private readonly _cdr;
    /** @hidden */
    ngOnDestroy(): void;
    /** Sets table reference. */
    setTable(table: Table): void;
    /**
     * Initiates drag&drop sequence.
     */
    dragDropStart(): 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<TableRow>): void;
    /**
     * @hidden
     * Create table rows rearrange event
     */
    _emitRowsRearrangeEvent(row: TableRow, dropRow: TableRow, event: FdDropEvent<TableRow>): 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 _onZoneFree;
    /** @hidden */
    private _blockScrolling;
    /** @hidden */
    private _enableScrolling;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableDraggableDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableDraggableDirective<any>, "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<FocusableCellPosition>;
    /** @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<TableHeaderResizerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableHeaderResizerDirective, "[fdpTableHeaderResizer]", never, {}, {}, never, never, true, never>;
}

interface FdpHeaderCellDefContext<T = any> {
    $implicit: T;
}
/** Column header container. */
declare class FdpTableHeader {
    static ɵfac: i0.ɵɵFactoryDeclaration<FdpTableHeader, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FdpTableHeader, "fdp-table-header", never, {}, {}, never, never, true, never>;
}
/**
 * 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<T = any> {
    templateRef: TemplateRef<FdpCellDefContext<T>>;
    /** @hidden */
    constructor(templateRef: TemplateRef<FdpCellDefContext<T>>);
    /** @hidden */
    static ngTemplateContextGuard(dir: FdpHeaderCellDef, ctx: FdpHeaderCellDefContext): ctx is FdpHeaderCellDefContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<FdpHeaderCellDef<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FdpHeaderCellDef<any>, "[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<TableInitialStateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableInitialStateDirective, "[fdpTableInitialState],    fdp-table", never, { "initialVisibleColumns": { "alias": "initialVisibleColumns"; "required": false; }; "initialSortBy": { "alias": "initialSortBy"; "required": false; }; "initialFilterBy": { "alias": "initialFilterBy"; "required": false; }; "initialGroupBy": { "alias": "initialGroupBy"; "required": false; }; "initialPage": { "alias": "initialPage"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * 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<HTMLElement>;
    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<HTMLElement>, 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<Event>;
    /** Returns observable that emits when a vertical scroll event is happened on the host element. */
    getVerticalScrollStream(): Observable<Event>;
    /** Returns observable that emits when a horizontal scroll event is happened on the host element. */
    getHorizontalScrollStream(): Observable<Event>;
    /** 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<TableScrollableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableScrollableDirective, "[fdpTableScrollable]", ["tableScrollable"], {}, {}, never, never, true, never>;
}

interface FdpViewSettingsFilterCustomDefContext {
    $implicit: any;
    valueChangeEmitter: EventEmitter<unknown>;
    contentDensity: ContentDensityMode;
}
declare class FdpViewSettingsFilterCustomDef {
    templateRef: TemplateRef<FdpViewSettingsFilterCustomDefContext>;
    /** @hidden */
    constructor(templateRef: TemplateRef<FdpViewSettingsFilterCustomDefContext>);
    /** @hidden */
    static ngTemplateContextGuard(dir: FdpViewSettingsFilterCustomDef, ctx: FdpViewSettingsFilterCustomDefContext): ctx is FdpViewSettingsFilterCustomDefContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<FdpViewSettingsFilterCustomDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FdpViewSettingsFilterCustomDef, "[fdpViewSettingsFilterCustomDef]", never, {}, {}, never, never, true, never>;
}

declare class TableVirtualScrollDirective extends TableVirtualScroll implements OnChanges {
    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;
    /** @hidden */
    virtualScrollTotalHeight: number;
    /** @hidden */
    virtualScrollTransform$: BehaviorSubject<number>;
    /** @hidden */
    private _table;
    /** @hidden */
    private _virtualScrollCache;
    /** @hidden */
    private readonly _tableScrollDispatcher;
    /** @hidden */
    private readonly _dndTableDirective;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    constructor(_tableService: TableService);
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** Sets table reference. */
    setTable(table: Table): void;
    /**
     * Calculates rows to be rendered in the table.
     */
    calculateVirtualScrollRows(): void;
    /**
     * Initialises scroll listener.
     */
    listenOnVirtualScroll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableVirtualScrollDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableVirtualScrollDirective, "fdp-table[virtualScroll]", never, { "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "renderAhead": { "alias": "renderAhead"; "required": false; }; "bodyHeight": { "alias": "bodyHeight"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "secondaryRowHeight": { "alias": "secondaryRowHeight"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SelectionCellStylesPipe implements PipeTransform {
    /** @hidden */
    transform(contentDensity: Nullable<ContentDensityMode>, rtl: boolean, semanticHighlightingColumnWidth: number | null): Record<string, string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionCellStylesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SelectionCellStylesPipe, "selectionCellStyles", true>;
}

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<string, number | string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellStylesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TableCellStylesPipe, "tableCellStyles", true>;
}

declare class ColumnResizableSidePipe implements PipeTransform {
    /** @hidden */
    transform(columnIndex: number, visibleColumnsLength: number, navigationColumnShown: boolean | null): TableColumnResizableSide;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnResizableSidePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnResizableSidePipe, "columnResizableSide", true>;
}

declare class RowClassesPipe implements PipeTransform {
    /** @hidden */
    transform(row: TableRow, rowsClass: TableRowClass): string;
    /** @hidden */
    private _getRowCustomCssClasses;
    static ɵfac: i0.ɵɵFactoryDeclaration<RowClassesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RowClassesPipe, "rowClasses", true>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class TableHelpersModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TableHelpersModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TableHelpersModule, never, [typeof TableInitialStateDirective, typeof TableDraggableDirective, typeof TableVirtualScrollDirective, typeof PlatformTableColumnResponsiveDirective, typeof FdpTableCell, typeof TableCellHeaderPopoverDirective, typeof PlatformTableCellResizableDirective, typeof TableDataSourceDirective, typeof TableDraggableDirective, typeof FdpTableHeader, typeof TableHeaderResizerDirective, typeof TableInitialStateDirective, typeof TableScrollableDirective, typeof FdpCellDef, typeof FdpEditableCellDef, typeof FdpEditableCellFormDirective, typeof FdpViewSettingsFilterCustomDef, typeof TableVirtualScrollDirective, typeof FdpHeaderCellDef, typeof SelectionCellStylesPipe, typeof TableCellStylesPipe, typeof ColumnResizableSidePipe, typeof RowClassesPipe], [typeof TableInitialStateDirective, typeof TableDraggableDirective, typeof TableVirtualScrollDirective, typeof PlatformTableColumnResponsiveDirective, typeof FdpTableCell, typeof TableCellHeaderPopoverDirective, typeof PlatformTableCellResizableDirective, typeof TableDataSourceDirective, typeof TableDraggableDirective, typeof FdpTableHeader, typeof TableHeaderResizerDirective, typeof TableInitialStateDirective, typeof TableScrollableDirective, typeof FdpCellDef, typeof FdpEditableCellDef, typeof FdpEditableCellFormDirective, typeof FdpViewSettingsFilterCustomDef, typeof TableVirtualScrollDirective, typeof FdpHeaderCellDef, typeof SelectionCellStylesPipe, typeof TableCellStylesPipe, typeof ColumnResizableSidePipe, typeof RowClassesPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TableHelpersModule>;
}

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<Map<string, string>>;
    /** Indicate if resizing process in progress. */
    get resizeInProgress(): boolean;
    /** Resize progress stream. */
    readonly resizeInProgress$: BehaviorSubject<boolean>;
    /** Whether cell mock should be visible. */
    readonly cellMockVisible$: i0.WritableSignal<boolean>;
    /** Current column resizer position. */
    get resizerPosition(): number;
    /** Resizer position stream. */
    readonly resizerPosition$: BehaviorSubject<number>;
    /** Observable to notify to run CD */
    get markForCheck(): Observable<void>;
    /** 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 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;
    /** 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<TableColumnResizeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TableColumnResizeService>;
}

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<T = any> {
    /** Stream that emits when toggling all selectable rows is needed. */
    readonly toggleAllSelectableRows$: Observable<boolean>;
    /** Stream that emits when table cell being clicked. */
    readonly cellClicked$: Observable<CellClickedModel>;
    /** Stream that emits when scrolling to overlapped cell is needed. */
    readonly scrollToOverlappedCell$: Observable<void>;
    /** Stream that emits when the table cell being focused. */
    readonly cellFocused$: Observable<FocusableItemPosition>;
    /** Stream that emits when the table cell being focused. */
    readonly cellActivate$: Observable<TableCellActivateEvent<any>>;
    /** Toggle row stream. */
    readonly toggleRow$: Observable<ToggleRowModel>;
    /** Editable cells map. */
    readonly editableCells: Map<TableRow<any>, EditableTableCell[]>;
    /** @hidden */
    readonly childRowsAdded$: Subject<{
        row: TableRow;
        rowIndex: number;
        items: T[];
    }>;
    /** Stream to load child items for a particular rows. */
    readonly loadChildRows$: Subject<TableRow<T>[]>;
    /** @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<CollectionGroup>, groupRulesMap: Map<string, CollectionGroup>): 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<T> | TableRow<T>[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TableRowService<any>>;
}

declare const ARIA_SORT: Record<`${SortDirection}`, string>;
declare class TableColumnSortingDirectionPipe implements PipeTransform {
    /** @hidden */
    transform(sorting: Nullable<CollectionSort>): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnSortingDirectionPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TableColumnSortingDirectionPipe, "fdpTableColumnSortingDirection", true>;
}

declare const FDP_TABLE_DRAGGABLE_DIRECTIVE: InjectionToken<TableDraggable<any>>;
declare const FDP_TABLE_STATE_DIRECTIVE: InjectionToken<TableInitialState>;
declare const FDP_TABLE_VIRTUAL_SCROLL_DIRECTIVE: InjectionToken<TableVirtualScroll>;

declare const DEFAULT_TABLE_PAGE: Readonly<CollectionPage>;
declare const DEFAULT_TABLE_SEARCH_INPUT: Readonly<SearchInput>;
declare const DEFAULT_TABLE_STATE: Readonly<TableState>;
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<ContentDensityMode, number>;
declare const TABLE_COLUMN_MIN_WIDTH = 50;
declare const ROW_HEIGHT: ReadonlyMap<ContentDensityMode, number>;

/** @hidden */
declare function newTableRow<T = any>(row: Partial<TableRow<T>>): TableRow<T>;
/** @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<T>(rows: TableRow<T>[], rowNavigatable: string | boolean): TableRow<T>[];
/** @hidden */
declare function isRowNavigatable<T>(row: T, rowNavigatable: string | boolean): boolean;
/** @hidden */
declare function getFreezableColumns(columns: TableColumn[], freezeColumnsTo: string): Map<string, number>;
/** @hidden */
declare function getFreezableEndColumns(columns: TableColumn[], freezeEndColumnsTo: string): Map<string, number>;
/** @hidden */
declare function convertTreeObjectsToTableRows<T>(source: T[], selectionMode: SelectionModeValue, tableRows: TableRow<T>[], rowComparator: RowComparator<T>, relationKey: string, hasChildrenKey: string, selectedKey: string, expandedStateKey: string, rowNavigatable: string | boolean, enableTristateMode?: boolean): TableRow<T>[];
/**
 * @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<T>(source: T[], selectionMode: SelectionModeValue, tableRows: TableRow[], rowComparator: RowComparator<T>): Map<T, boolean | null>;
/** @hidden */
declare function applySelectionToChildren<T>(allRows: Array<TableRow<T>>, row: TableRow, addedRows: TableRow<T>[], removedRows: TableRow<T>[]): void;
/** @hidden */
declare function findRowChildren<T>(row: TableRow<T>, allRows: TableRow<T>[]): TableRow<T>[];
/**
 * 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<T>(row: TableRow<T>, untilParent?: TableRow<T> | null): TableRow<T>[];
/** @hidden */
declare function toDataStream<T>(source: FdpTableDataSource<T>): TableDataSource<T> | undefined;
/**
 * @hidden
 * Creates an empty column skeleton object.
 * @returns Column model.
 */
declare function buildNewRowSkeleton<T>(editableRowSkeleton: T, columns: TableColumn[]): T;
/** @hidden */
declare function isGroupRow(row: TableRow): boolean;
/** @hidden */
declare function sortTreeLikeGroupedRows(groupedRows: TreeLike<TableRow>[], groupRulesMap: Map<string, CollectionGroup>): TreeLike<TableRow>[];
/** @hidden */
declare function convertTreeLikeToFlatList<K>(treeLikeList: TreeLike<K>[]): 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<TableRow>[];
/** @hidden */
declare function convertObjectsToTableRows<T>(source: T[], addedItems: T[], selectedKey: string, rowNavigatable: boolean | string, selectionMode: SelectionModeValue, rows: TableRow[], rowComparator: RowComparator): TableRow<T>[];
/** @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: <D = any>(rows: TableRow[], filter: CollectionDateFilter, adapter: DatetimeAdapter<D>) => TableRow[];
declare const filterByBoolean: (rows: TableRow[], filter: CollectionBooleanFilter) => TableRow[];
declare const getUniqueListValuesByKey: <T, K extends keyof T>(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, TableRowState, TableScrollable, TableState, TableStateChange, TableStateProperty, ToggleRowModel, TreeLike, TreeTableItem, UpdatedDndRowsPosition };
