import * as i0 from '@angular/core';
import { AfterContentInit, QueryList, OnDestroy, ElementRef, OnChanges, OnInit, AfterViewInit, DestroyRef, NgZone } from '@angular/core';
import * as i1 from '@fundamental-ngx/cdk/utils';
import { FocusableItemDirective, ResizeObserverService, CssClassBuilder, FocusableListDirective, Nullable } from '@fundamental-ngx/cdk/utils';
import { CheckboxComponent } from '@fundamental-ngx/core/checkbox';
import { IconFont } from '@fundamental-ngx/core/icon';
import { ContentDensityObserver, ContentDensityMode } from '@fundamental-ngx/core/content-density';

declare class TableBodyDirective {
    /** @hidden */
    fdTableBodyClass: boolean;
    /**  Whether to show the table body's horizontal borders */
    noBorderX: boolean;
    /**  Whether to show the table body's vertical borders */
    noBorderY: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableBodyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableBodyDirective, "[fdTableBody], [fd-table-body]", never, { "noBorderX": { "alias": "noBorderX"; "required": false; }; "noBorderY": { "alias": "noBorderY"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TableCellDirective extends FocusableItemDirective implements AfterContentInit {
    /** Whether to show the table cell's horizontal borders */
    noBorderX: boolean;
    /** Whether to show the table cell's vertical borders */
    noBorderY: boolean;
    /** Whether the table cell is activable */
    activable: boolean;
    /** @hidden */
    set focusable(value: boolean);
    get focusable(): boolean;
    /** Whether the table cell is hoverable */
    hoverable: boolean;
    /** Whether the table cell's width should fit to content  */
    fitContent: boolean;
    /** Whether the table cell shouldn't have padding on sides */
    noPadding: boolean;
    /** Whether the table cell indicates that there is no data */
    noData: boolean;
    /** Whether the table cell inside table header should be non-interactive */
    nonInteractive: boolean;
    /** Key of a cell element, it's used to identify this cell with certain column */
    key: string;
    /** @hidden */
    _checkboxes: QueryList<CheckboxComponent>;
    /** @hidden */
    _fdTableCellClass: boolean;
    /** @hidden */
    private _parentPreviousTabIndex;
    /** @hidden */
    constructor();
    /** @hidden */
    protected _focusIn(): void;
    /** @hidden */
    protected _focusOut(): void;
    /** @hidden */
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellDirective, "[fdTableCell], [fd-table-cell]", never, { "noBorderX": { "alias": "noBorderX"; "required": false; }; "noBorderY": { "alias": "noBorderY"; "required": false; }; "activable": { "alias": "activable"; "required": false; }; "focusable": { "alias": "focusable"; "required": false; }; "hoverable": { "alias": "hoverable"; "required": false; }; "fitContent": { "alias": "fitContent"; "required": false; }; "noPadding": { "alias": "noPadding"; "required": false; }; "noData": { "alias": "noData"; "required": false; }; "nonInteractive": { "alias": "nonInteractive"; "required": false; }; "key": { "alias": "key"; "required": false; }; }, {}, ["_checkboxes"], never, true, never>;
    static ngAcceptInputType_focusable: unknown;
}

declare class TableContainerDirective implements OnDestroy {
    /** Whether the scroll is applied on the page and not on the table */
    outerScroll: boolean;
    /** @hidden */
    set toolbar(toolbarElRef: ElementRef);
    /** @hidden */
    set tableHeader(tableHeaderEl: ElementRef);
    /** @hidden */
    readonly resizeObserverService: ResizeObserverService;
    /** @hidden */
    private readonly _renderer;
    /** @hidden */
    private _tableHeaderEl;
    /** @hidden */
    private _resizeSubscription;
    /** @hidden */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableContainerDirective, "[fdTableContainer], [fd-table-container]", never, { "outerScroll": { "alias": "outerScroll"; "required": false; }; }, {}, ["toolbar", "tableHeader"], never, true, never>;
    static ngAcceptInputType_outerScroll: unknown;
}

declare class TableFixedDirective {
    /** @hidden */
    fdTableFixedClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableFixedDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFixedDirective, "[fdTableFixed], [fd-table-fixed]", never, {}, {}, never, never, true, never>;
}

declare class TableFooterDirective {
    /** @hidden */
    fdTableFooterClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableFooterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFooterDirective, "[fdTableFooter], [fd-table-footer]", never, {}, {}, never, never, true, never>;
}

declare class TableHeaderDirective {
    /** @hidden */
    fdTableHeaderClass: boolean;
    /** Whether or not to show the table header's horizontal borders */
    noBorderX: boolean;
    /** Whether or not to show the table header's vertical borders */
    noBorderY: boolean;
    /**
     * Whether or not the header cells should be interactive
     * (have hover and active states)
     * default: false
     */
    nonInteractive: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableHeaderDirective, "[fdTableHeader], [fd-table-header]", never, { "noBorderX": { "alias": "noBorderX"; "required": false; }; "noBorderY": { "alias": "noBorderY"; "required": false; }; "nonInteractive": { "alias": "nonInteractive"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TableIconDirective implements OnChanges, CssClassBuilder, OnInit {
    /** @hidden */
    fdTableIconClass: boolean;
    /** The property allows user to pass additional css classes
     */
    class: string;
    /** The icon to include in the button. See the icon page for the list of icons.
     * Setter is used to control when css class have to be rebuilded.
     * Default value is set to ''.
     */
    glyph: string;
    /** Glyph font family */
    glyphFont: IconFont;
    /** Whether or no icon is used as navigation  */
    navigation: boolean;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /**
     * @hidden
     * CssClassBuilder interface implementation
     * function must return single string
     * function is responsible for order which css classes are applied
     */
    buildComponentCssClass(): string[];
    /** Function runs when component is initialized
     * function should build component css class
     * function should build css style
     */
    ngOnChanges(): void;
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableIconDirective, "[fdTableIcon], [fd-table-icon]", never, { "class": { "alias": "class"; "required": false; }; "glyph": { "alias": "glyph"; "required": false; }; "glyphFont": { "alias": "glyphFont"; "required": false; }; "navigation": { "alias": "navigation"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TableInnerDirective {
    /** @hidden */
    fdTableInnerClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableInnerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableInnerDirective, "[fdTableInner], [fd-table-inner]", never, {}, {}, never, never, true, never>;
}

declare class TablePopoverDirective {
    /** @hidden */
    fdTablePopoverClass: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TablePopoverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TablePopoverDirective, "[fdTablePopover], [fd-table-popover]", never, {}, {}, never, never, true, never>;
}

/**
 * The directive that represents a table.
 * A table is a set of tabular data. Line items can support data, images and actions.
 * ```html
 *     <div fd-table-responsive-wrapper>
 *         <table fd-table>
 *         </table>
 *     </div>
 * ```
 */
declare class TableResponsiveWrapperDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TableResponsiveWrapperDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableResponsiveWrapperDirective, "[fd-table-responsive-wrapper]", never, {}, {}, never, never, true, never>;
}

declare const HIDDEN_CLASS_NAME = "fd-table--hidden";
declare class TableRowDirective extends FocusableListDirective implements AfterViewInit, OnInit {
    /** @hidden */
    cells: QueryList<TableCellDirective>;
    /** @hidden */
    fdTableRowClass: boolean;
    /** Whether the table row is activable */
    activable: boolean;
    /** Whether the table row is hoverable */
    /** Whether to highlight active row when clicked. */
    highlightActive: boolean;
    /**  Whether the table row is hoverable */
    hoverable: boolean;
    /** Whether the table row is focusable */
    set focusable(value: boolean);
    get focusable(): boolean;
    /** Whether the table row is main row, it's concerned only on pop in mode */
    main: boolean;
    /** Whether the table row is secondary row, it's concerned only on pop in mode */
    secondary: boolean;
    /** Whether the table row is active. */
    active: boolean;
    /** @hidden */
    elementRef: ElementRef<HTMLTableRowElement>;
    /** @hidden */
    private readonly _changeDetRef;
    /** @hidden */
    private _tableService;
    /** @hidden */
    constructor();
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    private _resetCells;
    /** @hidden */
    private _sortMethod;
    /** @hidden */
    private _sortNativeElements;
    /** @hidden */
    private _changeVisibility;
    /** @hidden */
    private _hideElement;
    /** @hidden */
    private _setupCellsSubscription;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableRowDirective, "[fdTableRow], [fd-table-row]", never, { "activable": { "alias": "activable"; "required": false; }; "highlightActive": { "alias": "highlightActive"; "required": false; }; "hoverable": { "alias": "hoverable"; "required": false; }; "focusable": { "alias": "focusable"; "required": false; }; "main": { "alias": "main"; "required": false; }; "secondary": { "alias": "secondary"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, ["cells"], never, true, never>;
    static ngAcceptInputType_focusable: unknown;
}

type TableStatuses = 'valid' | 'warning' | 'information' | 'error';
declare class TableStatusIndicatorDirective {
    /** The type of indicator. Options are 'valid', 'warning', 'information' and 'error'. */
    status: Nullable<TableStatuses>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableStatusIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableStatusIndicatorDirective, "[fdTableStatusIndicator], [fd-table-status-indicator]", never, { "status": { "alias": "status"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TableTextDirective {
    /** Whether the text should have shadow (halo) & overflow should be hidden. */
    fdTableTextClass: boolean;
    /** Whether the text should wrap when the text is too long for 1 line */
    noWrap: boolean;
    /** Whether the text should be bolded and marked as a title */
    title: boolean;
    /** Maximum width of a text element */
    maxWidth: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableTextDirective, "[fdTableText], [fd-table-text]", never, { "fdTableTextClass": { "alias": "fdTableTextClass"; "required": false; }; "noWrap": { "alias": "noWrap"; "required": false; }; "title": { "alias": "title"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * The component that represents a table wrapper, it will add fd-table class to its first child.
 * A table is a set of tabular data. Line items can support data, images and actions.
 * ```html
 * <table-wrapper>
 * <table></table>
 * </table-wrapper>
 * ```
 */
declare class TableWrapperComponent implements AfterContentInit, OnDestroy {
    private elementRef;
    private _contentDensityObserver;
    /** @hidden */
    private _contentDensitySettings;
    /** @hidden */
    constructor(elementRef: ElementRef, _contentDensityObserver: ContentDensityObserver);
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableWrapperComponent, "fd-table-wrapper", never, {}, {}, never, ["*"], true, never>;
}

declare class TableService {
    /** @hidden */
    propagateKeys$: i0.WritableSignal<string[]>;
    /** @hidden */
    changeKeys(keys: string[]): void;
}

declare const FdTableContentDensityProviderParams: {
    supportedContentDensity: ContentDensityMode[];
};
/**
 * The component that represents a table.
 * A table is a set of tabular data. Line items can support data, images and actions.
 * ```html
 * <table fd-table></table>
 * ```
 */
declare class TableComponent implements AfterContentInit, AfterViewInit {
    private readonly _tableService;
    private readonly _contentDensityObserver;
    private readonly _destroyRef;
    private readonly _ngZone;
    /** @hidden */
    fdTableClass: boolean;
    /** Whether or not to show the table's horizontal borders */
    noBorderX: boolean;
    /** Whether or not to show the table's vertical borders */
    noBorderY: boolean;
    /** Whether or not to show the table's outer border */
    noOuterBorder: boolean;
    /** Whether or not to show the table's top border */
    topBorder: boolean;
    /** Whether or not to display the table in pop in mode, it also require change of markup */
    popIn: boolean;
    /** Whether or not to display the table in responsive mode. */
    responsive: boolean;
    /** List of keys that identifies single columns */
    keys: string[];
    /** Applies `focusable` to all cells within this table */
    set allCellsFocusable(value: boolean);
    get allCellsFocusable(): boolean;
    /** @hidden */
    readonly _cells: QueryList<TableCellDirective>;
    /** @hidden */
    private _allCellsFocusable;
    /** @hidden */
    constructor(_tableService: TableService, _contentDensityObserver: ContentDensityObserver, _destroyRef: DestroyRef, _ngZone: NgZone);
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** Method that sorts and changes visible state of particular cells  */
    reset(keys: string[]): void;
    /** @hidden */
    private _propagateKeys;
    /** @hidden */
    private _updateCells;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "table[fd-table]", ["fd-table"], { "noBorderX": { "alias": "noBorderX"; "required": false; }; "noBorderY": { "alias": "noBorderY"; "required": false; }; "noOuterBorder": { "alias": "noOuterBorder"; "required": false; }; "topBorder": { "alias": "topBorder"; "required": false; }; "popIn": { "alias": "popIn"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "keys": { "alias": "keys"; "required": false; }; "allCellsFocusable": { "alias": "allCellsFocusable"; "required": false; }; }, {}, ["_cells"], ["*"], true, [{ directive: typeof i1.FocusableGridDirective; inputs: {}; outputs: {}; }]>;
    static ngAcceptInputType_allCellsFocusable: unknown;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class TableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, never, [typeof TableComponent, typeof TableResponsiveWrapperDirective, typeof TableWrapperComponent, typeof TableHeaderDirective, typeof TableFooterDirective, typeof TableBodyDirective, typeof TableRowDirective, typeof TableCellDirective, typeof TableStatusIndicatorDirective, typeof TablePopoverDirective, typeof TableInnerDirective, typeof TableTextDirective, typeof TableIconDirective, typeof TableFixedDirective, typeof TableContainerDirective], [typeof TableComponent, typeof TableResponsiveWrapperDirective, typeof TableWrapperComponent, typeof TableHeaderDirective, typeof TableFooterDirective, typeof TableBodyDirective, typeof TableRowDirective, typeof TableCellDirective, typeof TableStatusIndicatorDirective, typeof TablePopoverDirective, typeof TableInnerDirective, typeof TableTextDirective, typeof TableIconDirective, typeof TableFixedDirective, typeof TableContainerDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
}

export { FdTableContentDensityProviderParams, HIDDEN_CLASS_NAME, TableBodyDirective, TableCellDirective, TableComponent, TableContainerDirective, TableFixedDirective, TableFooterDirective, TableHeaderDirective, TableIconDirective, TableInnerDirective, TableModule, TablePopoverDirective, TableResponsiveWrapperDirective, TableRowDirective, TableService, TableStatusIndicatorDirective, TableTextDirective, TableWrapperComponent };
export type { TableStatuses };
