import * as i0 from '@angular/core';
import { ElementRef, EventEmitter, OnChanges, OnInit, SimpleChanges, QueryList, AfterContentInit, TemplateRef, ChangeDetectorRef, AfterViewInit, OnDestroy, InjectionToken } from '@angular/core';
import { CssClassBuilder, Nullable, ListItemInterface, KeyboardSupportItemInterface, FocusEscapeDirection, KeyboardSupportService } from '@fundamental-ngx/cdk/utils';
import { IconFont, IconComponent } from '@fundamental-ngx/core/icon';
import { Subject } from 'rxjs';
import * as i1 from '@angular/common';
import { NgClass } from '@angular/common';
import * as _fundamental_ngx_core_list from '@fundamental-ngx/core/list';
import { ButtonComponent } from '@fundamental-ngx/core/button';
import { CheckboxComponent } from '@fundamental-ngx/core/checkbox';
import { RadioButtonComponent } from '@fundamental-ngx/core/radio';
import { FormStates } from '@fundamental-ngx/cdk/forms';
import { FocusableOption } from '@angular/cdk/a11y';
import { ContentDensityObserver } from '@fundamental-ngx/core/content-density';

declare class ListBylineLeftDirective {
    /** Whether or not this should be wrapped, when too much text. */
    readonly wrap: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListBylineLeftDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListBylineLeftDirective, "[fdListBylineLeft], [fd-list-byline-left]", never, { "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type ListBylineStatus = 'neutral' | 'positive' | 'negative' | 'critical' | 'informative';
declare class ListBylineRightDirective {
    /** Semantic status of byline
     *  Possible options are:
     * 'neutral' | 'positive' | 'negative' | 'critical' | 'informative'
     */
    readonly status: i0.InputSignal<ListBylineStatus | undefined>;
    /** Whether or not this should be wrapped, when too much text. */
    readonly wrap: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListBylineRightDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListBylineRightDirective, "[fdListBylineRight], [fd-list-byline-right]", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ListBylineDirective {
    /** Whether or not this is a 2-column byline. */
    readonly twoCol: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether or not this should be wrapped, when too much text. */
    readonly wrap: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListBylineDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListBylineDirective, "[fdListByline], [fd-list-byline]", never, { "twoCol": { "alias": "twoCol"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ListContentDirective {
    /** @hidden */
    fdListContentClass: boolean;
    /** Whether or not this is a 2-column content. */
    twoCol: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListContentDirective, "[fdListContent], [fd-list-content]", never, { "twoCol": { "alias": "twoCol"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ListThumbnailDirective {
    /** @hidden */
    fdListThumbnailClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListThumbnailDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListThumbnailDirective, "[fdListThumbnail], [fd-list-thumbnail]", never, {}, {}, never, never, true, never>;
}

declare class ListFooterDirective {
    /** @hidden */
    fdListFooterClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListFooterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListFooterDirective, "[fdListFooter], [fd-list-footer]", never, {}, {}, never, never, true, never>;
}

declare class ListGroupHeaderDirective {
    readonly elementRef: ElementRef;
    /** id of an element to be applied */
    nativeElementId: string | null;
    /** @hidden Implementation of KeyboardSupportItemInterface */
    keyDown: EventEmitter<KeyboardEvent>;
    /** @hidden */
    constructor(elementRef: ElementRef);
    /** @hidden */
    keydownHandler(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListGroupHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListGroupHeaderDirective, "[fdListGroupHeader], [fd-list-group-header]", never, { "nativeElementId": { "alias": "nativeElementId"; "required": false; }; }, { "keyDown": "keyDown"; }, never, never, true, never>;
}

declare class ListIconDirective implements OnChanges, OnInit, CssClassBuilder {
    /** The icon name to display. See the icon page for the list of icons
     * here: https://sap.github.io/fundamental-ngx/icon
     * */
    glyph: string;
    /** Glyph font family */
    glyphFont: IconFont;
    /** Apply user custom styles */
    class: string;
    /** Role attribute for list icon */
    role: string;
    /** Aria hidden attribute for list icon */
    ariaHidden: 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[];
    /** @hidden */
    ngOnChanges(): void;
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListIconDirective, "[fdListIcon], [fd-list-icon]", never, { "glyph": { "alias": "glyph"; "required": false; }; "glyphFont": { "alias": "glyphFont"; "required": false; }; "class": { "alias": "class"; "required": false; }; "role": { "alias": "role"; "required": false; }; "ariaHidden": { "alias": "ariaHidden"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ListLinkDirective implements OnChanges {
    elementRef: ElementRef;
    /** Defines if navigation indicator arrow should be included inside list item */
    navigationIndicator: boolean;
    /** Defines if link should be treated as a navigated */
    navigated: boolean;
    /** Whether to mark link as focusable. If true, list item will shift focus from itself to the link. */
    focusable: boolean;
    /** @hidden */
    fdListLinkClass: boolean;
    /** Emits when some of the properties, that should be read by screenreader, are changed */
    readonly _onReadablePropertyChanged$: Subject<void>;
    /** @hidden */
    constructor(elementRef: ElementRef);
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListLinkDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListLinkDirective, "[fd-list-link], [fdListLink]", never, { "navigationIndicator": { "alias": "navigationIndicator"; "required": false; }; "navigated": { "alias": "navigated"; "required": false; }; "focusable": { "alias": "focusable"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ListNavigationItemArrowDirective {
    /** @hidden */
    navigationItemArrowClass: boolean;
    /** @hidden */
    rightArrowClass: boolean;
    /** @hidden */
    downArrowClass: boolean;
    /** @hidden */
    expanded: boolean;
    /** Aria-hidden attribute value. */
    ariaHidden: Nullable<boolean>;
    /** @hidden */
    _setExpanded(expanded: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListNavigationItemArrowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListNavigationItemArrowDirective, "[fd-list-navigation-item-arrow], [fdListNavigaitonItemArrow]", never, { "ariaHidden": { "alias": "ariaHidden"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ListNavigationItemTextDirective {
    readonly elementRef: ElementRef;
    /** @hidden */
    navigationItemTextClass: boolean;
    /** @hidden */
    constructor(elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ListNavigationItemTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListNavigationItemTextDirective, "[fd-list-navigation-item-text], [fdListNavigaitonItemText]", never, {}, {}, never, never, true, never>;
}

declare const _secondaryListItemTypes: readonly ["positive", "critical", "negative", "informative"];
type SecondaryListItemType = (typeof _secondaryListItemTypes)[number];
declare class ListSecondaryDirective implements OnChanges {
    /**
     * Type of the secondary list item.
     */
    type: SecondaryListItemType;
    /** @hidden */
    ngClass: NgClass;
    /** @hidden */
    constructor();
    /** @hidden */
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListSecondaryDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListSecondaryDirective, "[fd-list-secondary], [fdListSecondary]", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.NgClass; inputs: {}; outputs: {}; }]>;
}

declare class ListTitleTextDirective {
    /** @hidden */
    fdListTitleText: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListTitleTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListTitleTextDirective, "[fd-list-title-text], [fdListTitleText]", never, {}, {}, never, never, true, never>;
}

declare class ListTitleDirective implements OnInit {
    /** Whether or not this should be wrapped, when too much text. */
    readonly wrap: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether the text should truncate with ellipsis. */
    readonly truncate: i0.InputSignalWithTransform<boolean, unknown>;
    /** @hidden */
    readonly elRef: ElementRef<any>;
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListTitleDirective, "[fd-list-title], [fdListTitle]", never, { "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ListSublineDirective {
    /** Whether the text should truncate with ellipsis. */
    truncate: i0.InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListSublineDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListSublineDirective, "[fdListSubline], [fd-list-subline]", never, { "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface ListComponentInterface {
    _navItems: QueryList<{
        indicated: boolean;
        _innerText: string;
        expanded: boolean;
        _isItemVisible: boolean;
        focus(): void;
    }>;
    byline: boolean;
    items: QueryList<ListItemInterface>;
    role: Nullable<string>;
    setItemActive(index: number): void;
}

declare abstract class ListFocusItem<T = any> implements KeyboardSupportItemInterface {
    set tabindex(value: number);
    get tabindex(): number;
    /**
     * Value of the list item.
     * Used for dropdown-based controls such as combobox, select, etc.
     */
    value: T;
    /** @hidden Implementation of KeyboardSupportItemInterface */
    readonly keyDown: i0.OutputEmitterRef<KeyboardEvent>;
    /** @hidden */
    readonly elementRef: ElementRef;
    /** @hidden */
    readonly _focused$: Subject<{
        focusedWithin: boolean;
    }>;
    /** @hidden */
    readonly _clicked$: Subject<MouseEvent>;
    /** @hidden */
    protected _isFirstItem$: i0.WritableSignal<boolean>;
    /** @hidden */
    protected _tabIndex$: i0.WritableSignal<number | undefined>;
    /** @hidden */
    protected _normalizedTabIndex$: i0.Signal<number>;
    /** @hidden */
    protected onFocus(event: FocusEvent): void;
    /** @hidden */
    click(): void;
    /** @hidden */
    focus(): void;
    /** @hidden */
    setIsFirst(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListFocusItem<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListFocusItem<any>, never, never, { "tabindex": { "alias": "tabindex"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "keyDown": "keyDown"; }, never, never, true, never>;
}

/**
 * The component that represents a list item.
 * The list item can contain plain text, links or actions.
 */
declare class ListItemComponent<T = any> extends ListFocusItem<T> implements AfterContentInit, ListItemInterface {
    private readonly _changeDetectorRef;
    /** Whether list item is selected */
    selected: boolean;
    /** Whether there is no data inside list item */
    noData: boolean;
    /** Whether there is item performs some action */
    action: boolean;
    /** Whether there is item performs some action */
    interactive: boolean;
    /** Whether list item contains busy indicator */
    growing: boolean;
    /** Counter on list item */
    counter: number;
    /** Whether list item shows active indicator. Used only in List with Subline. */
    active: boolean;
    /** Whether list item should contain additional unRead styles */
    unread: boolean;
    /**
     * Whether the list item is byline
     */
    byline: boolean;
    /** Aria-role attribute. */
    ariaRole: Nullable<string>;
    /** The ID of the list item element */
    id: Nullable<string>;
    /** Whether to prevent built-in click event logic on the list item.
     * Helpful when using lists with checkboxes or radio buttons when the list item should be clickable, but should not select/deselect the list item. */
    preventClick: boolean;
    /** Whether list item contains link */
    link: boolean;
    /** @hidden */
    set radio(value: RadioButtonComponent);
    get radio(): RadioButtonComponent;
    /** @hidden */
    set checkbox(value: CheckboxComponent);
    get checkbox(): CheckboxComponent;
    /** @hidden */
    linkDirectives: QueryList<ListLinkDirective>;
    /** @hidden */
    buttons: QueryList<ButtonComponent>;
    /** @hidden Implementation of KeyboardSupportItemInterface */
    readonly keyDown: i0.OutputEmitterRef<KeyboardEvent>;
    /** @hidden group header id, that is being set by parent list component */
    _relatedGroupHeaderId: string | null;
    /** @hidden */
    readonly _list: _fundamental_ngx_core_list.ListComponentInterface | null;
    /** Template ref for Settings list item */
    settingsListTpl: i0.InputSignal<TemplateRef<any> | undefined>;
    /** @hidden */
    private _role;
    /** @hidden An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)  */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _onLinkListChanged$;
    /** @hidden */
    private _radio;
    /** @hidden */
    private _checkbox;
    /** @hidden */
    constructor(_changeDetectorRef: ChangeDetectorRef);
    /** @hidden */
    protected get roleAttr(): string;
    /** @hidden */
    keydownHandler(event: KeyboardEvent): void;
    /** @hidden */
    keyupHandler(event: KeyboardEvent): void;
    /** Handler for mouse events */
    onClick(event: MouseEvent): void;
    /** @hidden */
    protected _onFocus(): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    private _listenOnLinkQueryChange;
    /** @hidden */
    private _listenOnButtonQueryChange;
    /** @hidden */
    private _addClassToButtons;
    /** @hidden */
    private _muteEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListItemComponent<any>, "[fdListItem] ,[fd-list-item]", ["fdListItem"], { "selected": { "alias": "selected"; "required": false; }; "noData": { "alias": "noData"; "required": false; }; "action": { "alias": "action"; "required": false; }; "interactive": { "alias": "interactive"; "required": false; }; "growing": { "alias": "growing"; "required": false; }; "counter": { "alias": "counter"; "required": false; }; "active": { "alias": "active"; "required": false; }; "unread": { "alias": "unread"; "required": false; }; "byline": { "alias": "byline"; "required": false; }; "ariaRole": { "alias": "ariaRole"; "required": false; }; "id": { "alias": "id"; "required": false; }; "preventClick": { "alias": "preventClick"; "required": false; }; "settingsListTpl": { "alias": "settingsListTpl"; "required": false; "isSignal": true; }; }, { "keyDown": "keyDown"; }, ["radio", "checkbox", "linkDirectives", "buttons"], ["fd-checkbox", "fd-radio-button", "*"], true, never>;
}

declare class ListMessageDirective implements OnChanges, OnInit, CssClassBuilder {
    readonly elementRef: ElementRef;
    /** Type of the message. Can be 'success' | 'error' | 'warning' | 'information' */
    type: FormStates;
    /** Apply user custom styles */
    class: string;
    /** @hidden */
    constructor(elementRef: ElementRef);
    /** @hidden
     * CssClassBuilder interface implementation
     * function must return single string
     * function is responsible for order which css classes are applied
     */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnChanges(): void;
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListMessageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListMessageDirective, "[fd-list-message], [fdListMessage]", never, { "type": { "alias": "type"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ListNavigationItemComponent implements AfterContentInit, AfterViewInit, FocusableOption {
    /** Whether or not the list item is expanded. */
    expanded: boolean;
    /** Whether or not this list item is indicated for navigation. */
    indicated: boolean;
    /** @hidden */
    _navigationItemClass: boolean;
    /** @hidden */
    _isExpandable: boolean;
    /** @hidden */
    _tabIndex: any;
    /** @hidden */
    _ariaLevel: number;
    /** @hidden */
    _listComponent: ListComponentInterface;
    /** @hidden */
    _listNavigationItemArrow: ListNavigationItemArrowDirective;
    /** @hidden */
    _iconComponent: IconComponent;
    /** @hidden */
    _text: ListNavigationItemTextDirective;
    /** @hidden */
    _childItems: QueryList<ListNavigationItemComponent>;
    /** @hidden */
    protected get _ariaExpanded(): boolean | null;
    /** @hidden */
    _condensed: i0.WritableSignal<boolean>;
    /** @hidden */
    _expanded: boolean;
    /** @hidden */
    _innerText: string;
    /** @hidden */
    readonly _focused$: Subject<boolean>;
    /** @hidden */
    readonly _clicked$: Subject<MouseEvent>;
    /**
     * @hidden
     * false if list-item is within unexpanded list (not visible to user until list expanded). default is true
     */
    _isItemVisible: boolean;
    /** @hidden handles rtl service */
    private readonly _isRtl;
    /** @hidden */
    private readonly _renderer2;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    constructor();
    /** @hidden */
    onItemClick(event: MouseEvent): void;
    /** @hidden */
    keyDownHandler(event: KeyboardEvent): void;
    /** @hidden */
    protected onFocus(event: FocusEvent): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden
     * set the _isItemVisible of sublist items to true if this(containing) list is expanded.
     */
    _setIsItemVisible(value: boolean): void;
    /** @hidden */
    _childIndicatedAndCollapsed(): boolean;
    /** support for FocusKeyManager for arrow key navigation */
    focus(): void;
    /** support for FocusKeyManager for arrow key navigation */
    click(): void;
    /** @hidden */
    private _handleExpandedChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListNavigationItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListNavigationItemComponent, "[fd-list-navigation-item], [fdListNavigaitonItem]", never, { "expanded": { "alias": "expanded"; "required": false; }; "indicated": { "alias": "indicated"; "required": false; }; }, {}, ["_listComponent", "_listNavigationItemArrow", "_iconComponent", "_text", "_childItems"], ["*", "[fd-list]"], true, never>;
}

interface ListUnreadIndicator {
    unreadIndicator: boolean;
}

/**
 * The directive that represents a list.
 * It is used to display a list of items with simple information such as scopes, names, etc.
 */
declare class ListComponent implements ListComponentInterface, ListUnreadIndicator, OnInit, AfterContentInit, OnDestroy {
    private _keyboardSupportService;
    /** Whether dropdown mode is included to component, used for Select and Combobox */
    dropdownMode: boolean;
    /** Whether multi mode is included to component, used for MultiInput */
    multiInputMode: boolean;
    /** Whether list is used in mobile mode*/
    mobileMode: boolean;
    /** Whether list component contains message */
    hasMessage: boolean;
    /** Whether list component has removed borders */
    noBorder: boolean;
    /** Whether list component has navigation indicators */
    navigationIndicator: boolean;
    /** Whether list component has checkboxes or radio buttons included */
    selection: boolean;
    /** Whether internal keyboard support should be enabled. It's enabled by default */
    keyboardSupport: boolean;
    /** Whether list should have a byline */
    byline: boolean;
    /** Whether list should have a subline */
    subline: boolean;
    /** Whether to apply modifier class for Theme List */
    theme: boolean;
    /** Whether to display unread notification indicator. */
    unreadIndicator: boolean;
    /** Event thrown, when focus escapes the list */
    focusEscapeList: EventEmitter<FocusEscapeDirection>;
    /** Whether list component includes links */
    hasNavigation: boolean;
    /**
     * User-provided role.
     */
    role: Nullable<string>;
    /** @hidden */
    items: QueryList<ListItemInterface>;
    /** @hidden */
    _navItems: QueryList<ListNavigationItemComponent>;
    /** @hidden */
    private _focusItems;
    /** @hidden */
    protected get _ariaRole(): string;
    /** Whether the list is used inside Settings Dialog */
    settingsList: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether the list is used inside Settings Dialog Footer */
    settingsListFooter: i0.InputSignalWithTransform<boolean, unknown>;
    /**
     * @hidden
     * Default role for lists
     */
    private _defaultRole;
    /** An RxJS Subject that will kill the data stream upon queryList changes (for unsubscribing)  */
    private readonly _onRefresh$;
    /** An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)  */
    private readonly _destroyRef;
    /** @hidden */
    constructor(_keyboardSupportService: KeyboardSupportService<ListFocusItem>, _contentDensityObserver: ContentDensityObserver);
    /** @hidden */
    keyDownHandler(event: KeyboardEvent): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Set fake focus on element with passed index */
    setItemActive(index: number, updateOnly?: boolean): void;
    /**
     * @returns Currently active list item.
     */
    getActiveItem(): ListFocusItem | null;
    /** @hidden */
    private _listenOnQueryChange;
    /** @hidden */
    private _listenOnItemsClick;
    /** @hidden */
    private updateItemsProperties;
    /** @hidden */
    private _recheckLinks;
    /** @hidden */
    private _listenOnListFocusEscape;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListComponent, "[fd-list], [fdList]", never, { "dropdownMode": { "alias": "dropdownMode"; "required": false; }; "multiInputMode": { "alias": "multiInputMode"; "required": false; }; "mobileMode": { "alias": "mobileMode"; "required": false; }; "hasMessage": { "alias": "hasMessage"; "required": false; }; "noBorder": { "alias": "noBorder"; "required": false; }; "navigationIndicator": { "alias": "navigationIndicator"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "keyboardSupport": { "alias": "keyboardSupport"; "required": false; }; "byline": { "alias": "byline"; "required": false; }; "subline": { "alias": "subline"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "unreadIndicator": { "alias": "unreadIndicator"; "required": false; }; "role": { "alias": "role"; "required": false; }; "settingsList": { "alias": "settingsList"; "required": false; "isSignal": true; }; "settingsListFooter": { "alias": "settingsListFooter"; "required": false; "isSignal": true; }; }, { "focusEscapeList": "focusEscapeList"; }, ["items", "_navItems", "_focusItems"], ["*"], true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class ListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ListModule, never, [typeof ListComponent, typeof ListItemComponent, typeof ListTitleDirective, typeof ListFooterDirective, typeof ListGroupHeaderDirective, typeof ListSecondaryDirective, typeof ListIconDirective, typeof ListMessageDirective, typeof ListLinkDirective, typeof ListBylineDirective, typeof ListBylineLeftDirective, typeof ListBylineRightDirective, typeof ListContentDirective, typeof ListThumbnailDirective, typeof ListTitleTextDirective, typeof ListNavigationItemComponent, typeof ListNavigationItemArrowDirective, typeof ListNavigationItemTextDirective, typeof ListSublineDirective], [typeof ListComponent, typeof ListItemComponent, typeof ListTitleDirective, typeof ListFooterDirective, typeof ListGroupHeaderDirective, typeof ListSecondaryDirective, typeof ListIconDirective, typeof ListMessageDirective, typeof ListLinkDirective, typeof ListBylineDirective, typeof ListBylineLeftDirective, typeof ListBylineRightDirective, typeof ListContentDirective, typeof ListThumbnailDirective, typeof ListTitleTextDirective, typeof ListNavigationItemComponent, typeof ListNavigationItemArrowDirective, typeof ListNavigationItemTextDirective, typeof ListSublineDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ListModule>;
}

declare const FD_LIST_MESSAGE_DIRECTIVE: InjectionToken<unknown>;
declare const FD_LIST_LINK_DIRECTIVE: InjectionToken<unknown>;
declare const FD_LIST_COMPONENT: InjectionToken<ListComponentInterface>;
declare const FD_LIST_UNREAD_INDICATOR: InjectionToken<ListComponentInterface>;

export { FD_LIST_COMPONENT, FD_LIST_LINK_DIRECTIVE, FD_LIST_MESSAGE_DIRECTIVE, FD_LIST_UNREAD_INDICATOR, ListBylineDirective, ListBylineLeftDirective, ListBylineRightDirective, ListComponent, ListContentDirective, ListFocusItem, ListFooterDirective, ListGroupHeaderDirective, ListIconDirective, ListItemComponent, ListLinkDirective, ListMessageDirective, ListModule, ListNavigationItemArrowDirective, ListNavigationItemComponent, ListNavigationItemTextDirective, ListSecondaryDirective, ListSublineDirective, ListThumbnailDirective, ListTitleDirective, ListTitleTextDirective, _secondaryListItemTypes };
export type { ListBylineStatus, ListComponentInterface, ListUnreadIndicator, SecondaryListItemType };
