import * as i0 from '@angular/core';
import { Signal, InjectionToken, AfterViewInit, TemplateRef, QueryList, OnInit, NgZone, Renderer2, ElementRef, OnChanges, SimpleChanges, OnDestroy, ChangeDetectorRef, EventEmitter, AfterViewChecked, PipeTransform, Injector, TrackByFunction, DestroyRef } from '@angular/core';
import { Nullable, TemplateDirective, ContentDensity, FocusableGridDirective, TabbableElementService, FocusableCellPosition, FocusableItemPosition, FocusableItem } from '@fundamental-ngx/cdk/utils';
import { ContentDensityMode, ContentDensityObserver } from '@fundamental-ngx/core/content-density';
import { SearchInput, SuggestionItem } from '@fundamental-ngx/platform/search-field';
import * as _fundamental_ngx_platform_table_helpers from '@fundamental-ngx/platform/table-helpers';
import { TableColumn, SortDirection, ColumnAlignValue, TableColumnResizeService, FilterableColumnDataType, FdpCellDef, FdpEditableCellDef, FdpHeaderCellDef, TableCellHeaderPopoverDirective, FdpColumnResponsiveState, TableService, TableDialogCommonData, CollectionFilter, FilterStrategy, CollectionGroup, Table, FilterType, TableFilterSelectOption, FdpViewSettingsFilterCustomDef, CollectionSort, SelectionModeValue, SelectionMode, TableRowService, RowComparator, TableRowClass, TableState, TableRowSelectionChangeEvent, TableSortChangeEvent, TableFilterChangeEvent, TableGroupChangeEvent, TableColumnsChangeEvent, TablePageChangeEvent, TableColumnFreezeEvent, TableRowToggleOpenStateEvent, TableCellActivateEvent, TableRowActivateEvent, SaveRowsEvent, TableScrollable, EditableTableCell, TableRow, TableDataSourceDirective, TableInitialState, TableVirtualScroll, TableDraggable, TableScrollDispatcherService, PlatformTableManagedPreset, TableDataSource, TableRowKeyboardDrag, isTreeRowFirstCell, isTreeRow } from '@fundamental-ngx/platform/table-helpers';
export * from '@fundamental-ngx/platform/table-helpers';
import { BehaviorSubject, Observable } from 'rxjs';
import { Placement, HeadingLevel } from '@fundamental-ngx/core/shared';
import { TableRowDirective } from '@fundamental-ngx/core/table';
import { DialogRef, DialogService, DialogConfig } from '@fundamental-ngx/core/dialog';
import * as _fundamental_ngx_i18n from '@fundamental-ngx/i18n';
import { NgForm } from '@angular/forms';
import { PopoverComponent, TriggerConfig } from '@fundamental-ngx/core/popover';
import { ListComponent } from '@fundamental-ngx/platform/list';

declare class NoDataWrapperComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<NoDataWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NoDataWrapperComponent, "fdp-table-no-data-wrapper", never, {}, {}, never, ["*"], true, never>;
}

/**
 * Reset button.
 *
 * Used to reset resettable state by click.
 *
 */
interface Resettable {
    reset: () => void;
    isResetAvailable$: Signal<boolean>;
}
declare const RESETTABLE_TOKEN: InjectionToken<Resettable>;
declare class ResetButtonComponent {
    resettable: Resettable;
    /** @hidden */
    constructor(resettable: Resettable);
    static ɵfac: i0.ɵɵFactoryDeclaration<ResetButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResetButtonComponent, "fdp-table-reset-button", never, {}, {}, never, never, true, never>;
}

