import * as i0 from '@angular/core';
import { AfterViewInit, OnDestroy, ElementRef, ChangeDetectorRef, QueryList, OnInit, Renderer2, EventEmitter, Optional } from '@angular/core';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Subject } from 'rxjs';
import { BooleanInput } from '@angular/cdk/coercion';
import { FocusMonitor } from '@angular/cdk/a11y';
import * as i1 from '@angular/common';
import * as i2 from '@aposin/ng-aquila/icon';
import * as i3 from '@aposin/ng-aquila/copytext';
import * as i4 from '@aposin/ng-aquila/swipebar';

interface NxExpandable {
    /** Indicates if this expandable instance is open or not.  */
    expanded: BehaviorSubject<boolean>;
    /** Toggles the open state. */
    toggle(): void;
    /** Expands this component. */
    expand(): void;
    /** Closes this component. */
    close(): void;
}
/**
 * This toggle button can be clicked and toggles expandable elements.
 *
 * E.g. it can toggle a expandable table row or anything else that implements the `NxExpandable` interface.
 */
declare class NxToggleButtonComponent implements AfterViewInit, OnDestroy {
    private readonly _cdr;
    private readonly _focusMonitor;
    _expanded: boolean;
    _buttonElement: ElementRef;
    /**
     * This is the expandable target that will be toggled when the user clicks the button.
     */
    set target(value: NxExpandable);
    _target: NxExpandable;
    set ariaLabel(value: string);
    _ariaLabel: string;
    private _subscription;
    constructor(_cdr: ChangeDetectorRef, _focusMonitor: FocusMonitor);
    ngAfterViewInit(): void;
    _onClick(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxToggleButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxToggleButtonComponent, "nx-toggle-button", never, { "target": { "alias": "target"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * This is an expandable table row.
 * It can collapse its height to hide the content.
 * Requires the table cells to have the `[nxExpandableTableCell]` component.
 */
declare class NxExpandableTableRowComponent implements NxExpandable {
    private readonly _cdr;
    set isExpanded(value: BooleanInput);
    get isExpanded(): BooleanInput;
    private _isExpanded;
    readonly expanded: BehaviorSubject<boolean>;
    constructor(_cdr: ChangeDetectorRef);
    /**
     * Toggles the expansion of this row.
     */
    toggle(): void;
    /**
     * Expands this row.
     */
    expand(): void;
    /**
     * Closes this row.
     */
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxExpandableTableRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxExpandableTableRowComponent, "tr[nxExpandableTableRow]", never, { "isExpanded": { "alias": "isExpanded"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * The nxExpandableTable adds row expansion functionality to the nxTable.
 * It provides the logic to expand/collapse all expandable rows simultanously.
 */
declare class NxExpandableTableDirective implements OnDestroy, AfterViewInit, NxExpandable {
    rows: QueryList<NxExpandableTableRowComponent>;
    readonly expanded: BehaviorSubject<boolean>;
    private readonly _destroyed;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Toggles the expandable rows. If all rows are open it will close them, otherwise it will open them.
     */
    toggle(): void;
    /**
     * Expands all expandable rows.
     */
    expand(): void;
    /**
     * Closes all expandable rows.
     */
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxExpandableTableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxExpandableTableDirective, "table[nxExpandableTable], ng-container[nxExpandableContainer]", ["nxExpandableTable"], {}, {}, ["rows"], never, true, never>;
}

/**
 * This is an expandable table cell.
 * Only works in conjunction with the `[nxExpandableTableRow]` component.
 */
declare class NxExpandableTableCellComponent implements OnDestroy {
    private readonly _cdr;
    _open: boolean;
    private readonly _destroyed;
    constructor(_row: NxExpandableTableRowComponent, _cdr: ChangeDetectorRef);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxExpandableTableCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxExpandableTableCellComponent, "td[nxExpandableTableCell]", never, {}, {}, never, ["*"], true, never>;
}

/**
 * This is a table header cell.
 */
declare class NxHeaderCellDirective {
    readonly elementRef: ElementRef<HTMLElement>;
    constructor(elementRef: ElementRef<HTMLElement>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NxHeaderCellDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxHeaderCellDirective, "[nxHeaderCell]", never, {}, {}, never, never, true, never>;
}

declare class NxHeaderResizeDirective implements OnInit, OnDestroy {
    private readonly documentRef;
    private readonly elementRef;
    private readonly header;
    private renderer;
    private mousedown;
    private touchstart;
    private mousemove;
    private touchmove;
    private mouseup;
    private touchend;
    readonly resizable: rxjs.Observable<number>;
    private readonly _destroyed;
    constructor(documentRef: Document, elementRef: ElementRef<HTMLElement>, header: NxHeaderCellDirective, renderer: Renderer2);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxHeaderResizeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxHeaderResizeDirective, "[nxHeaderResize]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated due to not fulfilling the WCAG accessibility requirements.
 */
declare class NxTableCellClipDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NxTableCellClipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxTableCellClipDirective, "table[nxTableCellClip]", never, {}, {}, never, never, true, never>;
}

type SortDirection = 'asc' | 'desc';
declare class SortEvent {
    /** The name of the column that is being sorted by. */
    readonly active: string;
    /** The sort direction. */
    readonly direction: SortDirection;
    constructor(
    /** The name of the column that is being sorted by. */
    active: string, 
    /** The sort direction. */
    direction: SortDirection);
}
declare class NxSortDirective implements OnDestroy {
    readonly _stateChanges: Subject<void>;
    /** Sets the key of the most recently sorted column. */
    set active(value: string);
    get active(): string;
    private _active;
    /** Sets the direction of the currently active sorted column. Default: 'asc'. */
    set direction(value: SortDirection);
    get direction(): SortDirection;
    private _direction;
    /**
     * An event emitted when the active value has changed.
     * @docs-private
     */
    readonly activeChange: EventEmitter<string>;
    /**
     * An event emitted when the direction value has changed.
     * @docs-private
     */
    readonly directionChange: EventEmitter<SortDirection>;
    /** An event emitted when either the active sort or sort direction changes. */
    readonly sortChange: EventEmitter<SortEvent>;
    ngOnDestroy(): void;
    /**
     * Sets the active sort key and determines the new sort direction.
     * Afterwards the output event `sortChange` is called.
     *
     * If `sortable` is not the key of the active sort header, the initial direction to sort is 'asc'.
     * Otherwise the direction of the sorted column changes.
     */
    sort(sortable: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxSortDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxSortDirective, "table[nxSort]", ["NxSortDirective"], { "active": { "alias": "active"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; }, { "activeChange": "activeChange"; "directionChange": "directionChange"; "sortChange": "sortChange"; }, never, never, true, never>;
}

declare class NxSortHeaderIntl {
    /**
     * Stream that emits whenever the labels here are changed. Use this to notify
     * components if the labels have changed after initialization.
     */
    readonly changes: Subject<void>;
    /** The aria label for a header that can be clicked to sort ascending. */
    sortAscendingAriaLabel: string;
    /** The aria label for a header that can be clicked to sort descending. */
    sortDescendingAriaLabel: string;
    /** The aria label for a column that is sorted ascending. */
    sortedAscendingAriaLabel: string;
    /** The aria label for a column that is sorted descending. */
    sortedDescendingAriaLabel: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxSortHeaderIntl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NxSortHeaderIntl>;
}

declare class NxSortHeaderComponent implements OnInit, AfterViewInit, OnDestroy {
    readonly _intl: NxSortHeaderIntl;
    private readonly _cdr;
    private readonly _focusMonitor;
    /** Sets the key of this sort header. */
    set key(value: string);
    get key(): string;
    private _key;
    _focusContainer: ElementRef;
    readonly _sort: NxSortDirective;
    private readonly _destroyed;
    constructor(_sort: NxSortDirective | null, _intl: NxSortHeaderIntl, _cdr: ChangeDetectorRef, _focusMonitor: FocusMonitor);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    _handleClick(): void;
    _onKeydown($event: KeyboardEvent): void;
    _isSortedAscending(): boolean;
    _isSortedDescending(): boolean;
    _isSorted(): boolean;
    _getAriaLabel(): string | null;
    _getTitle(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxSortHeaderComponent, [{ optional: true; }, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxSortHeaderComponent, "th[nxSortHeaderCell]", ["nxSortHeaderComponent"], { "key": { "alias": "nxSortHeaderCell"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * This is a table.
 * The table supports a `zebra` and a `condensed` mode.
 */
declare class NxTableComponent {
    private readonly _cdr;
    private readonly _expandableTableDirective;
    /** Change the table mode to condensed  */
    set condensed(value: BooleanInput);
    get condensed(): boolean;
    private _condensed;
    /** Change the table mode to zebra  */
    set zebra(value: BooleanInput);
    get zebra(): boolean;
    private _zebra;
    /**
     * Makes first or last column "sticky".
     *
     * Values: `'first' | 'last' | 'both'`.
     */
    set sticky(value: string);
    get sticky(): string;
    private _sticky;
    constructor(_cdr: ChangeDetectorRef, _expandableTableDirective: NxExpandableTableDirective | null);
    static ɵfac: i0.ɵɵFactoryDeclaration<NxTableComponent, [null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxTableComponent, "table[nxTable]", never, { "sticky": { "alias": "sticky"; "required": false; }; "condensed": { "alias": "condensed"; "required": false; }; "zebra": { "alias": "zebra"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * This is a table cell.
 */
declare class NxTableCellComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<NxTableCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxTableCellComponent, "td[nxTableCell], td[nxCell]", never, {}, {}, never, ["*"], true, never>;
}

/**
 * This is a table row.
 */
declare class NxTableRowComponent {
    protected readonly _cdr: ChangeDetectorRef;
    private readonly _elementRef;
    /** Whether this table row is selectable */
    set selectable(value: BooleanInput);
    get selectable(): boolean;
    private _selectable;
    /** Whether this table row is selected */
    set selected(value: BooleanInput);
    get selected(): boolean;
    private _selected;
    readonly select: EventEmitter<void>;
    /** Whether this row is rendered "sticky". Only works for `nxHeaderCell` cells. */
    set mayStick(value: BooleanInput);
    get mayStick(): boolean;
    private _mayStick;
    constructor(_cdr: ChangeDetectorRef, _elementRef: ElementRef);
    _onSelect($event: KeyboardEvent): void;
    /**
     * Checks if the event would trigger an action or if default action is prevented.
     * Returns `true` if a button, link, input or label are clicked.
     */
    private isSelectionPrevented;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxTableRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxTableRowComponent, "tr[nxTableRow]", never, { "selectable": { "alias": "selectable"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "mayStick": { "alias": "mayStick"; "required": false; }; }, { "select": "select"; }, never, ["*"], true, never>;
}

/**
 * @docs-private
 * @deprecated No longer used.
 * @deletion-target 18.0.0
 */
declare function NX_SORT_HEADER_INTL_PROVIDER_FACTORY(parentIntl: NxSortHeaderIntl): NxSortHeaderIntl;
/**
 * @docs-private
 * @deprecated No longer used.
 * @deletion-target 18.0.0
 */
declare const NX_SORT_HEADER_INTL_PROVIDER: {
    provide: typeof NxSortHeaderIntl;
    deps: Optional[][];
    useFactory: typeof NX_SORT_HEADER_INTL_PROVIDER_FACTORY;
};
declare class NxTableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NxTableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NxTableModule, never, [typeof i1.CommonModule, typeof i2.NxIconModule, typeof i3.NxCopytextModule, typeof i4.NxSwipebarModule, typeof NxHeaderCellDirective, typeof NxTableComponent, typeof NxTableCellComponent, typeof NxTableComponent, typeof NxTableRowComponent, typeof NxToggleButtonComponent, typeof NxExpandableTableDirective, typeof NxExpandableTableRowComponent, typeof NxExpandableTableCellComponent, typeof NxSortHeaderComponent, typeof NxSortDirective, typeof NxHeaderResizeDirective, typeof NxTableCellClipDirective], [typeof NxHeaderCellDirective, typeof NxTableComponent, typeof NxTableCellComponent, typeof NxTableComponent, typeof NxTableRowComponent, typeof NxToggleButtonComponent, typeof NxExpandableTableDirective, typeof NxExpandableTableRowComponent, typeof NxExpandableTableCellComponent, typeof NxSortHeaderComponent, typeof NxSortDirective, typeof NxHeaderResizeDirective, typeof NxTableCellClipDirective, typeof i4.NxSwipebarModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NxTableModule>;
}

export { NX_SORT_HEADER_INTL_PROVIDER, NX_SORT_HEADER_INTL_PROVIDER_FACTORY, NxExpandableTableCellComponent, NxExpandableTableDirective, NxExpandableTableRowComponent, NxHeaderCellDirective, NxHeaderResizeDirective, NxSortDirective, NxSortHeaderComponent, NxSortHeaderIntl, NxTableCellClipDirective, NxTableCellComponent, NxTableComponent, NxTableModule, NxTableRowComponent, NxToggleButtonComponent, SortEvent };
export type { NxExpandable, SortDirection };