declare class TableCellHeaderPopoverComponent implements AfterViewInit {
    /** Column definition. */
    column: TableColumn;
    /** Custom popover template. */
    popoverTemplate: Nullable<TemplateRef<any>>;
    /** Whether the popover is disabled. */
    disabled: boolean;
    /** Whether the column is frozen. */
    columnFrozen: boolean;
    /** Whether the filtering from header is disabled. */
    filteringFromHeaderDisabled: Nullable<boolean>;
    /** Column index */
    columnIndex: number;
    /** @hidden */
    popover: Nullable<PopoverComponent>;
    /** @hidden */
    _popoverItems: QueryList<TemplateDirective>;
    /** @hidden */
    _listComponent: ListComponent<any>;
    /** @hidden */
    _popoverItems$: i0.WritableSignal<TemplateRef<any>[]>;
    /** @hidden */
    _headerPopoverTriggers: TriggerConfig[];
    /** @hidden */
    protected readonly SORT_DIRECTION: typeof SortDirection;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _tableService;
    /** @hidden */
    private readonly _table;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    mapColumnAlignToPlacement(columnAlignValue: Nullable<ColumnAlignValue>): Placement;
    /** @hidden */
    _setColumnHeaderSortBy(field: TableColumn['key'], direction: SortDirection): void;
    /** @hidden */
    _setColumnHeaderGroupBy(field: TableColumn['key']): void;
    /** @hidden */
    _setColumnHeaderFilterBy(field: TableColumn['key'], value: any): void;
    /** @hidden */
    _freeze(): void;
    /** @hidden */
    _unFreeze(): void;
    /** @hidden */
    _popoverOpened(isOpen: boolean): void;
    /** @hidden */
    _closePopover(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellHeaderPopoverComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellHeaderPopoverComponent, "fdp-table-cell-header-popover", never, { "column": { "alias": "column"; "required": false; }; "popoverTemplate": { "alias": "popoverTemplate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "columnFrozen": { "alias": "columnFrozen"; "required": false; }; "filteringFromHeaderDisabled": { "alias": "filteringFromHeaderDisabled"; "required": false; }; "columnIndex": { "alias": "columnIndex"; "required": false; }; }, {}, never, never, true, never>;
}

/** @dynamic */
declare class PlatformTableColumnResizerComponent implements OnInit {
    private readonly _ngZone;
    private readonly _tableColumnResizeService;
    private readonly _renderer;
    private readonly _elmRef;
    private readonly _document;
    /** @hidden */
    private _pointerMoveListener;
    /** @hidden */
    private _destroyRef;
    /** @hidden */
    private readonly _isRtl;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    constructor(_ngZone: NgZone, _tableColumnResizeService: TableColumnResizeService, _renderer: Renderer2, _elmRef: ElementRef, _document: Document | null);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    private _listenForMouseUp;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformTableColumnResizerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlatformTableColumnResizerComponent, "fdp-table-column-resizer", never, {}, {}, never, never, true, never>;
}

/**
 * The component that represents a table column.
 * ```html
 * <fdp-column
 *  name="name"
 *  key="name"
 *  label="Name"
 *  align="start">
 * </fdp-column>
 *
 * <fdp-column
 *  name="price"
 *  key="price.value">
 *  <fdp-table-header *fdpHeaderCellDef>Price</fdp-table-header>
 *  <fdp-table-cell *fdpCellDef="let item">
 *   {{item.price.value}} {{item.price.currency}}
 *  </fdp-table-cell>
 * </fdp-column>
 * ```
 * */
declare class TableColumnComponent extends TableColumn implements OnInit, OnChanges {
    private readonly _tableColumnResizeService;
    private readonly _tableService?;
    /** Column unique identifier. */
    name: string;
    /** Column data accessor. */
    key: string;
    /** Column header label. */
    set label(value: string);
    get label(): string;
    /** Column footer label, to be used when the footer contains only text. */
    footerLabel: string;
    /** Column footer cell template, to be used when the footer cell requires more complex content than only text. */
    footerCellTemplate: Nullable<TemplateRef<any>>;
    /** Cell text alignment. */
    align: ColumnAlignValue;
    /** Toggles sort feature for the column. */
    sortable: boolean;
    /** Toggles filter feature for the column. */
    filterable: boolean;
    /** Initial visibility state of the column. Default `true`. */
    visible: boolean;
    /**
     * Data type the column represents. Default is 'string'
     * @type { 'string' | 'number' | 'date' | 'boolean' }
     */
    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.
     * */
    filterSelectOptions: string[];
    /** Toggles grouping feature for the column. */
    groupable: boolean;
    /** Toggles freeze feature for the column. */
    freezable: boolean;
    /** Toggles freeze feature for the column. */
    endFreezable: boolean;
    /** Whether the table cell inside table header should be non-interactive. */
    nonInteractive: boolean;
    /** Width of the column cells. */
    set width(value: string);
    get width(): string;
    /** Whether the text should wrap, when text is too long for 1 line */
    noWrap: boolean;
    /** Whether to apply fd-table-text (text-shadow) to the cell content, if disabled noWrap has no effect. */
    applyText: boolean;
    /** Column role attribute. */
    role: 'cell' | 'rowheader' | 'gridcell';
    /** Whether to announce empty cells to screen readers. Default is true. */
    readonly announceEmptyCell: i0.InputSignal<boolean>;
    /** Column cell template */
    columnCellTemplate: Nullable<TemplateRef<any>>;
    /** Label change event */
    labelValueChanges$: BehaviorSubject<string>;
    /** Editable column cell template. */
    editableColumnCellTemplate: Nullable<TemplateRef<any>>;
    /** Column header template */
    headerCellTemplate: Nullable<TemplateRef<any>>;
    /** Column header popover template. */
    headerCellPopoverTemplate: Nullable<TemplateRef<any>>;
    /** Stores information for the header cell if the ellipsis are visible after the column resize */
    headerOverflows: boolean;
    /** @hidden */
    _freezed: boolean;
    /** @hidden */
    _endFreezed: boolean;
    /** @hidden */
    set fdpCellDef(fdpCellDef: Nullable<FdpCellDef>);
    /** Editable column cell template definition. */
    set fdpEditableCellDef(fdpEditableCellDef: Nullable<FdpEditableCellDef>);
    /** @hidden */
    set fdpHeaderCellDef(fdpHeaderCellDef: Nullable<FdpHeaderCellDef>);
    /** @hidden */
    set fdpHeaderCellPopover(popover: Nullable<TableCellHeaderPopoverDirective>);
    /** Responsive state of the column. */
    responsiveState: FdpColumnResponsiveState;
    /** @hidden */
    private _width;
    /** @hidden */
    constructor(_tableColumnResizeService: TableColumnResizeService, _tableService?: TableService | undefined);
    /** @hidden */
    ngOnInit(): void;
    /** Table won't know about column properties update so notify about it manually
     * @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    private _validateNameOption;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnComponent, [null, { optional: true; host: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnComponent, "fdp-column", never, { "name": { "alias": "name"; "required": false; }; "key": { "alias": "key"; "required": false; }; "label": { "alias": "label"; "required": false; }; "footerLabel": { "alias": "footerLabel"; "required": false; }; "footerCellTemplate": { "alias": "footerCellTemplate"; "required": false; }; "align": { "alias": "align"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "dataType": { "alias": "dataType"; "required": false; }; "filterSelectOptions": { "alias": "filterSelectOptions"; "required": false; }; "groupable": { "alias": "groupable"; "required": false; }; "freezable": { "alias": "freezable"; "required": false; }; "endFreezable": { "alias": "endFreezable"; "required": false; }; "nonInteractive": { "alias": "nonInteractive"; "required": false; }; "width": { "alias": "width"; "required": false; }; "noWrap": { "alias": "noWrap"; "required": false; }; "applyText": { "alias": "applyText"; "required": false; }; "role": { "alias": "role"; "required": false; }; "announceEmptyCell": { "alias": "announceEmptyCell"; "required": false; "isSignal": true; }; }, {}, ["fdpCellDef", "fdpEditableCellDef", "fdpHeaderCellDef", "fdpHeaderCellPopover"], never, true, never>;
}

declare class TableHeaderCellContentComponent {
    /** Table Id */
    id: string;
    /** Column reference. */
    set column(value: Nullable<TableColumn>);
    get column(): Nullable<TableColumn>;
    /** Whether column has applied sorting. */
    readonly hasSorting$: i0.Signal<boolean | null | undefined>;
    /** Whether column has applied filtering. */
    readonly hasFilter$: i0.Signal<boolean | null | undefined>;
    /** Applied sorting. */
    readonly sorting$: i0.Signal<_fundamental_ngx_platform_table_helpers.CollectionSort | null | undefined>;
    /** @hidden */
    readonly SORT_DIRECTION: typeof SortDirection;
    /** @hidden */
    private readonly _column$;
    /** @hidden */
    private readonly _fdpTableService;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderCellContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableHeaderCellContentComponent, "fdp-table-header-cell-content", never, { "id": { "alias": "id"; "required": false; }; "column": { "alias": "column"; "required": false; }; }, {}, never, ["*"], true, never>;
}

interface DialogTableColumn {
    label: string;
    key: string;
}
type VisibleColumnType = string;
interface ColumnsDialogData extends TableDialogCommonData {
    availableColumns: DialogTableColumn[];
    visibleColumns: VisibleColumnType[];
}
interface ColumnsDialogResultData {
    visibleColumns: VisibleColumnType[];
    columnOrder?: VisibleColumnType[];
}
declare class SelectableColumn {
    /** Selected */
    selected: boolean;
    /** Active */
    active: boolean;
    /** Table Column it belongs to */
    column: DialogTableColumn;
    constructor(
    /** Selected */
    selected: boolean, 
    /** Active */
    active: boolean, 
    /** Table Column it belongs to */
    column: DialogTableColumn);
}
declare class P13ColumnsDialogComponent implements Resettable, OnInit, OnDestroy {
    dialogRef: DialogRef<ColumnsDialogData>;
    private cdr;
    /** Indicates when reset command is available */
    readonly isResetAvailable$: i0.WritableSignal<boolean>;
    /** Table columns available for grouping */
    readonly availableColumns: DialogTableColumn[];
    /** All available columns for interacting */
    _selectableColumns: SelectableColumn[];
    /** filtered columns that are rendered in the list */
    _filteredColumns: SelectableColumn[];
    /** Search Query subject */
    _searchQuerySubject: BehaviorSubject<string>;
    /** Show All flag subject */
    _showAllItemsSubject: BehaviorSubject<boolean>;
    /** Selected columns count */
    _selectedColumnsCount: number;
    /** Flag to track disabled state for move-down move-up buttons */
    _moveUpDisabled: boolean;
    /** Flag to track disabled state for move-down move-up buttons */
    _moveDownDisabled: boolean;
    /** @hidden */
    get _isShownAllItems(): boolean;
    /** @hidden */
    get _selectAllDisabled(): boolean;
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    constructor(dialogRef: DialogRef<ColumnsDialogData>, cdr: ChangeDetectorRef);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Reset to the initial state */
    reset(): void;
    /** Close dialog */
    cancel(): void;
    /** Confirm changes and close dialog */
    confirm(): void;
    /** @hidden */
    _toggleSelectAll(selectAll: boolean): void;
    /** @hidden */
    _onToggleColumn(): void;
    /** @hidden */
    _recalculateResetAvailability(): void;
    /** @hidden */
    _searchInputChange({ text }: SearchInput): void;
    /** @hidden */
    _toggleShowAll(): void;
    /** @hidden */
    _setActiveColumn(column: SelectableColumn | null): void;
    /** @hidden */
    _moveActiveToTop(event: Event): void;
    /** @hidden */
    _moveActiveToBottom(event: Event): void;
    /** @hidden */
    _moveActiveUp(event: Event): void;
    /** @hidden */
    _moveActiveDown(event: Event): void;
    /** @hidden */
    _isReorderColumnButtonShowable(item: SelectableColumn): boolean;
    /** @hidden */
    _filterByColumnKy(index: number, item: SelectableColumn): string;
    /**
     * @hidden
     * @param visibleColumnKeys keys of columns that should be displayed as selected.
     * Also, their order matters: it will be used
     */
    private _initiateColumns;
    /** @hidden */
    private _listenToFilterOptions;
    /** @hidden */
    private _onChangeFilteredColumnsList;
    /** @hidden */
    private _getVisibleColumnsFromSelectedColumns;
    /** @hidden */
    private _getColumnOrder;
    /** @hidden */
    private _getActiveColumnIndexInFilteredList;
    /** @hidden */
    private _moveColumnInFilteredListByIndex;
    /**
     * @hidden
     * Move column in selectable list.
     */
    private _moveColumnInSelectableList;
    /**
     * @hidden
     * Move element in the list
     * @return moved item and replaced item.
     */
    private _moveElementInTheListByIndex;
    /** @hidden */
    private _countSelectedColumns;
    /** @hidden */
    private _calculateMovementButtonsState;
    static ɵfac: i0.ɵɵFactoryDeclaration<P13ColumnsDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<P13ColumnsDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

interface FilterableColumn {
    label: string;
    key: string;
    dataType: FilterableColumnDataType;
    filterable?: boolean;
    filterSelectOptions?: string[];
}
interface FilterDialogData extends TableDialogCommonData {
    collectionFilter: CollectionFilter[];
    columns: FilterableColumn[];
    validator?: ((rules: CollectionFilter[]) => boolean) | undefined;
}
interface FilterDialogResultData {
    collectionFilter: CollectionFilter[];
}
/**
 * Filter Rule
 *
 * represents one rule per row
 */
declare class FilterRule<T = any> {
    readonly columns: ReadonlyArray<FilterableColumn>;
    /** Column key the rule belongs to */
    columnKey?: string | undefined;
    /** Data type */
    strategy?: FilterStrategy | undefined;
    /** Main filter value */
    value?: (T | null) | undefined;
    /** Additional filter value */
    value2?: (T | null) | undefined;
    /** Validation flg */
    isValid: boolean;
    /** Available strategies options */
    strategies: ReadonlyArray<FilterStrategy>;
    /** Data type */
    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.
     * */
    filterSelectOptions: string[];
    /** returns whether filter rule has value */
    get hasValue(): boolean;
    /** @hidden */
    constructor(columns: ReadonlyArray<FilterableColumn>, 
    /** Column key the rule belongs to */
    columnKey?: string | undefined, 
    /** Data type */
    strategy?: FilterStrategy | undefined, 
    /** Main filter value */
    value?: (T | null) | undefined, 
    /** Additional filter value */
    value2?: (T | null) | undefined);
    /** @hidden */
    setValid(isValid: boolean): void;
    /** @hidden */
    setValue(value: T | null): void;
    /** @hidden */
    setValue2(value: T | null): void;
    /** @hidden */
    setStrategy(strategy: FilterStrategy): void;
    /** @hidden */
    setStrategiesByColumnKey(columnKey?: string): void;
    /** @hidden */
    setColumnKey(columnKey: string): void;
    /** @hidden */
    setDataTypeByColumnKey(columnKey?: string): void;
    /** @hidden */
    setFilterSelectOptionsByColumnKey(columnKey?: string): void;
    /** @hidden */
    private valueExists;
}

declare class FilterRuleComponent implements OnDestroy {
    /** Rule to be displayed **/
    rule: FilterRule;
    /** Emits when rule is changed */
    ruleChange: EventEmitter<void>;
    /** Emits when rule state is changed */
    ruleStateChange: EventEmitter<boolean>;
    /** @hidden */
    readonly 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";
    };
    /** @hidden */
    readonly DATA_TYPE: typeof FilterableColumnDataType;
    /** @hidden */
    readonly strategyLabels: Record<_fundamental_ngx_platform_table_helpers.FilterStrategy, _fundamental_ngx_i18n.FdLanguageKeyIdentifier>;
    /** @hidden */
    set ngForm(ngForm: NgForm);
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    _onModelChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterRuleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterRuleComponent, "fdp-table-filter-rule", never, { "rule": { "alias": "rule"; "required": false; }; }, { "ruleChange": "ruleChange"; "ruleStateChange": "ruleStateChange"; }, never, never, true, never>;
}

declare class P13FilteringDialogComponent implements Resettable {
    dialogRef: DialogRef<FilterDialogData>;
    /** Indicates when reset command is available */
    readonly isResetAvailable$: i0.WritableSignal<boolean>;
    /** Table columns available for filtering */
    readonly columns: FilterableColumn[];
    /**
     * @hidden
     * Include Rules
     */
    _includeRules: FilterRule[];
    /**
     * @hidden
     * Exclude Rules
     */
    _excludeRules: FilterRule[];
    /**
     * @hidden
     * Count of valid included rules
     */
    _validIncludeRulesCount: number;
    /**
     * @hidden
     * Count of valid excluded rules
     */
    _validExcludeRulesCount: number;
    /**
     * @hidden
     * Panel opened/closed flag
     */
    _includePanelExpanded: boolean;
    /**
     * @hidden
     * Panel opened/closed flag
     */
    _excludePanelExpanded: boolean;
    /** @hidden */
    constructor(dialogRef: DialogRef<FilterDialogData>);
    /** Reset changes to the initial state */
    reset(): void;
    /** Close dialog */
    cancel(): void;
    /** Confirm changes and close dialog */
    confirm(): void;
    /** @hidden */
    _removeRule(rule: FilterRule, rules: FilterRule[]): void;
    /** @hidden */
    _addNewRule(rules: FilterRule[]): void;
    /** @hidden */
    _recalculateResetAvailability(): void;
    /** @hidden */
    _onRuleStateChange(): void;
    /** @hidden */
    private _initiateRules;
    /** @hidden */
    private _createRules;
    /** @hidden */
    private _getCollectionFiltersFromRules;
    /** @hidden */
    private _getCollectionFiltersFromIncludeRules;
    /** @hidden */
    private _getCollectionFiltersFromExcludeRules;
    /** @hidden */
    private _calculateValidRulesCount;
    /** @hidden */
    private _isRuleValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<P13FilteringDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<P13FilteringDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

interface GroupDialogColumn {
    label: string;
    key: string;
}
interface GroupDialogData extends TableDialogCommonData {
    collectionGroup: CollectionGroup[];
    columns: GroupDialogColumn[];
}
interface GroupDialogResultData {
    collectionGroup: CollectionGroup[];
}
declare class GroupRule {
    /** Column key the rule belongs to */
    columnKey: string | null;
    /** Show Field as Column */
    showAsColumn: boolean;
    get isValid(): boolean;
    constructor(
    /** Column key the rule belongs to */
    columnKey?: string | null, 
    /** Show Field as Column */
    showAsColumn?: boolean);
}
declare class P13GroupingDialogComponent implements Resettable {
    dialogRef: DialogRef<GroupDialogData>;
    /** Table columns available for grouping */
    readonly columns: GroupDialogColumn[];
    /** Indicates when reset command is available */
    readonly isResetAvailable$: i0.WritableSignal<boolean>;
    /** Group rules to render */
    rules: GroupRule[];
    /** @hidden */
    constructor(dialogRef: DialogRef<GroupDialogData>);
    /** Reset changes to the initial state */
    reset(): void;
    /** Close dialog */
    cancel(): void;
    /** Confirm changes and close dialog */
    confirm(): void;
    /** @hidden */
    _recalculateResetAvailability(): void;
    /** @hidden */
    _removeRule(rule: GroupRule): void;
    /** @hidden */
    _addNew(index: number): void;
    /** @hidden */
    _onRuleColumnKeyChange(rule: GroupRule, columnKey: string): void;
    /** @hidden */
    _onRuleShowAsColumnChange(rule: GroupRule, value: boolean): void;
    /** Get available columns for a rule */
    getAvailableColumns(rule: GroupRule): GroupDialogColumn[];
    /** @hidden */
    private _initiateRules;
    /** @hidden */
    private _createGroupRules;
    /** @hidden */
    private _getCollectionGroupFromGroupRules;
    /** @hidden */
    private _getUniqueRules;
    /** @hidden */
    private _isRuleValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<P13GroupingDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<P13GroupingDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

/**
 * Personalization Dialog Columns Settings.
 *
 */
declare class TableP13ColumnsComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<TableP13ColumnsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableP13ColumnsComponent, "fdp-table-p13-columns", never, {}, {}, never, never, true, never>;
}

/**
 * Personalization Dialog Filter Settings.
 */
declare class TableP13FilterComponent {
    /**
     * Function for handling validation of the filter rules in the table personalization dialog.
     */
    validator: ((rules: CollectionFilter[]) => boolean) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableP13FilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableP13FilterComponent, "fdp-table-p13-filter", never, { "validator": { "alias": "validator"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Personalization Dialog Group Settings.
 *
 */
declare class TableP13GroupComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<TableP13GroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableP13GroupComponent, "fdp-table-p13-group", never, {}, {}, never, never, true, never>;
}

/**
 * Personalization Dialog Sort Settings.
 *
 */
declare class TableP13SortComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<TableP13SortComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableP13SortComponent, "fdp-table-p13-sort", never, {}, {}, never, never, true, never>;
}

/**
 * View settings dialog component.
 *
 * Used to link view settings filters options to the grid table.
 *
 * ```html
 * <fdp-table #myTable></fdp-table>
 * ...
 * <fdp-table-p13-dialog [table]="myTable">
 *   <!-- Sort Panel -->
 *   <fdp-table-p13-sort></fdp-table-p13-sort>
 *
 *   <!-- Filter Panel -->
 *   <fdp-table-p13-filter></fdp-table-p13-filter>
 *
 *   <!-- Group Panel -->
 *   <fdp-table-p13-group></fdp-table-p13-group>
 *
 *   <!-- Columns Panel -->
 *   <fdp-table-p13-columns></fdp-table-p13-columns>
 * </fdp-table-p13-dialog>
 * ```
 * */
declare class TableP13DialogComponent implements OnDestroy {
    private readonly _dialogService;
    /** Reference to table component. */
    set table(table: Table);
    get table(): Table;
    /** Event emitted when dialog is closed. */
    dialogClosed: EventEmitter<string[]>;
    /** @hidden */
    sort: TableP13SortComponent;
    /** @hidden */
    filter: TableP13FilterComponent;
    /** @hidden */
    group: TableP13GroupComponent;
    /** @hidden */
    columns: TableP13ColumnsComponent;
    /** @hidden */
    _table: Table;
    /** @hidden */
    _dialogRef: DialogRef<TableDialogCommonData, any>;
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    private _tableSubscriptions;
    /** @hidden */
    private _columnOrder;
    /** @hidden */
    constructor(_dialogService: DialogService);
    /** @hidden */
    ngOnDestroy(): void;
    /** Open Sort Settings Dialog */
    showSortingSettings(): void;
    /** Open Filtering Settings Dialog */
    showFilteringSettings(): void;
    /** Open Grouping Settings Dialog */
    showGroupingSettings(): void;
    /** Open Columns Settings Dialog */
    showColumnsSettings(): void;
    /** @hidden */
    private _setTable;
    /** @hidden */
    private _subscribeToTable;
    /** @hidden */
    private _listenToTableTriggersToOpenDialogs;
    /** @hidden */
    private _listenToTableColumns;
    /** @hidden */
    private _getTableState;
    /** @hidden */
    private _getTableColumns;
    /** @hidden */
    private _applySorting;
    /** @hidden */
    private _applyFiltering;
    /** @hidden */
    private _applyGrouping;
    /** @hidden */
    private _applyColumns;
    /** @hidden */
    private _unsubscribeFromTable;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableP13DialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableP13DialogComponent, "fdp-table-p13-dialog", never, { "table": { "alias": "table"; "required": false; }; }, { "dialogClosed": "dialogClosed"; }, ["sort", "filter", "group", "columns"], never, true, never>;
}

interface TableToolbarInterface {
    tableToolbarTitleId: string;
    contentTemplateRef: TemplateRef<any>;
}
/** @deprecated Use TableToolbarInterface instead */
type TableToolbarWithTemplate = TableToolbarInterface;
/**
 * Used to provide a table-toolbar to the table component without causing a circular dependency.
 */
declare const TABLE_TOOLBAR: InjectionToken<any>;

/**
 * The component that represents a table toolbar actions.
 * ```html
 * <fdp-table-toolbar-actions>
 *  <fdp-button label="Action One"></fdp-button>
 *  <fdp-button label="Action Two"></fdp-button>
 * </fdp-table-toolbar-actions>
 * ```
 * */
declare class TableToolbarActionsComponent {
    /** @hidden */
    contentTemplateRef: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableToolbarActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableToolbarActionsComponent, "fdp-table-toolbar-actions", never, {}, {}, never, ["*"], true, never>;
}

declare class TableToolbarLeftActionsComponent {
    /** @hidden */
    _contentTemplateRef: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableToolbarLeftActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableToolbarLeftActionsComponent, "fdp-table-toolbar-left-actions", never, {}, {}, never, ["*"], true, never>;
}

interface TableAppliedFilter {
    columnName: string;
    params: string;
}
interface ToolbarContext {
    counter: Signal<number>;
    sortable: Signal<boolean>;
    filterable: Signal<boolean>;
    groupable: Signal<boolean>;
    columns: Signal<boolean>;
    settings: Signal<boolean>;
    hasAnyActions: Signal<boolean>;
    appliedFilters: Signal<TableAppliedFilter[]>;
}
/** Context provided to the titleTemplate. */
interface TableToolbarTitleTemplateContext {
    /** Item count signal. */
    counter: Signal<number>;
}
type EditMode = 'none' | 'inline';
declare class TableToolbarTemplateDirective {
    /** @hidden */
    readonly templateRef: TemplateRef<ToolbarContext>;
    /** @hidden */
    static ngTemplateContextGuard(_directive: TableToolbarTemplateDirective, context: unknown): context is ToolbarContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableToolbarTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableToolbarTemplateDirective, "[fdpTableToolbarTemplate]", never, {}, {}, never, never, true, never>;
}
/**
 * The component that represents a table toolbar.
 *
 * ```html
 * <fdp-table-toolbar
 *   title="Order Line Items"
 *   [hideItemCount]="false">
 * </fdp-table-toolbar>
 * ```
 * */
declare class TableToolbarComponent implements TableToolbarInterface, AfterViewChecked {
    private _tableService;
    private readonly _table;
    /**
     * Whether the toolbar should hide elements in popover when they overflow.
     * */
    shouldOverflow: boolean;
    /** Table title. */
    title: string;
    /** Aria label for the search field. */
    searchFieldAriaLabel: Nullable<string>;
    /** Toggle to show table item count. */
    hideItemCount: boolean;
    /** Toggle to show search input. */
    hideSearchInput: boolean;
    /** Set a customized placeholder */
    searchFieldPlaceholder: string;
    /** Toggle to expand and collapse all feature */
    showExpandCollapseButtons: boolean;
    /** Suggestions for search field. */
    searchSuggestions: SuggestionItem[];
    /** Table rows edit/add mode. */
    editMode: EditMode;
    /** Whether display Refresh button in the search field */
    disableRefresh: boolean;
    /** Whether display search button in the search field */
    disableSearch: boolean;
    /** Toolbar Aria-label attribute. */
    ariaLabel: string;
    /** Toolbar Aria-labelledby attribute. */
    ariaLabelledBy: string;
    /** Toolbar Aria-describedby attribute. */
    ariaDescribedBy: string;
    /** Toolbar Aria-orientation attribute. */
    ariaOrientation: 'horizontal' | 'vertical';
    /**
     * The ID of the toolbar
     * */
    id: string;
    /** Search field input text. */
    set searchFieldInputText(text: string);
    get searchFieldInputText(): string;
    /** Event emitted when the search field input is changed. */
    searchFieldInputChange: EventEmitter<string>;
    /** @hidden */
    tableToolbarActionsComponent: TableToolbarActionsComponent;
    /** @hidden */
    _tableToolbarLeftActionsComponent: TableToolbarLeftActionsComponent;
    /** @hidden */
    contentTemplateRef: TemplateRef<any>;
    /** @hidden */
    tableToolbarTitleId: string;
    /** @hidden */
    _showSaveButton: boolean;
    /** @hidden */
    _searchInputText: string;
    /**
     * Custom title template. When provided, it replaces the default string title.
     * The template context provides a `counter` signal with the current item count.
     *
     * ```html
     * <fdp-table-toolbar [titleTemplate]="customTitleTpl">
     *   <ng-template #customTitleTpl let-counter="counter">
     *     <fd-icon glyph="product"></fd-icon> Products ({{ counter() }})
     *   </ng-template>
     * </fdp-table-toolbar>
     * ```
     */
    titleTemplate: i0.InputSignal<TemplateRef<TableToolbarTitleTemplateContext> | null>;
    /**
     * Heading level of the table toolbar title.
     */
    headingLevel: i0.InputSignal<HeadingLevel>;
    /** @hidden */
    readonly headingLevelParsed: Signal<number>;
    /** @hidden */
    readonly tableLoading$: Observable<boolean>;
    /** @hidden Title text extracted from titleTemplate for accessibility. */
    protected readonly titleText: i0.WritableSignal<string>;
    /** @hidden */
    private _titleObserver;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    constructor(_tableService: TableService, _table: Table);
    /** @hidden */
    ngAfterViewChecked(): void;
    /** @hidden */
    submitSearch(search: SearchInput): void;
    /** @hidden */
    searchInputChanged(event: SearchInput): void;
    /** @hidden */
    openSorting(): void;
    /** @hidden */
    openFiltering(): void;
    /** @hidden */
    openGrouping(): void;
    /** @hidden */
    openColumns(): void;
    /** @hidden */
    _addRow(): void;
    /** @hidden */
    _saveRows(): void;
    /** @hidden */
    _cancelEditing(): void;
    /** @hidden */
    _expandAll(): void;
    /** @hidden */
    _formatAppliedFilters(appliedFilters: {
        columnName: string;
        params: string;
    }[]): string;
    /** @hidden */
    _closeFilterToolbar(): void;
    /** @hidden */
    _collapseAll(): void;
    /** @hidden */
    private _listenToTableEvents;
    /** @hidden Sets up a MutationObserver to watch for title content changes. */
    private _setupTitleObserver;
    /** @hidden Updates the title text from the rendered title element. */
    private _updateTitleText;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableToolbarComponent, "fdp-table-toolbar", never, { "shouldOverflow": { "alias": "shouldOverflow"; "required": false; }; "title": { "alias": "title"; "required": false; }; "searchFieldAriaLabel": { "alias": "searchFieldAriaLabel"; "required": false; }; "hideItemCount": { "alias": "hideItemCount"; "required": false; }; "hideSearchInput": { "alias": "hideSearchInput"; "required": false; }; "searchFieldPlaceholder": { "alias": "searchFieldPlaceholder"; "required": false; }; "showExpandCollapseButtons": { "alias": "showExpandCollapseButtons"; "required": false; }; "searchSuggestions": { "alias": "searchSuggestions"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "disableRefresh": { "alias": "disableRefresh"; "required": false; }; "disableSearch": { "alias": "disableSearch"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; }; "ariaOrientation": { "alias": "ariaOrientation"; "required": false; }; "id": { "alias": "id"; "required": false; }; "searchFieldInputText": { "alias": "searchFieldInputText"; "required": false; }; "titleTemplate": { "alias": "titleTemplate"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, { "searchFieldInputChange": "searchFieldInputChange"; }, ["tableToolbarActionsComponent", "_tableToolbarLeftActionsComponent"], never, true, never>;
}

declare const NOT_FILTERED_OPTION_VALUE: string;

/**
 * View settings dialog filter component.
 *
 * ```html
 * <!-- With custom form -->
 * <fdp-table-view-settings-filter
 *     column="name"
 *     label="Name"
 *     type="custom">
 *         <ng-container *fdpViewSettingsFilterCustomDef="let model">
 *             <label>Enter name:</label>
 *             <fdp-input type="text" name="name" [(ngModel)]="model.name"></fdp-input>
 *         </ng-container>
 * </fdp-table-view-settings-filter>
 *
 * <!-- Single select -->
 * <fdp-table-view-settings-filter
 *     column="status"
 *     label="Status"
 *     type="single-select"
 *     values="[{value: 'OUT_OF_STOCK', label: 'Out of stock'}, { value: 'AVAILABLE', label: 'Available'}]">
 * </fdp-table-view-settings-filter>
 * ```
 *
 * */
declare class TableViewSettingsFilterComponent {
    /** Table column name on which to filter. */
    column: string;
    /** Label for the column. */
    label: string;
    /**
     * Type of filter interface.
     * @type {'single-select' | 'multi-select' | 'custom' 'category'}
     */
    type: FilterType;
    /** Selection values for 'single-select' or 'multi-select' filter types. */
    values: TableFilterSelectOption[];
    /** Custom filter template directive reference */
    customFilterTemplate: TemplateRef<any>;
    /** @hidden */
    set _filterCustomDef(filterCustomDef: FdpViewSettingsFilterCustomDef);
    static ɵfac: i0.ɵɵFactoryDeclaration<TableViewSettingsFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableViewSettingsFilterComponent, "fdp-table-view-settings-filter", never, { "column": { "alias": "column"; "required": false; }; "label": { "alias": "label"; "required": false; }; "type": { "alias": "type"; "required": false; }; "values": { "alias": "values"; "required": false; }; }, {}, ["_filterCustomDef"], never, true, never>;
}

/**
 * Custom Select filter type.
 *
 * Used to render user's custom filter template
 *
 */
declare class FilterCustomComponent {
    private contentDensityObserver;
    /** ViewSettingsFilter options the filter is created from */
    filter: TableViewSettingsFilterComponent;
    /** The filter model */
    set filterBy(filterBy: CollectionFilter | undefined);
    /** Filter model change event */
    valueChange: EventEmitter<unknown>;
    /** Content Density, comes from table injector */
    get contentDensity(): ContentDensityMode;
    /**
     * @hidden
     * Currently selected value
     */
    _value: Record<string, any>;
    /**
     * @hidden
     * Last emitted value
     */
    _valueLastEmitted: Record<string, any>;
    /** @hidden */
    private readonly _cdr;
    /** @hidden */
    constructor(contentDensityObserver: ContentDensityObserver);
    /** @hidden */
    _checkValueChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterCustomComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterCustomComponent, "fdp-filter-custom", never, { "filter": { "alias": "filter"; "required": false; }; "filterBy": { "alias": "filterBy"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

/**
 * Multi Select filter type.
 *
 */
type SelectableOption = TableFilterSelectOption & {
    selected: boolean;
};
declare class FilterMultiSelectComponent {
    /** Selectable filter options */
    options: TableFilterSelectOption[];
    /** The filter model */
    set filterBy(filterBy: CollectionFilter | undefined);
    /** Filter model change event */
    valueChange: EventEmitter<any[]>;
    /**
     * @hidden
     * Currently selected values
     */
    _value: any[];
    /** @hidden */
    _selectableOptions: SelectableOption[];
    /** @hidden */
    _onSelectChange(option: SelectableOption, selected: boolean): void;
    /** @hidden */
    _updateValueBasedOnOptions(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterMultiSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterMultiSelectComponent, "fdp-filter-multi-select", never, { "options": { "alias": "options"; "required": false; }; "filterBy": { "alias": "filterBy"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

/**
 * Single Select filter type.
 *
 */
declare class FilterSingleSelectComponent {
    /** Selectable filter options */
    options: TableFilterSelectOption[];
    /** The filter model */
    set filterBy(filterBy: CollectionFilter | undefined);
    /** Filter model change event */
    valueChange: EventEmitter<any[]>;
    /** @hidden */
    readonly NOT_FILTERED_OPTION_VALUE: string;
    /**
     * @hidden
     * Currently selected value
     */
    _value: any;
    /** @hidden */
    _onValueChange(value: unknown): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSingleSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterSingleSelectComponent, "fdp-filter-single-select", never, { "options": { "alias": "options"; "required": false; }; "filterBy": { "alias": "filterBy"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

interface FiltersViewStep {
    titleTemplateRef: TemplateRef<any>;
    bodyTemplateRef: TemplateRef<any>;
}
declare const FILTERS_VIEW_STEP_TOKEN: InjectionToken<FiltersViewStep>;

/**
 * Filter dialog step.
 *
 * Used to render selected filter options.
 *
 */
declare class FilterStepComponent implements FiltersViewStep {
    /** ViewSettingsFilter options the filter is created from */
    filter: TableViewSettingsFilterComponent;
    /** Column key to apply this filter to */
    columnKey: string;
    /** Table's content density to be used */
    contentDensity: ContentDensity;
    /** The current filter model */
    set filterBy(filterByList: CollectionFilter[]);
    /** Column name to display in the filter */
    columnName: string;
    /** Heading level of the dialog. */
    headingLevel: number;
    /** Go back event */
    back: EventEmitter<void>;
    /** Filter model change event */
    valueChange: EventEmitter<CollectionFilter>;
    /** Template ref to the filter title */
    titleTemplateRef: TemplateRef<any>;
    /** Template ref to the filter body */
    bodyTemplateRef: TemplateRef<any>;
    /** @hidden */
    readonly FILTER_TYPE: typeof FilterType;
    /** @hidden */
    _filterBy?: CollectionFilter;
    /** @hidden */
    _onFilterValueChange(filterValue: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterStepComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterStepComponent, "fdp-filter-step", never, { "filter": { "alias": "filter"; "required": false; }; "columnKey": { "alias": "columnKey"; "required": false; }; "contentDensity": { "alias": "contentDensity"; "required": false; }; "filterBy": { "alias": "filterBy"; "required": false; }; "columnName": { "alias": "columnName"; "required": false; }; "headingLevel": { "alias": "headingLevel"; "required": false; }; }, { "back": "back"; "valueChange": "valueChange"; }, never, never, true, never>;
}

/**
 * Filters list dialog step.
 *
 * Used to render available filters to drill down.
 *
 */
interface SelectableFilter {
    label: string;
}
declare class FiltersListStepComponent implements FiltersViewStep {
    /** Selectable filters list */
    filters: SelectableFilter[];
    /** Heading level of the dialog. */
    headingLevel: number;
    /** Select event is fired once some filter is selected */
    selectFilter: EventEmitter<SelectableFilter>;
    /** Template ref to the filter title */
    titleTemplateRef: TemplateRef<any>;
    /** Template ref to the filter body */
    bodyTemplateRef: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FiltersListStepComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FiltersListStepComponent, "fdp-filters-list-step", never, { "filters": { "alias": "filters"; "required": false; }; "headingLevel": { "alias": "headingLevel"; "required": false; }; }, { "selectFilter": "selectFilter"; }, never, never, true, never>;
}

interface SettingsSortDialogColumn {
    label: string;
    key: string;
}
interface SettingsSortDialogData extends TableDialogCommonData {
    direction: SortDirection;
    field: string | null;
    columns: SettingsSortDialogColumn[];
    allowDisablingSorting: boolean;
}
interface SettingsSortDialogResultData {
    field: string | null;
    direction: SortDirection;
}
interface SettingsGroupDialogColumn {
    label: string;
    key: string;
}
interface SettingsGroupDialogData extends TableDialogCommonData {
    direction: SortDirection;
    field: string | null;
    columns: SettingsGroupDialogColumn[];
}
interface SettingsGroupDialogResultData {
    field: string | null;
    direction: SortDirection;
}
interface FiltersDialogData extends TableDialogCommonData {
    filterBy: CollectionFilter[];
    columns: TableColumn[];
    viewSettingsFilters: TableViewSettingsFilterComponent[];
}
interface FiltersDialogResultData {
    filterBy: CollectionFilter[];
}
declare enum ACTIVE_STEP {
    SELECT_FILTER = "SELECT_FILTER",
    FILTER = "FILTER"
}

declare class FiltersComponent implements AfterViewInit, OnInit {
    private readonly _cd;
    /** Data for the filtering dialog */
    set filteringData(value: FiltersDialogData);
    /** @hidden Heading level */
    headingLevel: i0.InputSignal<number>;
    /** Initial set of filters applied */
    initialFilters: i0.InputSignal<CollectionFilter[]>;
    /** Emits when the active filter step view changes */
    activeFilterStepViewChange: i0.OutputEmitterRef<FiltersViewStep>;
    /** Emits the final result of filter changes */
    filterChange: i0.OutputEmitterRef<FiltersDialogResultData>;
    /** Emits whether the reset button should be enabled */
    resetAvailabilityChange: i0.OutputEmitterRef<boolean>;
    /** Signal to hold currently applied filter rules */
    filterBy: i0.WritableSignal<CollectionFilter[]>;
    /** Signal for table columns, used to retrieve the column key */
    columns: i0.WritableSignal<TableColumn[]>;
    /** Signal for declared filter options */
    viewSettingsFilters: i0.WritableSignal<TableViewSettingsFilterComponent[]>;
    /** Signal to track the currently selected filter step */
    activeStep: i0.WritableSignal<ACTIVE_STEP>;
    /** Signal to track the currently selected filter */
    activeFilter: i0.WritableSignal<Nullable<TableViewSettingsFilterComponent>>;
    /** Signal to track the column key associated with the active filter */
    activeFilterColumnKey: i0.WritableSignal<Nullable<string>>;
    /** Signal for the currently active filter step view */
    activeFilterStepView: i0.WritableSignal<Nullable<FiltersViewStep>>;
    /** Reference to the available steps */
    readonly ACTIVE_STEP: typeof ACTIVE_STEP;
    /** hidden */
    constructor(_cd: ChangeDetectorRef);
    /** hidden */
    ngOnInit(): void;
    /** hidden */
    ngAfterViewInit(): void;
    /** Setter for the active filter step view to trigger updates */
    set setActiveFilterStepView(view: FiltersViewStep);
    /**
     * Select a filter to drill down and update the active filter step.
     * @param filter The filter to be selected and applied.
     */
    selectFilter(filter: SelectableFilter): void;
    /** Navigate back to the top-level filters list */
    goToFilters(): void;
    /**
     * Apply changes to the selected filter and emit the filter change event.
     * @param filter The filter to apply
     * @param filterComponent The component for the filter (provides type info)
     */
    applyFilter(filter: CollectionFilter, filterComponent: Nullable<TableViewSettingsFilterComponent>): void;
    /**
     * Private method to initialize filter data on component initialization.
     * Extracts the initial filter values and table column data.
     */
    private _initializeFilterData;
    /**
     * Private method to compare the current selected filters against the initial state.
     * Enables or disables the reset button based on filter state comparison.
     */
    private _compareSelectedFilters;
    static ɵfac: i0.ɵɵFactoryDeclaration<FiltersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FiltersComponent, "fdp-filters", never, { "filteringData": { "alias": "filteringData"; "required": false; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "initialFilters": { "alias": "initialFilters"; "required": false; "isSignal": true; }; }, { "activeFilterStepViewChange": "activeFilterStepViewChange"; "filterChange": "filterChange"; "resetAvailabilityChange": "resetAvailabilityChange"; }, never, never, true, never>;
}

declare class GroupingComponent implements OnInit {
    /** Input data for grouping */
    groupingData: i0.InputSignal<SettingsGroupDialogData | undefined>;
    /** @hidden Initial grouping settings */
    initialGrouping: i0.InputSignal<Nullable<SettingsGroupDialogResultData>>;
    /** @hidden Heading level */
    headingLevel: i0.InputSignal<number>;
    /** Event emitter for group changes */
    groupChange: i0.OutputEmitterRef<SettingsGroupDialogResultData>;
    /** Event emitter for reset availability changes */
    resetAvailabilityChange: i0.OutputEmitterRef<boolean>;
    /** Current selected grouping direction */
    direction: i0.WritableSignal<SortDirection>;
    /** Current selected grouping field */
    field: i0.WritableSignal<string | null>;
    /** Table columns available for grouping */
    columns: i0.WritableSignal<SettingsGroupDialogColumn[]>;
    /** @hidden */
    groupOrderHeaderId: string;
    /** @hidden */
    groupByHeaderId: string;
    /** Constants for grouping directions */
    readonly SORT_DIRECTION: typeof SortDirection;
    /** Constant for 'Not grouped' option */
    readonly NOT_GROUPED_OPTION_VALUE: null;
    /** hidden */
    ngOnInit(): void;
    /**
     * Handle changes to grouping direction.
     * @param direction New grouping direction.
     */
    _groupOrderChange(direction: SortDirection): void;
    /**
     * Handle changes to the grouping field.
     * @param field New grouping field.
     */
    _groupFieldChange(field: string): void;
    /**
     * Initialize grouping data and signals.
     * @param groupingData Input grouping data.
     * @hidden
     */
    private _initGroupingData;
    /**
     * Compare current grouping state with the initial state, emit events for group and reset availability changes.
     * @hidden
     */
    private _onModelChange;
    /**
     * Compare the initial grouping state with the current state and emit reset availability change if needed.
     * @hidden
     */
    private _compareInitialGrouping;
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GroupingComponent, "fdp-grouping", never, { "groupingData": { "alias": "groupingData"; "required": false; "isSignal": true; }; "initialGrouping": { "alias": "initialGrouping"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, { "groupChange": "groupChange"; "resetAvailabilityChange": "resetAvailabilityChange"; }, never, never, true, never>;
}

declare class SortingComponent implements OnInit {
    /** Input data for sorting */
    sortingData: i0.InputSignal<SettingsSortDialogData | undefined>;
    /** @hidden Heading level */
    headingLevel: i0.InputSignal<number>;
    /** @hidden Initial sorting state */
    initialSorting: i0.InputSignal<Nullable<CollectionSort>>;
    /** Event emitter for sort changes */
    sortChange: i0.OutputEmitterRef<SettingsSortDialogResultData>;
    /** Event emitter for reset availability changes */
    resetAvailabilityChange: i0.OutputEmitterRef<boolean>;
    /** Current selected sorting direction */
    direction: i0.WritableSignal<SortDirection>;
    /** Current selected sorting field */
    field: i0.WritableSignal<string | null>;
    /** Whether disabling sorting is allowed */
    allowDisablingSorting: i0.WritableSignal<boolean>;
    /** Available table columns for sorting */
    columns: i0.WritableSignal<SettingsSortDialogColumn[]>;
    /** @hidden */
    sortOrderHeaderId: string;
    /** @hidden */
    sortDialogSortByHeaderId: string;
    /** @hidden Constants for sort direction */
    readonly SORT_DIRECTION: typeof SortDirection;
    /** @hidden Constant for 'Not sorted' option value */
    readonly NOT_SORTED_OPTION_VALUE: null;
    /** hidden */
    ngOnInit(): void;
    /**
     * Handle sort direction changes.
     * @param direction New sorting direction.
     */
    _sortDirectionChange(direction: SortDirection): void;
    /**
     * Handle sort field changes.
     * @param field New sorting field.
     */
    _sortFieldChange(field: string): void;
    /**
     * Initialize sorting data and signals.
     * @param sortingData Input sorting data.
     * @hidden
     */
    private _initSortingData;
    /**
     * Emit changes to the model and compare with initial sorting.
     * @hidden
     */
    private _onModelChange;
    /**
     * Compare the current sorting state with the initial state.
     * Emit reset availability if the sorting has changed.
     * @hidden
     */
    private _compareInitialSorting;
    static ɵfac: i0.ɵɵFactoryDeclaration<SortingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SortingComponent, "fdp-sorting", never, { "sortingData": { "alias": "sortingData"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "initialSorting": { "alias": "initialSorting"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "resetAvailabilityChange": "resetAvailabilityChange"; }, never, never, true, never>;
}

declare const dialogConfig: DialogConfig;
interface CombinedTableDialogData {
    sortingData: SettingsSortDialogData | null;
    filteringData: FiltersDialogData | null;
    groupingData: SettingsGroupDialogData | null;
}
/**
 * View settings dialog component.
 *
 * Used to link view settings filters options to the grid table.
 *
 * ```html
 * <fdp-table #myTable></fdp-table>
 * ...
 * <fdp-table-view-settings-dialog [table]="myTable">
 *     <fdp-table-view-settings-filter
 *         column="status"
 *         label="Status"
 *         type="single-select"
 *         values="[{value: 'filterValue', label: 'Filter label'}]">
 *     </fdp-table-view-settings-filter>
 * </fdp-table-view-settings-dialog>
 * ```
 * */
declare class TableViewSettingsDialogComponent implements AfterViewInit {
    private readonly _dialogService;
    /** Reference to table component. */
    set table(table: Table);
    get table(): Table;
    /** Whether to allow selecting '(Not sorted)' option in sorting dialog. */
    allowDisablingSorting: boolean;
    /** Heading level of the dialog. */
    headingLevel: 1 | 2 | 3 | 4 | 5 | 6;
    /** @hidden */
    filters: QueryList<TableViewSettingsFilterComponent>;
    /** @hidden */
    _table: Table;
    /** @hidden */
    _dialogRef: DialogRef<TableDialogCommonData | CombinedTableDialogData, any>;
    private readonly destroyRef;
    /** @hidden */
    constructor(_dialogService: DialogService);
    /** @hidden */
    ngAfterViewInit(): void;
    /** Open Sort Settings Dialog */
    showViewSettingsDialog(): void;
    /** @hidden */
    private _listenToFilters;
    /** @hidden */
    private _setTable;
    /** @hidden */
    private _subscribeToTable;
    /** @hidden */
    private _getTableState;
    /** @hidden */
    private _getTableColumns;
    /** @hidden */
    private _applySorting;
    /** @hidden */
    private _applyFiltering;
    /** @hidden */
    private _applyGrouping;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableViewSettingsDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableViewSettingsDialogComponent, "fdp-table-view-settings-dialog", never, { "table": { "alias": "table"; "required": false; }; "allowDisablingSorting": { "alias": "allowDisablingSorting"; "required": false; }; "headingLevel": { "alias": "headingLevel"; "required": false; }; }, {}, ["filters"], never, true, never>;
}

declare class TableHeaderRowComponent extends TableRowDirective implements OnInit {
    /** Table ID. */
    rowId: string;
    /**
     * Whether to fix the table header and footer. Default is true.
     * Note that if the table contains freezable columns, the header and
     * footer will be fixed automatically, regardless of this input value.
     * */
    fixed: boolean;
    /**
     * Whether to show selection column.
     */
    isShownSelectionColumn: boolean;
    /**
     * Row checked state.
     */
    checkedState: boolean | null;
    /**
     * Selection mode.
     */
    selectionMode: SelectionModeValue;
    /**
     * Selection column width.
     */
    selectionColumnWidth: number;
    /** The column `name` to freeze columns up to and including. */
    freezeColumnsTo: string;
    /** Table without horizontal borders. */
    noHorizontalBorders: boolean;
    /** Table without vertical borders. */
    noVerticalBorders: boolean;
    /** Table without borders. */
    noBorders: boolean;
    /** The column `name` to freeze columns after and including. */
    freezeEndColumnsTo: string;
    /** @hidden */
    disableSelectionCheckbox: boolean;
    /** @hidden */
    private set _focusableCellItems(value);
    /** @hidden */
    readonly SELECTION_MODE: typeof SelectionMode;
    /** @hidden */
    readonly SORT_DIRECTION: typeof SortDirection;
    /** @hidden */
    readonly _tableColumnResizeService: TableColumnResizeService;
    /** @hidden */
    readonly _fdpTableService: TableService;
    /** @hidden */
    readonly _contentDensityObserver: ContentDensityObserver;
    /** @hidden */
    readonly _tableRowService: TableRowService<any>;
    /** @hidden */
    protected readonly isRtl: i0.Signal<boolean>;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    private readonly _cdr;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    _columnTrackBy(index: number, column: TableColumn): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableHeaderRowComponent, "[fdp-table-header-row]", never, { "rowId": { "alias": "rowId"; "required": false; }; "fixed": { "alias": "fixed"; "required": false; }; "isShownSelectionColumn": { "alias": "isShownSelectionColumn"; "required": false; }; "checkedState": { "alias": "checkedState"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selectionColumnWidth": { "alias": "selectionColumnWidth"; "required": false; }; "freezeColumnsTo": { "alias": "freezeColumnsTo"; "required": false; }; "noHorizontalBorders": { "alias": "noHorizontalBorders"; "required": false; }; "noVerticalBorders": { "alias": "noVerticalBorders"; "required": false; }; "noBorders": { "alias": "noBorders"; "required": false; }; "freezeEndColumnsTo": { "alias": "freezeEndColumnsTo"; "required": false; }; "disableSelectionCheckbox": { "alias": "disableSelectionCheckbox"; "required": false; }; }, {}, never, never, true, never>;
}
/** @hidden */
declare class IsColumnHasHeaderMenuPipe implements PipeTransform {
    /** @hidden */
    private readonly _fdpTableService;
    /** @hidden */
    transform(column: TableColumn): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsColumnHasHeaderMenuPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsColumnHasHeaderMenuPipe, "isColumnHasHeaderMenu", true>;
}

/**
 * The component that represents a table.
 * A table is a set of tabular data. Line items can support data, images and actions.
 * ```html
 * <fdp-table
 *  [dataSource]="source"
 *  fdCompact
 *  selectionMode="multiple"
 *  emptyTableMessage="No data found">
 *
 *  <fdp-table-toolbar
 *   title="Order Line Items"
 *   [hideItemCount]="false">
 *  </fdp-table-toolbar>
 *
 *  <fdp-column
 *   name="name"
 *   key="name"
 *   label="Name"
 *   align="start">
 *  </fdp-column>
 *
 *  <fdp-column
 *   name="description"
 *   key="description"
 *   label="Description">
 *  </fdp-column>
 * </fdp-table>
 * ```
 */
declare class TableComponent<T = any> extends Table<T> implements AfterViewInit, OnDestroy, OnChanges, OnInit, AfterViewChecked {
    private readonly _ngZone;
    private readonly _cdr;
    readonly _tableService: TableService;
    private readonly _tableScrollDispatcher;
    readonly _tableColumnResizeService: TableColumnResizeService;
    readonly contentDensityObserver: ContentDensityObserver;
    readonly injector: Injector;
    private readonly _tabbableService;
    /** Component name used in a Preset-managed component. */
    name: string;
    /** ID for the Table. */
    id: string;
    /** Whether to allow resizing columns by dragging the column edge with mouse. */
    enableDragResize: boolean;
    /**
     * Whether to fix the table header and footer. Default is true.
     * Note that if the table contains freezable columns, the header and
     * footer will be fixed automatically, regardless of this input value.
     * */
    fixed: boolean;
    /** The column `name` to freeze columns up to and including. */
    freezeColumnsTo: string;
    /** The column `name` to freeze columns after and including. */
    freezeEndColumnsTo: string;
    /** Toggle for page scrolling feature. */
    pageScrolling: boolean;
    /** Whether the table should render growing button at the bottom. */
    showGrowingButton: boolean;
    /**
     * Whether to show total items amount in growing button text content.
     */
    showItemsCount: boolean;
    /** Number of items per page. */
    pageSize: Nullable<number>;
    /** Page scrolling threshold in px. */
    pageScrollingThreshold: number;
    /** Table body height. */
    bodyHeight: string;
    /** Text displayed when table has no items. */
    emptyTableMessage: string;
    /** Text displayed when table has no visible columns. */
    noVisibleColumnsMessage: string;
    /** Table without horizontal borders. */
    noHorizontalBorders: boolean;
    /** If the table scrolling should happen outside and stick the toolbar and thead */
    outerScroll: boolean;
    /** Table without vertical borders. */
    set noVerticalBorders(value: boolean);
    get noVerticalBorders(): boolean;
    /** @hidden */
    private _noVerticalBorders;
    /** Table without borders. */
    noBorders: boolean;
    /** Table body without any borders, but header with borders. */
    noBodyBorders: boolean;
    /** Table without outer borders */
    noOuterBorders: boolean;
    /** Table body without horizontal borders. */
    noBorderX: boolean;
    /** Table body without vertical borders. */
    noBorderY: boolean;
    /** Accessor to a children nodes of tree. */
    relationKey: string;
    /** Table row expanded state key. Used to set the initial state of tree row. */
    expandedStateKey: string;
    /** Property key indicating that the row has children accessible via [childDataSource]. */
    hasChildrenKey: string;
    /**
     * Whether row is navigatable.
     * Pass boolean value to set state for the all rows.
     * Pass string value with the key of the row item's field to compute state for every single row.
     */
    rowNavigatable: string | boolean;
    /**
     * Whether to highlight navigated row.
     */
    highlightNavigatedRow: boolean;
    /** Whether table row can be clicked */
    rowsActivable: boolean;
    /** Value with the key of the row item's field to enable selecting.  */
    selectedKey: string;
    /** Value with the key of the row item's field to enable selecting.  */
    selectableKey: string;
    /**
     * Tracking function that will be used to check the differences in data changes.
     * Used similarly to `ngFor` `trackBy` function.
     * Accepts a function that takes two parameters, index and item.
     */
    trackBy: TrackByFunction<T>;
    /**
     * An optional function that identifies uniqueness of a particular row.
     * Table component uses it to be able to preserve selection when a data list is changed.
     */
    rowComparator: RowComparator<T>;
    /** String or function to calculate additional rows' CSS classes. */
    rowsClass: TableRowClass<T>;
    /** Used to construct empty row object for editing. */
    editableRowSkeleton: T;
    /** Whether all rows should be collapsed by default after the table is loaded. */
    expandOnInit: boolean;
    /**
     * 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;
    /** Event emitted when the current preset configuration has been changed. */
    /**
     * Whether to load previous pages.
     * This option works only when `pageScrolling` is true, and the initial page > 1
     */
    loadPagesBefore: boolean;
    /**
     * Whether or not the header cells should be interactive
     * (have hover and active states)
     * default: false
     */
    nonInteractiveHeader: boolean;
    /** @hidden */
    _selectionMode: SelectionModeValue;
    /** @hidden */
    _header: TableHeaderRowComponent;
    /** Sets selection mode for the table. 'single' | 'multiple' | 'none' */
    set selectionMode(value: SelectionModeValue);
    get selectionMode(): SelectionModeValue;
    /** @hidden */
    private _enableTristateMode;
    /**
     *  When True, the checked state of each tree item depends on the checked
     *  state of its parent or direct child.
     */
    set enableTristateMode(value: boolean);
    get enableTristateMode(): boolean;
    /** Value with the key of the row item's field to compute semantic state of the row.  */
    set semanticHighlighting(value: string);
    get semanticHighlighting(): string;
    /**
     * Whether to force rows to follow 'checked all' state of the table.
     * If true, all new rows that are coming from the dataSource will follow 'checked all' state.
     * If false, row will respect `checkedKey` property to define checked state of itself.
     * Default is false.
     */
    forceCheckedAllState: boolean;
    /**
     * aria-labelledby attribute value for the table.
     */
    ariaLabelledBy: string;
    /** The minimum width at which the user can resize a column, in pixels. Default is 50. */
    minimumColumnWidth: number;
    /** Whether to display the table footer. */
    showTableFooter: boolean;
    /**
     * Specifies minimal width of the non-frozen columns.
     * Useful when table has large amount of freezable columns and table still should have some free space available.
     */
    set nonFrozenColumnsMinWidth(value: number);
    get nonFrozenColumnsMinWidth(): number;
    /** @hidden */
    private _nonFrozenColumnsMinWidth;
    /** @hidden */
    private _shouldCheckNewRows;
    /** @hidden */
    private _calculateFrozenColumnRefresh$;
    /** @hidden */
    private _defaultBodyHeight;
    /** Event emitted when current preset configuration has been changed. */
    presetChanged: EventEmitter<Partial<Omit<TableState, "columnKeys">>>;
    /** Event fired when table selection has changed. */
    readonly rowSelectionChange: EventEmitter<TableRowSelectionChangeEvent<T>>;
    /** Event fired when table sort order has changed. */
    readonly sortChange: EventEmitter<TableSortChangeEvent>;
    /** Event fired when the table filter has changed. */
    readonly filterChange: EventEmitter<TableFilterChangeEvent>;
    /** Event fired when table grouping has changed. */
    readonly groupChange: EventEmitter<TableGroupChangeEvent>;
    /** Event fired when visible columns list has been changed. */
    readonly columnsChange: EventEmitter<TableColumnsChangeEvent>;
    /** Event emitted when pagination state has been changed. */
    readonly pageChange: EventEmitter<TablePageChangeEvent>;
    /** Event fired when there is a change in the frozen column. */
    readonly columnFreeze: EventEmitter<TableColumnFreezeEvent>;
    /** Event fired when group/tree row collapsed/expanded. */
    readonly rowToggleOpenState: EventEmitter<TableRowToggleOpenStateEvent<T>>;
    /** Event fired when a cell is clicked or focused. */
    readonly cellActivate: EventEmitter<TableCellActivateEvent<T>>;
    /** Event fired when row navigated. */
    readonly rowActivate: EventEmitter<TableRowActivateEvent<T>>;
    /** Event fired when row navigated. */
    readonly rowNavigate: EventEmitter<TableRowActivateEvent<T>>;
    /** 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>;
    /** Event emitted when table body being scrolled. */
    readonly tableScrolled: EventEmitter<number>;
    /** Event emitted when new rows has been set and rendered. */
    readonly tableRowsSet: EventEmitter<void>;
    /** Event emitted when all rows being expanded. */
    allRowsExpanded: EventEmitter<void>;
    /** Event emitted when all rows being collapsed. */
    allRowsCollapsed: EventEmitter<void>;
    /** Event emitted when a cell is focused. */
    readonly cellFocused: EventEmitter<any>;
    /** @hidden */
    readonly tableScrollable: TableScrollable;
    /** @hidden */
    readonly tableContainer: ElementRef<HTMLDivElement>;
    /** @hidden */
    readonly table: ElementRef<HTMLDivElement>;
    /** @hidden */
    readonly _focusableGrid: FocusableGridDirective;
    /** @hidden */
    private readonly _tableBody;
    /** @hidden */
    private readonly _dndDirective;
    /** @hidden */
    readonly tableScrollMockContainer: ElementRef<HTMLDivElement>;
    /** @hidden */
    readonly tableBody: ElementRef<HTMLElement>;
    /** @hidden */
    readonly columns: QueryList<TableColumn>;
    /** @hidden */
    readonly customEditableCells: QueryList<EditableTableCell>;
    /** @hidden */
    readonly tableToolbar: TableToolbarInterface;
    /** @hidden */
    readonly _noDataWrapper: Nullable<NoDataWrapperComponent>;
    /** Total loaded items. */
    loadedRows$: i0.WritableSignal<number>;
    /** @hidden */
    hoveredRowIndex$: i0.WritableSignal<Nullable<number>>;
    /** @hidden */
    get initialSortBy(): CollectionSort[];
    /**
     * @hidden
     * verify if the bodyheight provided is valid in percentage or pixels
     */
    get isBodyHeightValid(): boolean;
    /**
     * @hidden
     * if the bodyHeight is valid, then set that as value as body height for table
     * else set default body height for table as 100%
     */
    get tableBodyHeight(): string;
    /**
     * @hidden
     * Columns to be rendered in the template
     */
    get _visibleColumns(): TableColumn[];
    /** @hidden */
    get isTreeTable(): boolean;
    /** @hidden */
    get enableRowReordering(): boolean;
    /** Whether the table rows are draggable. */
    get isDraggable(): boolean;
    /** @hidden */
    get _semanticHighlightingColumnWidth(): number;
    /** @hidden Sum of widths of fixed columns (semantic highlighting, selection) */
    get _fixedColumnsPadding(): number;
    /** @hidden */
    get _tableWidthPx(): number;
    /** @hidden */
    get loadingState(): boolean;
    /**
     *  Whether the selection column should be shown,
     *  If there are no visible rows or visible columns
     *  or selection mode is none, then selection column should not be shown.
     **/
    get isSelectionColumnShown(): boolean;
    /** @hidden */
    get _ariaLabelledBy(): string | null;
    /**
     * @hidden
     * Representation of combined table rows.
     * Contains all rows including group rows.
     */
    _tableRows: TableRow<T>[];
    /**
     * @hidden
     * Representation of table rows that came from dataSource.
     * Contains all rows including group rows.
     */
    _dataSourceTableRows: TableRow<T>[];
    /**
     * @hidden
     * Representation of added table rows.
     */
    _newTableRows: TableRow<T>[];
    /**
     * @hidden
     * Visible table rows.
     * Rows list that is used to be rendered in the ui.
     * Based on _tableRows and excludes hidden rows.
     */
    _tableRowsVisible: TableRow<T>[];
    /**
     * @hidden
     * Table Column Map. Where key is column key and value is column
     */
    _keyToColumnMap: Map<string, TableColumn>;
    /**
     * @hidden
     * Freezable column names and their respective indexes
     */
    _freezableColumns: Map<string, number>;
    /**
     * @hidden
     * Freezable column names and their respective indexes for columns that will be frozen to the end of the table
     */
    _freezableEndColumns: Map<string, number>;
    /** @hidden */
    _tableColumnsLength: number;
    /** @hidden */
    readonly loadingRowRange: number[];
    /** @hidden */
    get loadingColumnsRange(): number[];
    /** @hidden */
    _checkedState: boolean | null;
    /** @hidden */
    _isGroupTable$: i0.Signal<boolean>;
    /**
     * @hidden
     * Used to create a row component placeholder and set data in it rather than re-create the row component when data changes.
     * Optimizes performance due to skipping initial setup of the component.
     */
    _tableCurrentlyRenderedRowsPlaceholder: number[];
    /** @hidden */
    _dndTableRowsPlaceholder: TableRow[];
    /** @hidden */
    _isSelectionColumnShown: boolean;
    /** @hidden */
    readonly _toolbarContext: ToolbarContext;
    /** @hidden */
    _navigatedRowIndex: number;
    /** @hidden */
    _selectionColumnWidth: number;
    /** @hidden */
    readonly tableColumnsStream: Observable<TableColumn[]>;
    /** @hidden */
    _loadPreviousPages: boolean;
    /** @hidden */
    readonly _dataSourceDirective: TableDataSourceDirective<T>;
    /** @hidden */
    readonly _tableRowService: TableRowService<any>;
    /** @hidden */
    readonly initialState: TableInitialState | null;
    /** @hidden */
    readonly _virtualScrollDirective: TableVirtualScroll | null;
    /** @hidden */
    readonly _dndTableDirective: TableDraggable<any> | null;
    /** Loading state */
    loading: boolean | undefined;
    /** @hidden */
    private _semanticHighlightingKey;
    /** @hidden */
    private _forceSemanticHighlighting;
    /** @hidden */
    private readonly _isShownSortSettingsInToolbar$;
    /** @hidden */
    private readonly _isShownFilterSettingsInToolbar$;
    /** @hidden */
    private readonly _isShownGroupSettingsInToolbar$;
    /** @hidden */
    private _appliedFilterNames;
    /** @hidden */
    private readonly _isShownColumnSettingsInToolbar$;
    /** @hidden */
    private readonly _isShownSettingsInToolbar$;
    /**
     * @hidden
     * Indicates when all items are checked
     */
    private _checkedAll;
    /**
     * @hidden
     * Indicates whether at least 1 item is checked
     */
    private _checkedAny;
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    private _viewInitiated;
    /** @hidden */
    private _addedItems;
    /** @hidden */
    private _columnsWidthSet;
    /** @hidden */
    private _dndLoadingState;
    /** @hidden */
    private readonly _rangeSelector;
    /** @hidden */
    private _currentPreset;
    /** @hidden */
    private _initialStateSet;
    /** @hidden */
    private _rowHeightManuallySet;
    /** @hidden */
    private _shouldEmitRowsChange;
    /** @hidden */
    private _lastFreezableColumnCalculation;
    /** @hidden */
    private readonly _tableHeaderResizer;
    /**
     * @hidden
     * Mapping function for the trackBy, provided by the user.
     * Is needed, because we are wrapping user supplied data into a `TableRow` class.
     */
    _rowTrackBy: TrackByFunction<number>;
    /** @hidden */
    private readonly _defaultTrackBy;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    constructor(_ngZone: NgZone, _cdr: ChangeDetectorRef, _tableService: TableService, _tableScrollDispatcher: TableScrollDispatcherService, _tableColumnResizeService: TableColumnResizeService, contentDensityObserver: ContentDensityObserver, injector: Injector, _tabbableService: TabbableElementService);
    /** Returns array of rows that are currently rendered in the table body. */
    getCurrentlyRenderedRows(): number[];
    /**
     * Sets an array of rows that are currently rendered in the table body.
     * @param startIndex Start index of all rows.
     * @param length Length of rows.
     */
    setCurrentlyRenderedRows(startIndex: number | undefined, length: number): void;
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngAfterViewChecked(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Get current state/settings of the Table. */
    getTableState(): TableState;
    /** Set current state/settings of the Table. */
    setTableState(state: TableState | PlatformTableManagedPreset): void;
    /** Get table columns definition list. */
    getTableColumns(): TableColumn[];
    /** Get a list of visible table columns. */
    getVisibleTableColumns(): TableColumn[];
    /** Set Sorting rules */
    sort(sortRules: CollectionSort[]): void;
    /** Add Sorting rules to the existing ones */
    addSort(sortRules: CollectionSort[]): void;
    /** Set Filter rules */
    filter(filterRules: CollectionFilter[]): void;
    /** Add Filter rule */
    addFilter(filterRules: CollectionFilter[]): void;
    /** Removes filters for the provided fields */
    removeFilter(fields: string[]): void;
    /** Set Groups */
    group(groups: CollectionGroup[]): void;
    /** Add Groups */
    addGroup(groups: CollectionGroup[]): void;
    /**
     * Set visible table columns
     * The order is matter
     * @param columns table columns names
     */
    setColumns(columns: string[]): void;
    /** Freeze table to column */
    freezeToColumn(columnName: string, end?: boolean): void;
    /** Unfreeze column */
    unfreeze(columnName: string, end?: boolean): void;
    /** expand all rows */
    expandAll(): void;
    /** collapse all rows */
    collapseAll(): void;
    /** Search in table */
    search(searchInput: SearchInput): void;
    /** Set current page number in table */
    setCurrentPage(currentPage: number): void;
    /** Set items per page number in table  */
    setPageSize(pageSize: number, resetPageNumber?: boolean): void;
    /** Toolbar Sort Settings button visibility */
    showSortSettingsInToolbar(showSortSettings: boolean): void;
    /** Toolbar Filter Settings button visibility */
    showFilterSettingsInToolbar(showFilterSettings: boolean): void;
    /** Toolbar Group Settings button visibility */
    showGroupSettingsInToolbar(showGroupSettings: boolean): void;
    /** Toolbar Columns Settings button visibility */
    showColumnSettingsInToolbar(showColumnSettings: boolean): void;
    /** Toolbar Settings button visibility */
    showSettingsInToolbar(showSettings: boolean): void;
    /** Disable filter from column heder menu */
    setHeaderColumnFilteringDisabled(disabled: boolean): void;
    /** Set the row navigation */
    setRowNavigation(rowIndex: number, rowNavigatable: string | boolean): void;
    /**
     * Toggle row checked state.
     * @param rowIndex Index of the row.
     */
    toggleSelectableRow(rowIndex: number): void;
    /**
     * Sets the checked state of the row.
     * @param rowIndex Index of the row.
     * @param value Value of the checked state.
     */
    setRowCheckedState(rowIndex: number, value: boolean): void;
    /** Remove the row navigation */
    removeRowNavigation(rowIndex: number): void;
    /** Manually triggers column's width recalculation */
    recalculateTableColumnWidth(): void;
    /** Gets the max allowed width for all freezable columns */
    getMaxAllowedFreezableColumnsWidth(): number;
    /** Get table data source */
    getDataSource(): TableDataSource<T>;
    /**
     * Adds empty row for editing at the beginning of the rows array.
     */
    addRow(): void;
    /** Cancels editing and discards newly added rows */
    cancelEditing(): void;
    /**
     * Emits save event and resets editable rows array.
     */
    saveRows(): void;
    /** @deprecated use 'setTableState' instead. Sets current preset for the Table. */
    setPreset(data: PlatformTableManagedPreset): void;
    /** Returns current preset configuration. */
    getCurrentPreset(): PlatformTableManagedPreset;
    /**
     * Manually triggers list item event listeners for drag&drop list directive.
     */
    refreshDndList(): void;
    /** @hidden */
    _onDragStarted(row: TableRow, dndIndex: number, globalIndex: number): void;
    /**
     * Programmatically toggles `expand` state of the row with defined index.
     * @param rowIndexes row indexes including nested rows.
     *
     * Usage example:
     * * To toggle first level row, pass one argument:
     * ```
     * table.toggleGroupRows(0) // Will result in toggling first row if it's type is `TableRowType.TREE` or `TableRowType.GROUP`.
     * ```
     * * To toggle nested rows, pass additional arguments of indexes:
     * ```
     * table.toggleGroupRows(0, 1) // Will result in toggling first root row, then it's second child.
     * ```
     */
    toggleGroupRows(...rowIndexes: number[]): void;
    /**
     * Function used to focus a cell in the table utilizing a FocusableCellPosition interface.
     */
    focusCell(position: FocusableCellPosition): void;
    /**
     * Clears the array of table rows. Triggered when new data source is applied.
     */
    clearTableRows(): void;
    /** @hidden */
    _scrollToOverlappedCell(): void;
    /** @hidden */
    _calculatingLoading(isLoading: boolean): void;
    /**
     * @hidden
     * Toggle selectable row in SelectionMode.MULTIPLE
     */
    _toggleMultiSelectRow(rowToToggle: TableRow, event?: Event): void;
    /**
     * @hidden
     * Toggle selectable row in SelectionMode.SINGLE
     */
    _toggleSingleSelectableRow(rowToToggle: TableRow): void;
    /**
     * @hidden
     * Select / Unselect all selectable rows
     */
    _toggleAllSelectableRows(selectAll: boolean): void;
    /**
     * @hidden
     * Create table row selection event
     */
    _emitRowSelectionChangeEvent(added: TableRow[], removed: TableRow[], all?: boolean): void;
    /** @hidden */
    _onCellClick(colIdx: number, row: TableRow<T>): void;
    /** @hidden */
    _onRowClick(row: TableRow<T> | null, event: Event): void;
    /** @hidden */
    _emitCellActivate(columnIndex: number, row: TableRow<T>): void;
    /** @hidden */
    _emitRowActivate(row: TableRow<T>, ctrlKey: boolean): void;
    /**
     * @hidden
     * Expand/Collapse group row
     */
    _toggleGroupRow(groupRow: TableRow<T>): void;
    /** @hidden */
    _emitRowNavigate(row: TableRow<T>, ctrlKey: boolean): void;
    /** Fetch data source data. */
    fetch(): void;
    /** @hidden */
    onTableRowsChanged(): void;
    /** @hidden */
    toggleExpandableTableRow(rowToToggle: TableRow, forceFetch?: boolean): void;
    /** @hidden */
    _onSpyIntersect(intersected: boolean): void;
    /**
     * After rows are rendered, the IntersectionObserver on the spy row may not
     * emit a new event if the spy was already visible before the data changed.
     * This method waits for the DOM to settle, then checks whether the spy row
     * is actually inside the scroll container's viewport and, if so, triggers
     * the next page load.
     *
     * @hidden
     */
    private _recheckSpyIntersection;
    /** @hidden */
    handleMouseEnter(rowIndex: number): void;
    /** @hidden */
    handleMouseLeave(): void;
    /** Manually update index after we add new items to the main array */
    private _reIndexTableRows;
    /** @hidden */
    private _isValidInteger;
    /** @hidden */
    private _markAsExpanded;
    /** @hidden */
    private _listenToTableRowsPipe;
    /** @hidden */
    private _listenToTableStateChanges;
    /** @hidden */
    private _setAppliedFilterNames;
    private _formatParams;
    /** @hidden */
    private _formatColumnName;
    /** @hidden */
    private _listenToTableRowStateChange;
    /** @hidden */
    private _createTableRowsByDataSourceItems;
    /** @hidden */
    private _createTreeTableRowsByDataSourceItems;
    /** @hidden */
    private _setTableRows;
    /** @hidden */
    private _calculateVisibleTableRows;
    /** @hidden */
    private _listenToRowHeightChange;
    /** @hidden */
    private _listenToColumns;
    /**
     * Construct visible columns for rendering purpose.
     */
    private _calculateVisibleColumns;
    /** @hidden */
    private _calculateTableColumnsLength;
    /** @hidden */
    private _calculateIsShownNavigationColumn;
    /** @hidden */
    private _setFreezableInfo;
    /** @hidden */
    private _buildColumnsMap;
    /** @hidden */
    private _calculateCheckedAll;
    /**
     * Propagates tristate selection mode to the tree. It starts with updating a state for all the parents and then
     * to children
     *
     * @hidden
     */
    private _applyTristateSelection;
    /** @hidden */
    private _applySelectionToParents;
    /** @hidden */
    private _applySelectionToChildren;
    /** @hidden */
    private _listenToPageScrolling;
    /** @hidden */
    private _listenToColumnPropertiesChange;
    /** @hidden */
    private _listenToTableWidthChanges;
    /** @hidden */
    private _listenToTableContainerMouseLeave;
    /** @hidden */
    private _initScrollPosition;
    /**
     * @hidden
     * Resets editable rows discarding the editable rows array.
     */
    private _resetEditState;
    /** @hidden */
    private _listenToLoadingAndRefocusCell;
    /** @hidden */
    private _onZoneFree;
    /** @hidden */
    private _setSemanticHighlighting;
    /** @hidden */
    private _setSelectionColumnWidth;
    /** @hidden */
    private _checkCellMock;
    /**
     * @hidden
     * Listens to fixed column width subject and calculates last applicable frozen column based on `nonFrozenColumnsMinWidth` vaue.
     */
    private _listenToFixedColumnsWidth;
    private _calculateLastFreezableColumn;
    /** @hidden */
    private _setMockScrollbarPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "fdp-table", never, { "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "enableDragResize": { "alias": "enableDragResize"; "required": false; }; "fixed": { "alias": "fixed"; "required": false; }; "freezeColumnsTo": { "alias": "freezeColumnsTo"; "required": false; }; "freezeEndColumnsTo": { "alias": "freezeEndColumnsTo"; "required": false; }; "pageScrolling": { "alias": "pageScrolling"; "required": false; }; "showGrowingButton": { "alias": "showGrowingButton"; "required": false; }; "showItemsCount": { "alias": "showItemsCount"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageScrollingThreshold": { "alias": "pageScrollingThreshold"; "required": false; }; "bodyHeight": { "alias": "bodyHeight"; "required": false; }; "emptyTableMessage": { "alias": "emptyTableMessage"; "required": false; }; "noVisibleColumnsMessage": { "alias": "noVisibleColumnsMessage"; "required": false; }; "noHorizontalBorders": { "alias": "noHorizontalBorders"; "required": false; }; "outerScroll": { "alias": "outerScroll"; "required": false; }; "noVerticalBorders": { "alias": "noVerticalBorders"; "required": false; }; "noBorders": { "alias": "noBorders"; "required": false; }; "noBodyBorders": { "alias": "noBodyBorders"; "required": false; }; "noOuterBorders": { "alias": "noOuterBorders"; "required": false; }; "noBorderX": { "alias": "noBorderX"; "required": false; }; "noBorderY": { "alias": "noBorderY"; "required": false; }; "relationKey": { "alias": "relationKey"; "required": false; }; "expandedStateKey": { "alias": "expandedStateKey"; "required": false; }; "hasChildrenKey": { "alias": "hasChildrenKey"; "required": false; }; "rowNavigatable": { "alias": "rowNavigatable"; "required": false; }; "highlightNavigatedRow": { "alias": "highlightNavigatedRow"; "required": false; }; "rowsActivable": { "alias": "rowsActivable"; "required": false; }; "selectedKey": { "alias": "selectedKey"; "required": false; }; "selectableKey": { "alias": "selectableKey"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "rowComparator": { "alias": "rowComparator"; "required": false; }; "rowsClass": { "alias": "rowsClass"; "required": false; }; "editableRowSkeleton": { "alias": "editableRowSkeleton"; "required": false; }; "expandOnInit": { "alias": "expandOnInit"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "secondaryRowHeight": { "alias": "secondaryRowHeight"; "required": false; }; "loadPagesBefore": { "alias": "loadPagesBefore"; "required": false; }; "nonInteractiveHeader": { "alias": "nonInteractiveHeader"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "enableTristateMode": { "alias": "enableTristateMode"; "required": false; }; "semanticHighlighting": { "alias": "semanticHighlighting"; "required": false; }; "forceCheckedAllState": { "alias": "forceCheckedAllState"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "minimumColumnWidth": { "alias": "minimumColumnWidth"; "required": false; }; "showTableFooter": { "alias": "showTableFooter"; "required": false; }; "nonFrozenColumnsMinWidth": { "alias": "nonFrozenColumnsMinWidth"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, { "presetChanged": "presetChanged"; "rowSelectionChange": "rowSelectionChange"; "sortChange": "sortChange"; "filterChange": "filterChange"; "groupChange": "groupChange"; "columnsChange": "columnsChange"; "pageChange": "pageChange"; "columnFreeze": "columnFreeze"; "rowToggleOpenState": "rowToggleOpenState"; "cellActivate": "cellActivate"; "rowActivate": "rowActivate"; "rowNavigate": "rowNavigate"; "emptyRowAdded": "emptyRowAdded"; "save": "save"; "cancel": "cancel"; "tableScrolled": "tableScrolled"; "tableRowsSet": "tableRowsSet"; "allRowsExpanded": "allRowsExpanded"; "allRowsCollapsed": "allRowsCollapsed"; "cellFocused": "cellFocused"; }, ["tableToolbar", "_noDataWrapper", "columns", "customEditableCells"], ["fdp-table-no-data-wrapper"], true, [{ directive: typeof _fundamental_ngx_platform_table_helpers.TableDataSourceDirective; inputs: { "dataSource": "dataSource"; "childDataSource": "childDataSource"; }; outputs: { "childDataSourceChanged": "childDataSourceChanged"; "onDataRequested": "onDataRequested"; "onDataReceived": "onDataReceived"; "dataSourceChanged": "dataSourceChanged"; "dataChanged": "dataChanged"; "isLoading": "isLoading"; }; }, { directive: typeof _fundamental_ngx_platform_table_helpers.TableHeaderResizerDirective; inputs: {}; outputs: {}; }]>;
    static ngAcceptInputType_outerScroll: unknown;
    static ngAcceptInputType_showTableFooter: unknown;
}

interface SortDialogColumn {
    label: string;
    key: string;
}
interface SortDialogData extends TableDialogCommonData {
    collectionSort: CollectionSort[];
    columns: SortDialogColumn[];
}
interface SortDialogResultData {
    collectionSort: CollectionSort[];
}
interface SortRule {
    columnKey: string | null;
    direction: SortDirection;
}
declare class ValidatedSortRule implements SortRule {
    /** Column key the rule belongs to */
    columnKey: string | null;
    /** Sort direction */
    direction: SortDirection;
    get isValid(): boolean;
    constructor(
    /** Column key the rule belongs to */
    columnKey?: string | null, 
    /** Sort direction */
    direction?: SortDirection);
}
declare class P13SortingDialogComponent implements Resettable {
    dialogRef: DialogRef<SortDialogData>;
    private cdr;
    /** Table columns available for sorting */
    readonly columns: SortDialogColumn[];
    /** Indicates when reset command is available */
    readonly isResetAvailable$: i0.WritableSignal<boolean>;
    /** @hidden */
    readonly SORT_DIRECTION: typeof SortDirection;
    /** Sort rules to render */
    rules: ValidatedSortRule[];
    /** @hidden */
    constructor(dialogRef: DialogRef<SortDialogData>, cdr: ChangeDetectorRef);
    /** Reset changes to the initial state */
    reset(): void;
    /** Close dialog */
    cancel(): void;
    /** Confirm changes and close dialog */
    confirm(): void;
    /** @hidden */
    _removeRule(rule: ValidatedSortRule): void;
    /** @hidden */
    _addNew(index: number): void;
    /** @hidden */
    _onRuleColumnKeyChange(rule: ValidatedSortRule, columnKey: string): void;
    /** @hidden */
    _onRuleDirectionChange(rule: ValidatedSortRule, direction: SortDirection): void;
    /** @hidden */
    _recalculateResetAvailability(): void;
    /** @hidden */
    _trackByColumnKey(index: number, rule: ValidatedSortRule): string | null;
    /** @hidden */
    private _initiateRules;
    /** @hidden */
    private _createRules;
    /** @hidden */
    private _getCollectionSortFromSortRules;
    /** @hidden */
    private _getUniqueRules;
    /** @hidden */
    private _isRuleValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<P13SortingDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<P13SortingDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
}
declare class GetAvailableSortColumnsPipe implements PipeTransform {
    /** @hidden */
    transform(columns: SortDialogColumn[], rules: SortRule[], currentKey: string | null): SortDialogColumn[];
    static ɵfac: i0.ɵɵFactoryDeclaration<GetAvailableSortColumnsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GetAvailableSortColumnsPipe, "getAvailableSortColumns", true>;
}

declare class TableEditableCellComponent implements EditableTableCell {
    /** Table row definition. */
    row: TableRow;
    /** Table cell definition. */
    column: TableColumn;
    /** Column value. */
    set columnValue(value: any);
    get columnValue(): any;
    /** Editable cell form. */
    form: NgForm;
    /** @hidden */
    _controlUniqName: string;
    /** @hidden */
    private _columnValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableEditableCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableEditableCellComponent, "fdp-table-editable-cell", never, { "row": { "alias": "row"; "required": false; }; "column": { "alias": "column"; "required": false; }; "columnValue": { "alias": "columnValue"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TableRowComponent<T> extends TableRowDirective implements OnInit, AfterViewInit, OnDestroy, OnChanges {
    /** Row ID. */
    rowId: string;
    /** Table Row. */
    row: TableRow<T>;
    /** Row index. */
    index: number;
    /** Selection mode. */
    selectionMode: SelectionModeValue;
    /** Selectable flag key. */
    selectableKey: string;
    /** Whether to enable checkbox tristate mode. */
    enableTristateMode: boolean;
    /**
     * Whether to fix the table header and footer. Default is true.
     * Note that if the table contains freezable columns, the header and
     * footer will be fixed automatically, regardless of this input value.
     * */
    fixed: boolean;
    /** Selection column width. */
    selectionColumnWidth: number;
    /** The column `name` to freeze columns up to and including. */
    freezeColumnsTo: string;
    /** The column `name` to freeze columns after and including. */
    freezeEndColumnsTo: string;
    /**
     * Event emitted when keyboard drag performed.
     */
    keyboardDrag: EventEmitter<TableRowKeyboardDrag>;
    /** @hidden */
    private set _focusableViewCellItems(value);
    /** @hidden */
    private readonly _editableCells;
    /** @hidden */
    protected get _ariaSelected(): boolean;
    /** @hidden */
    _hasRowHeaderColumn$: i0.Signal<boolean>;
    /** @hidden */
    _rowSelectionHelperTextId: string;
    /** @hidden */
    readonly _announceEmptyCell: i0.WritableSignal<boolean>;
    /** @hidden */
    readonly _isTreeRowFirstCell: typeof isTreeRowFirstCell;
    /** @hidden */
    readonly SELECTION_MODE: typeof SelectionMode;
    /** @hidden */
    readonly _contentDensityObserver: ContentDensityObserver;
    /** @hidden */
    readonly _tableColumnResizeService: TableColumnResizeService;
    /** @hidden */
    readonly _fdpTableService: TableService;
    /** @hidden */
    readonly _tableRowService: TableRowService<any>;
    /** @hidden */
    readonly _isTreeRow: typeof isTreeRow;
    /** @hidden */
    protected readonly isRtl: i0.Signal<boolean>;
    /** @hidden */
    protected readonly navigationIcon: i0.Signal<"slim-arrow-left" | "slim-arrow-right">;
    /** @hidden */
    protected readonly _destroyRef: DestroyRef;
    /** @hidden */
    private readonly _refreshChildRows$;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    private readonly _cdr;
    /** @hidden */
    private readonly _zone;
    /** @hidden */
    private readonly _elmRef;
    /** @hidden */
    private readonly _dndTableDirective;
    /** @hidden */
    constructor();
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    _toggleGroupRow(): void;
    /** @hidden */
    _toggleSingleSelectableRow(event?: Event): void;
    /** @hidden */
    _toggleMultiSelectRow(row: TableRow<T>, event?: Event): void;
    /** @hidden */
    _columnTrackBy(index: number, column: TableColumn): string;
    /** @hidden */
    _itemFocusedEventAnnouncer: (position: FocusableItemPosition) => string;
    /** @hidden */
    _handleCellFocused(event: FocusableItemPosition, index: number, row: TableRow<T>, column: TableColumn, tableTextContainer: HTMLElement): void;
    /** @hidden */
    protected _handleCellSpaceKey(colIdx: number, tableCellElement: HTMLTableCellElement, $event: Event): void;
    /** @hidden */
    private _listenToRowExpansion;
    /** @hidden */
    private _onKeyDown;
    /** @hidden */
    private _setAnnounceEmptyCell;
    /** @hidden Checks if container has elements with explicit accessible names (aria-label, aria-labelledby) */
    private _hasAccessibleContent;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableRowComponent<any>, "[fdp-table-row]", never, { "rowId": { "alias": "rowId"; "required": false; }; "row": { "alias": "row"; "required": false; }; "index": { "alias": "index"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selectableKey": { "alias": "selectableKey"; "required": false; }; "enableTristateMode": { "alias": "enableTristateMode"; "required": false; }; "fixed": { "alias": "fixed"; "required": false; }; "selectionColumnWidth": { "alias": "selectionColumnWidth"; "required": false; }; "freezeColumnsTo": { "alias": "freezeColumnsTo"; "required": false; }; "freezeEndColumnsTo": { "alias": "freezeEndColumnsTo"; "required": false; }; }, { "keyboardDrag": "keyboardDrag"; }, never, ["*"], true, never>;
}

declare class TableGroupRowComponent<T> extends TableRowDirective implements OnChanges {
    /** Table ID. */
    rowId: string;
    /** Row index. */
    index: number;
    /** Row height. */
    height: number;
    /** Whether the row is draggable. */
    draggable: boolean;
    /** Table Row. */
    row: TableRow<T>;
    /** Key to column mapping. */
    keyToColumnMap: Map<string, TableColumn>;
    /** Event emitted when group row expansion state needs to be toggled. */
    toggleGroupRow: EventEmitter<TableRow<T>>;
    /** @hidden */
    _column: Nullable<TableColumn>;
    /** @hidden */
    private set _focusableViewCellItems(value);
    /** @hidden */
    readonly _fdpTableService: TableService;
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableGroupRowComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableGroupRowComponent<any>, "[fdp-table-group-row]", never, { "rowId": { "alias": "rowId"; "required": false; }; "index": { "alias": "index"; "required": false; }; "height": { "alias": "height"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "row": { "alias": "row"; "required": false; }; "keyToColumnMap": { "alias": "keyToColumnMap"; "required": false; }; }, { "toggleGroupRow": "toggleGroupRow"; }, never, never, true, never>;
}

declare class TablePoppingRowComponent<T> extends TableRowDirective {
    /** Table Row. */
    row: TableRow<T>;
    /** Whether the row is selected. */
    checked: boolean | null;
    /** Current selection mode. */
    selectionMode: SelectionModeValue;
    /** Event emitted when group row expansion state needs to be toggled. */
    toggleGroupRow: EventEmitter<TableRow<T>>;
    /** Event emitted when cell being clicked on. */
    cellClicked: EventEmitter<{
        index: number;
        row: TableRow<T>;
    }>;
    /** @hidden */
    private set _focusableCellItems(value);
    /** @hidden */
    readonly SELECTION_MODE: typeof SelectionMode;
    /** @hidden */
    readonly _isTreeRow: typeof isTreeRow;
    /** @hidden */
    readonly _isTreeRowFirstCell: typeof isTreeRowFirstCell;
    /** @hidden */
    readonly _fdpTableService: TableService;
    /** Set items programmatically. */
    setItems(items: ReadonlyArray<FocusableItem>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TablePoppingRowComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TablePoppingRowComponent<any>, "[fdp-table-popping-row]", never, { "row": { "alias": "row"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; }, { "toggleGroupRow": "toggleGroupRow"; "cellClicked": "cellClicked"; }, never, never, true, never>;
}

declare class TableGrowingButtonComponent {
    /** Whether to show items count. */
    showItemsCount: boolean;
    /** @hidden */
    readonly _tableService: TableService;
    /** @hidden */
    readonly _dataSourceDirective: TableDataSourceDirective<any>;
    /** @hidden */
    readonly _table: Table<any>;
    /** @hidden */
    _loadMore(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableGrowingButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableGrowingButtonComponent, "fdp-table-growing-button", never, { "showItemsCount": { "alias": "showItemsCount"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TableFooterRowComponent extends TableRowDirective {
    /** @hidden */
    readonly _fdpTableService: TableService;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableFooterRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableFooterRowComponent, "[fdp-table-footer-row]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformTableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformTableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformTableModule, never, [typeof TableComponent, typeof TableColumnComponent, typeof TableToolbarComponent, typeof TableToolbarActionsComponent, typeof TableViewSettingsDialogComponent, typeof TableViewSettingsFilterComponent, typeof SortingComponent, typeof GroupingComponent, typeof FiltersComponent, typeof FiltersListStepComponent, typeof FilterStepComponent, typeof FilterSingleSelectComponent, typeof FilterMultiSelectComponent, typeof FilterCustomComponent, typeof ResetButtonComponent, typeof TableP13DialogComponent, typeof TableP13SortComponent, typeof TableP13FilterComponent, typeof TableP13GroupComponent, typeof TableP13ColumnsComponent, typeof P13SortingDialogComponent, typeof P13GroupingDialogComponent, typeof P13FilteringDialogComponent, typeof FilterRuleComponent, typeof P13ColumnsDialogComponent, typeof PlatformTableColumnResizerComponent, typeof NoDataWrapperComponent, typeof GetAvailableSortColumnsPipe, typeof TableEditableCellComponent, typeof TableToolbarLeftActionsComponent, typeof TableHeaderCellContentComponent, typeof TableCellHeaderPopoverComponent, typeof TableRowComponent, typeof TableGroupRowComponent, typeof TablePoppingRowComponent, typeof TableHeaderRowComponent, typeof IsColumnHasHeaderMenuPipe, typeof TableGrowingButtonComponent, typeof TableFooterRowComponent, typeof _fundamental_ngx_platform_table_helpers.TableHelpersModule], [typeof TableComponent, typeof TableColumnComponent, typeof TableToolbarComponent, typeof TableToolbarActionsComponent, typeof TableViewSettingsDialogComponent, typeof TableViewSettingsFilterComponent, typeof SortingComponent, typeof GroupingComponent, typeof FiltersComponent, typeof FiltersListStepComponent, typeof FilterStepComponent, typeof FilterSingleSelectComponent, typeof FilterMultiSelectComponent, typeof FilterCustomComponent, typeof ResetButtonComponent, typeof TableP13DialogComponent, typeof TableP13SortComponent, typeof TableP13FilterComponent, typeof TableP13GroupComponent, typeof TableP13ColumnsComponent, typeof P13SortingDialogComponent, typeof P13GroupingDialogComponent, typeof P13FilteringDialogComponent, typeof FilterRuleComponent, typeof P13ColumnsDialogComponent, typeof PlatformTableColumnResizerComponent, typeof NoDataWrapperComponent, typeof GetAvailableSortColumnsPipe, typeof TableEditableCellComponent, typeof TableToolbarLeftActionsComponent, typeof TableHeaderCellContentComponent, typeof TableCellHeaderPopoverComponent, typeof TableRowComponent, typeof TableGroupRowComponent, typeof TablePoppingRowComponent, typeof TableHeaderRowComponent, typeof IsColumnHasHeaderMenuPipe, typeof TableGrowingButtonComponent, typeof TableFooterRowComponent, typeof _fundamental_ngx_platform_table_helpers.TableHelpersModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformTableModule>;
}

export { FILTERS_VIEW_STEP_TOKEN, FilterCustomComponent, FilterMultiSelectComponent, FilterRule, FilterRuleComponent, FilterSingleSelectComponent, FilterStepComponent, FiltersComponent, FiltersListStepComponent, GetAvailableSortColumnsPipe, GroupingComponent, IsColumnHasHeaderMenuPipe, NOT_FILTERED_OPTION_VALUE, NoDataWrapperComponent, P13ColumnsDialogComponent, P13FilteringDialogComponent, P13GroupingDialogComponent, P13SortingDialogComponent, PlatformTableColumnResizerComponent, PlatformTableModule, RESETTABLE_TOKEN, ResetButtonComponent, SortingComponent, TABLE_TOOLBAR, TableCellHeaderPopoverComponent, TableColumnComponent, TableComponent, TableEditableCellComponent, TableFooterRowComponent, TableGroupRowComponent, TableGrowingButtonComponent, TableHeaderCellContentComponent, TableHeaderRowComponent, TableP13ColumnsComponent, TableP13DialogComponent, TableP13FilterComponent, TableP13GroupComponent, TableP13SortComponent, TablePoppingRowComponent, TableRowComponent, TableToolbarActionsComponent, TableToolbarComponent, TableToolbarLeftActionsComponent, TableToolbarTemplateDirective, TableViewSettingsDialogComponent, TableViewSettingsFilterComponent, dialogConfig };
export type { ColumnsDialogData, ColumnsDialogResultData, CombinedTableDialogData, DialogTableColumn, EditMode, FilterDialogData, FilterDialogResultData, FilterableColumn, FiltersViewStep, GroupDialogColumn, GroupDialogData, GroupDialogResultData, Resettable, SelectableFilter, SortDialogColumn, SortDialogData, SortDialogResultData, SortRule, TableAppliedFilter, TableToolbarInterface, TableToolbarTitleTemplateContext, TableToolbarWithTemplate, ToolbarContext, VisibleColumnType };