import * as i0 from '@angular/core';
import { ElementRef, DestroyRef, InjectionToken, Injector, AfterViewInit, OnDestroy, EventEmitter, AfterContentInit, Renderer2, QueryList, OnInit, AfterContentChecked, OnChanges, TemplateRef, ViewContainerRef, SimpleChanges, ModuleWithProviders, Provider, ChangeDetectorRef, EmbeddedViewRef, ComponentRef, ValueProvider, InputSignal, OutputEmitterRef, Type, ComponentFactoryResolver, ApplicationRef, Compiler, NgModuleFactory, FactorySansProvider, PipeTransform, WritableSignal, StaticProvider } from '@angular/core';
import * as rxjs from 'rxjs';
import { Observable, Subject, ReplaySubject, BehaviorSubject } from 'rxjs';
import { FocusableOption, InteractivityChecker, FocusKeyManager } from '@angular/cdk/a11y';
import * as i1 from '@angular/cdk/drag-drop';
import { DragDrop } from '@angular/cdk/drag-drop';
import { BooleanInput } from '@angular/cdk/coercion';
import { ComponentType, CdkPortalOutlet, ComponentPortal, TemplatePortal, BasePortalOutlet } from '@angular/cdk/portal';
import { DomSanitizer, SafeHtml, SafeStyle, SafeScript, SafeUrl, SafeResourceUrl } from '@angular/platform-browser';
import { Options, FocusTrap } from 'focus-trap';
import { MutationObserverFactory } from '@angular/cdk/observers';
import { ConnectedPosition, ScrollStrategy, OverlayRef, Overlay, ComponentType as ComponentType$1 } from '@angular/cdk/overlay';

interface HasElementRef<ElementType extends Element = HTMLElement> {
    readonly elementRef: ElementRef<ElementType>;
}
declare const ELEMENT_REF_EXCEPTION = "HasElementRef interface has to be implemented";

/** Makes the provided type nullable */
type Nullable<T> = T | null | undefined;
/** Makes each property of an object optional and nullable */
type NullableObject<T> = {
    [P in keyof T]?: Nullable<T[P]>;
};

interface FocusableItem extends FocusableOption {
    _position?: FocusableItemPosition;
    isFocusable: (() => boolean) | boolean;
    keydown: Observable<KeyboardEvent>;
    setTabbable: (tabbable: boolean) => void;
    element: (() => HTMLElement) | HTMLElement;
}

type CellFocusedEventAnnouncer = Nullable<(position: FocusableItemPosition) => string>;
interface FocusableItemPosition {
    rowIndex: number;
    colIndex: number;
    totalRows: number;
    totalCols: number;
}
declare class FocusableItemDirective implements FocusableItem, HasElementRef {
    /** @hidden Input with booleanAttribute transform */
    readonly fdkFocusableItem: i0.InputSignalWithTransform<boolean, unknown>;
    /** Function, which returns a string to be announced by screen-reader whenever an item which is in grid receives focus. */
    readonly cellFocusedEventAnnouncer: i0.InputSignal<CellFocusedEventAnnouncer>;
    /** Event emitted when the cell receives focus, not being emitted when focus moves between item's children. */
    readonly cellFocused: i0.OutputEmitterRef<FocusableItemPosition>;
    /** Event emitted when a focusable child element is focused. */
    readonly focusableChildElementFocused: i0.OutputEmitterRef<void>;
    /** @hidden */
    readonly _parentFocusableItemFocused: i0.OutputEmitterRef<void>;
    /** Element reference. */
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    readonly keydown: Subject<KeyboardEvent>;
    /** @hidden */
    _position: FocusableItemPosition;
    /** @hidden */
    protected readonly _destroyRef: DestroyRef;
    /**
     * Internal _focusable state that can be mutated programmatically.
     * Syncs with the fdkFocusableItem input but allows internal modification.
     * @hidden
     */
    private readonly _focusable;
    /** @hidden */
    private _tabbableElements;
    /** @hidden */
    private _tabbable;
    /** @hidden */
    private readonly _focusableObserver;
    /** @hidden */
    private readonly _tabbableElementService;
    /** @hidden */
    private readonly _liveAnnouncer;
    /** @hidden */
    private readonly _renderer2;
    /** @hidden */
    private readonly _document;
    /** @hidden */
    private readonly _checker;
    /** @hidden */
    constructor();
    /** @hidden */
    element: () => HTMLElement;
    /**
     * Programmatically set the _focusable state.
     * This allows parent components to update the _focusable state.
     */
    setFocusable(state: boolean): void;
    /**
     * Interface method required by FocusableItem.
     * Returns the current focusable state from the internal signal.
     * @hidden
     */
    isFocusable(): boolean;
    /** @hidden */
    focus(): void;
    /** Set tabbable state */
    setTabbable(state: boolean): void;
    /** @hidden */
    enableTabbableElements(): void;
    /** @hidden */
    disableTabbableElements(): void;
    /** @hidden */
    protected _onFocusin(): Promise<void>;
    /** @hidden */
    protected _onKeydown(event: KeyboardEvent): void;
    /** @hidden */
    private _defaultItemFocusedEventAnnouncer;
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusableItemDirective, "[fdkFocusableItem]", never, { "fdkFocusableItem": { "alias": "fdkFocusableItem"; "required": false; "isSignal": true; }; "cellFocusedEventAnnouncer": { "alias": "cellFocusedEventAnnouncer"; "required": false; "isSignal": true; }; }, { "cellFocused": "cellFocused"; "focusableChildElementFocused": "focusableChildElementFocused"; "_parentFocusableItemFocused": "_parentFocusableItemFocused"; }, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class FocusableItemModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableItemModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FocusableItemModule, never, [typeof FocusableItemDirective], [typeof FocusableItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FocusableItemModule>;
}

declare const FDK_FOCUSABLE_ITEM_DIRECTIVE: InjectionToken<unknown>;

interface FocusableListPosition {
    rowIndex: number;
    totalRows: number;
}

declare class FocusableObserver {
    /** @hidden */
    private readonly _attributeObserver;
    /** @Hidden */
    static isFocusable(element: Element, respectTabIndex: boolean): boolean;
    /** @hidden */
    observe(element: HasElementRef<Element> | Element | ElementRef<Element>, respectTabIndex?: boolean): Observable<boolean>;
    /** @hidden */
    unobserve(element: HasElementRef<Element> | Element | ElementRef<Element>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableObserver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FocusableObserver>;
}

declare class IndirectFocusableListDirective {
    /** @hidden */
    injector: Injector;
    /** @hidden */
    _focusableList: FocusableListDirective | null;
    /** @hidden */
    _indirectChildren: i0.WritableSignal<readonly FocusableItem[]>;
    /** @hidden */
    _indirectChildrenMap: Map<FocusableItem, number | (() => number)>;
    /** @hidden */
    private _updateTimeout?;
    /** @hidden */
    constructor();
    /** @hidden */
    register(item: FocusableItem, itemOrder: number | (() => number)): void;
    /** @hidden */
    unregister(item: FocusableItem): void;
    /** @hidden */
    protected _updateIndirectChildren(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IndirectFocusableListDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IndirectFocusableListDirective, "[fdkIndirectFocusableList]", ["fdkIndirectFocusableList"], {}, {}, never, never, true, never>;
}

declare const FDK_INDIRECT_FOCUSABLE_ITEM_ORDER: InjectionToken<number | (() => number)>;
/**
 * Directive, to mark the focusable item in the focusable list, which
 * is not the direct child of the focusable list.
 *
 * Useful in cases, when you need to make the item focusable, and
 * you do not have the access to the focusable list.
 */
declare class IndirectFocusableItemDirective {
    /** @hidden */
    protected _focusableItem: FocusableItem | null;
    /** @hidden */
    protected _indirectFocusableList: IndirectFocusableListDirective | null;
    /** @hidden */
    protected _order: number | (() => number) | null;
    /** @hidden */
    protected _destroyRef: DestroyRef;
    /** @hidden */
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<IndirectFocusableItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IndirectFocusableItemDirective, "[fdkIndirectFocusableItem]", never, {}, {}, never, never, true, never>;
}

/**
 * Returns true if the item configured to be focusable.
 * @param item
 */
declare function isItemFocusable(item: FocusableItem): boolean;

type ScrollPosition = 'top' | 'bottom' | undefined;
/** Helper function to scroll to focusable list or its item relatively to the container. */
declare function scrollIntoView(element: Nullable<HTMLElement>, position: Nullable<ScrollPosition>): void;

interface FocusableListItemFocusedEvent {
    index: number;
    total: number;
    id?: string | null;
}
interface FocusableListKeydownEvent {
    list: FocusableListDirective;
    event: KeyboardEvent;
    activeItemIndex: number | null | undefined;
}
declare class FocusableListDirective implements AfterViewInit, OnDestroy {
    /** Whether the whole list should be focusable, handy in grids. */
    set focusable(value: boolean);
    get focusable(): boolean;
    /** Direction of navigation. Should be set to 'grid' when list is a part of grid. */
    readonly navigationDirection: i0.ModelSignal<"horizontal" | "vertical" | "grid">;
    /** Direction of the content. */
    readonly contentDirection: i0.ModelSignal<"ltr" | "rtl" | null>;
    /**
     * Configures wrapping mode which determines whether the active item will wrap to the other end of list when there are no more items in the given direction.
     */
    readonly wrap: i0.InputSignalWithTransform<boolean, unknown>;
    /** Function, which returns a string to be announced by screen-reader whenever an row which is in grid receives focus. */
    readonly listFocusedEventAnnouncer: i0.InputSignal<(position: FocusableListPosition) => string>;
    /** Event emitted when list's item focused, contains item's position info. */
    readonly itemFocused: i0.OutputEmitterRef<FocusableListItemFocusedEvent>;
    /** @hidden */
    readonly _projectedFocusableItems: i0.Signal<readonly FocusableItem[]>;
    /** @hidden */
    readonly _itemsOverride: i0.WritableSignal<readonly FocusableItem[] | null>;
    /** @hidden */
    readonly _focusableItems: i0.Signal<readonly FocusableItem[]>;
    /** @hidden */
    readonly _gridItemFocused$: Subject<FocusableItemPosition>;
    /** @hidden */
    readonly _gridListFocused$: Subject<FocusableListPosition>;
    /** @hidden */
    readonly _keydown$: Subject<FocusableListKeydownEvent>;
    /** @hidden */
    readonly _isVisible: i0.WritableSignal<boolean>;
    /** @hidden */
    protected readonly tabindex: i0.Signal<0 | -1>;
    /** @hidden */
    protected readonly _destroyRef: DestroyRef;
    /** @hidden */
    protected _focusable: i0.WritableSignal<boolean>;
    /** @hidden */
    private readonly _gridPosition;
    /** @hidden */
    private _keyManager?;
    /** @hidden */
    private _tabbable;
    /** @hidden */
    private readonly _refreshItems$;
    /** @hidden */
    private _itemsEffectInitialized;
    /** @hidden */
    private readonly _renderer;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    private readonly _liveAnnouncer;
    /** @hidden */
    private readonly _focusableObserver;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    private readonly _document;
    /** @hidden */
    constructor();
    /** @hidden */
    _onKeydown(event: KeyboardEvent): void;
    /** @hidden */
    _onFocus(): Promise<void>;
    /** @hidden */
    ngAfterViewInit(): void;
    /** Set items programmatically. */
    setItems(items: ReadonlyArray<FocusableItem>): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Set active item in list */
    setActiveItem(index: number, scrollPosition?: ScrollPosition): void;
    /** Focus whole list */
    focus(scrollPosition?: ScrollPosition): void;
    /** Set tabbable state */
    setTabbable(state: boolean): void;
    /** @hidden */
    _updateNavigationDirection(): void;
    /** @hidden */
    _setItemsTabbable(state: boolean): void;
    /** @hidden */
    _setGridPosition(position: FocusableListPosition): void;
    /** @hidden */
    private _initializeFocusManager;
    /** @hidden */
    private _defaultListFocusedEventAnnouncer;
    /** @hidden */
    private _listenOnItems;
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableListDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusableListDirective, "[fdkFocusableList]", ["fdkFocusableList"], { "focusable": { "alias": "focusable"; "required": false; }; "navigationDirection": { "alias": "navigationDirection"; "required": false; "isSignal": true; }; "contentDirection": { "alias": "contentDirection"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "listFocusedEventAnnouncer": { "alias": "listFocusedEventAnnouncer"; "required": false; "isSignal": true; }; }, { "navigationDirection": "navigationDirectionChange"; "contentDirection": "contentDirectionChange"; "itemFocused": "itemFocused"; }, ["_projectedFocusableItems"], never, true, never>;
    static ngAcceptInputType_focusable: unknown;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class FocusableListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FocusableListModule, never, [typeof FocusableItemDirective, typeof FocusableListDirective], [typeof FocusableItemDirective, typeof FocusableListDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FocusableListModule>;
}

declare const FDK_FOCUSABLE_LIST_DIRECTIVE: InjectionToken<unknown>;

interface FocusableCellPosition {
    rowIndex: number;
    colIndex: number;
}
declare class FocusableGridDirective implements AfterViewInit {
    /** Direction of the content. */
    contentDirection: 'ltr' | 'rtl' | null;
    /** Whether the item in the previous/next row should be selected when going out of the first/last cell in the row. Default is false. */
    wrapHorizontally: boolean;
    /** Specify which item to select in prev/next row if its length smaller than current index. Nullish value means do not select. Default is null. */
    shortRowFocus: Nullable<'first' | 'last'>;
    /** Event emitted when item focused, contains item's position info. */
    readonly itemFocused: EventEmitter<FocusableItemPosition>;
    /** Event emitted when whole row focused, contains row's position info. */
    readonly rowFocused: EventEmitter<FocusableListPosition>;
    /** @hidden */
    private readonly _focusableLists;
    /** @hidden */
    private readonly _focusableItems;
    /** @hidden */
    _preventKeydown: boolean;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    private readonly _listItemEffects;
    /** @hidden */
    private readonly _subscribedItems;
    /** @hidden */
    ngAfterViewInit(): void;
    /**
     * Focus cell by position.
     * @param position position of the cell
     */
    focusCell(position: FocusableCellPosition): void;
    /** @hidden */
    _onKeydown(event: KeyboardEvent, list: FocusableListDirective, activeItemIndex: Nullable<number>): void;
    /** @hidden */
    private _getItemIndex;
    /** @hidden */
    private _handleItemSubscriptions;
    /** @hidden */
    private _watchListItems;
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableGridDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusableGridDirective, "[fdkFocusableGrid]", ["fdkFocusableGrid"], { "contentDirection": { "alias": "contentDirection"; "required": false; }; "wrapHorizontally": { "alias": "wrapHorizontally"; "required": false; }; "shortRowFocus": { "alias": "shortRowFocus"; "required": false; }; }, { "itemFocused": "itemFocused"; "rowFocused": "rowFocused"; }, ["_focusableLists", "_focusableItems"], never, true, never>;
    static ngAcceptInputType_wrapHorizontally: unknown;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class FocusableGridModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableGridModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FocusableGridModule, never, [typeof FocusableListModule, typeof FocusableGridDirective], [typeof FocusableListModule, typeof FocusableGridDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FocusableGridModule>;
}

type LinkPosition = 'after' | 'before';
interface ElementChord {
    x: number;
    y: number;
    position: LinkPosition;
    stickToPosition?: boolean;
    width: number;
    height: number;
}
interface FdDropEvent<T> {
    items: Array<T>;
    replacedItemIndex: number;
    draggedItemIndex: number;
    insertAt: 'before' | 'after' | null;
    mode: FdDndDropEventMode;
}
interface ElementPosition {
    x: number;
    y: number;
}
interface DndItem<T = any> {
    elementRef: ElementRef;
    item: Nullable<T>;
    moved: Observable<ElementPosition>;
    released: Observable<void>;
    started: Observable<void>;
    listDraggable: boolean;
    getElementCoordinates(isBefore: boolean, gridMode: boolean): ElementChord;
    removeLine(): void;
    removeReplaceIndicator(): void;
    createLine(linkPosition: LinkPosition, gridMode: boolean): void;
    createReplaceIndicator(): void;
    changeCDKDragState(): void;
    setDisabledState(state: boolean): void;
}
type FdDndDropType = 'shift' | 'group' | 'auto';
type FdDndDropEventMode = 'shift' | 'group';

declare class DndItemDirective<T = any> implements DndItem, AfterContentInit, OnDestroy {
    readonly elementRef: ElementRef;
    private readonly _dragDrop;
    private readonly _renderer;
    /** Item reference. Used for cases when `[items]` array of dnd list is different than `dndItems` content children. */
    item: Nullable<T>;
    /**
     * Whether to apply "fd-dnd-item" class.
     * @default true
     */
    applyDragItemClass: boolean;
    /** Container selector */
    containerSelector?: string;
    /** Event thrown when the element is moved by 1px */
    readonly moved: EventEmitter<ElementPosition>;
    /** Event thrown when the element is released */
    readonly released: EventEmitter<void>;
    /** Event thrown when the element is started to be dragged */
    readonly started: EventEmitter<void>;
    /**
     *  Defines if the item is prevented from being moved by other elements.
     * So nothing can be placed just before and just after it
     */
    stickInPlace: boolean;
    /** Defines if element is draggable */
    set draggable(draggable: boolean);
    /** Class added to element, when it's dragged. */
    classWhenElementDragged: string;
    /** Defines if every element in list is draggable */
    listDraggable: boolean;
    /** @hidden
     * Drag reference, object created from DND CDK Service
     */
    private _dragRef;
    /** @hidden */
    private _draggable;
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    private _placeholderElement;
    /** @hidden */
    private _lineElement;
    /** @hidden */
    private _replaceIndicator;
    /** @hidden */
    constructor(elementRef: ElementRef, _dragDrop: DragDrop, _renderer: Renderer2);
    /** @hidden */
    getElementCoordinates(isBefore: boolean): ElementChord;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    onCdkMove(position: ElementPosition): void;
    /** @hidden */
    onCdkDragReleased(): void;
    /** @hidden */
    onCdkDragStart(): void;
    /** @hidden */
    removePlaceholder(): void;
    /** @hidden */
    removeLine(): void;
    /** @hidden */
    removeReplaceIndicator(): void;
    /** @hidden */
    createReplaceIndicator(): void;
    /** @hidden */
    createLine(position: LinkPosition, gridMode: boolean): void;
    /** @hidden */
    changeCDKDragState(): void;
    /**
     * Sets the disabled state of the dnd item.
     * @param state
     */
    setDisabledState(state: boolean): void;
    /** @hidden */
    private createPlaceholder;
    /** @hidden */
    private _setPlaceholderStyles;
    /** @hidden */
    private _getOffsetToParent;
    /** @hidden */
    private _setCDKDrag;
    /** IE11 equivalent of Node.after() Method */
    private _placeAfter;
    /** @hidden */
    private _listenElementEvents;
    static ɵfac: i0.ɵɵFactoryDeclaration<DndItemDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DndItemDirective<any>, "[fdkDndItem], [fd-dnd-item]", never, { "item": { "alias": "fdkDndItem"; "required": false; }; "applyDragItemClass": { "alias": "applyDragItemClass"; "required": false; }; "containerSelector": { "alias": "containerSelector"; "required": false; }; "stickInPlace": { "alias": "stickInPlace"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "classWhenElementDragged": { "alias": "classWhenElementDragged"; "required": false; }; }, { "moved": "moved"; "released": "released"; "started": "started"; }, never, never, true, never>;
}

type DropPredicate<T> = (dragItem: T, dropItem: T, event: FdDropEvent<T>) => boolean | Promise<boolean> | Observable<boolean>;
type DragoverPredicate<T> = (dragItem: T, dragOverItem: T, dragItemIndex: number, dragOverItemIndex: number) => boolean;
declare class DndListDirective<T> implements AfterContentInit, OnDestroy {
    /**
     * Defines if the element is allowed to be dragged in 2 dimensions,
     * When true - replace indicator will be displayed vertically
     */
    gridMode: boolean;
    /**
     * Defines drop strategy:
     * * `shift` mode will create line after the closest drop element.
     * * `group` mode will create replace indicator on a whole closest drop element.
     * * `auto` mode will create a line after the closest drop element
     * if dragged element coordinates are shifted for 30% from the center of the closest drop element.
     * Otherwise, it will create replace indicator on a whole closest drop element.
     *
     * `shift` mode is the default.
     */
    dropMode: FdDndDropType;
    /**
     * Threshold of dragged item over another item to define which type of `dropMode` should be used.
     */
    threshold: number;
    /** Array of items, that will be sorted */
    items: Array<T>;
    /** Defines if drag and drop feature should be enabled for list items */
    set draggable(draggable: boolean);
    /** Predicate function that checks whether the item can be dropped over another item. */
    dropPredicate: DropPredicate<T> | undefined;
    /**
     * Predicate function that checks whether the item can be dragged over another item.
     * If the function returns `false`, dragged over item will not be highlighted, and drop event will be canceled.
     */
    dragoverPredicate: DragoverPredicate<T> | undefined;
    /**
     * Event emitted when `dropPredicate` function evaluation changes.
     * Emits `true` when evaluation started, and `false` when completed.
     */
    dropPredicateCalculating: EventEmitter<boolean>;
    /** Event that is thrown when items are reordered */
    readonly itemsChange: EventEmitter<T[]>;
    /** Event that is thrown when the item is dropped */
    readonly itemDropped: EventEmitter<FdDropEvent<T>>;
    /** Event that is thrown when predicate function returned false. */
    readonly dropCancelled: EventEmitter<void>;
    /** @hidden */
    dndItems: QueryList<DndItem<T>>;
    /** @hidden */
    protected readonly _initialClass = "fd-dnd-list";
    /** @hidden */
    private _elementsCoordinates;
    /** @hidden */
    private _closestItemIndex;
    /** @hidden */
    private _closestItemPosition;
    /** An RxJS Subject that will kill the current data stream (for unsubscribing)  */
    private readonly _refresh$;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden  */
    private _dndItemReference;
    /** @hidden */
    private _draggable;
    /** @hidden */
    private _detectedDropMode;
    /** @hidden */
    private _linesRemoved;
    /** @hidden */
    private _indicatorsRemoved;
    /** @hidden */
    private _draggedItem;
    /** @hidden */
    private _ignoreDrop;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /**
     * Refreshes the indexes of the items.
     */
    refreshQueryList(): void;
    /** Method called when the item is being moved by 1 px */
    onMove(mousePosition: ElementPosition, draggedItemIndex: number): void;
    /** Method called when an element is started to be dragged */
    dragStart(index: number): void;
    /** Method called when an element is released */
    dragEnd(draggedItemIndex: number): Promise<void>;
    /** @hidden */
    private _setDisabledItem;
    /** @hidden */
    private _selectDropModeIndicator;
    /** @hidden */
    private _removeAllLines;
    /** @hidden */
    private _removeAllReplaceIndicators;
    /** @hidden */
    private _createLine;
    /** @hidden */
    private _createReplaceIndicator;
    /**
     *  @hidden
     * Return information if an element is placed before the dragged element
     */
    private _isBefore;
    /** @hidden */
    private _changeDraggableState;
    static ɵfac: i0.ɵɵFactoryDeclaration<DndListDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DndListDirective<any>, "[fdkDndList], [fd-dnd-list]", never, { "gridMode": { "alias": "gridMode"; "required": false; }; "dropMode": { "alias": "dropMode"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; "items": { "alias": "items"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "dropPredicate": { "alias": "dropPredicate"; "required": false; }; "dragoverPredicate": { "alias": "dragoverPredicate"; "required": false; }; }, { "dropPredicateCalculating": "dropPredicateCalculating"; "itemsChange": "itemsChange"; "itemDropped": "itemDropped"; "dropCancelled": "dropCancelled"; }, ["dndItems"], never, true, never>;
}

/**
 * This directive is used to provide drag & drop with keyboard support.
 * It should be used together with directive fdDndKeyboardItem.
 */
declare class DndKeyboardGroupDirective {
    /** Group of items */
    groups: any[][];
    /** Whether to disable drag & drop */
    disableKeyboardDragDrop: boolean;
    /** Used to apply indexes when moving between groups */
    orientation: 'horizontal' | 'vertical';
    /** @hidden */
    _onDndItemFocus$: Subject<[number, number]>;
    /** @hidden */
    private readonly _cdr;
    /** @hidden */
    private readonly _rtlService;
    /** Custom function to call when moving item inside the group */
    customMoveFn: (group: any[], fromIndex: number, toIndex: number) => void;
    /** Custom function to call when moving item between groups */
    customTransferFn: (group: any[], nextGroup: any[], fromIndex: number, toIndex: number) => void;
    /** Process drag & drop */
    processDragDrop(event: KeyboardEvent, itemIndex: number, groupIndex: number): void;
    /** @hidden Focus after moving elements with keyboard */
    private _focusDndItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<DndKeyboardGroupDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DndKeyboardGroupDirective, "[fdkDndKeyboardGroup], [fdDndKeyboardGroup]", never, { "groups": { "alias": "groups"; "required": false; }; "disableKeyboardDragDrop": { "alias": "disableKeyboardDragDrop"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "customMoveFn": { "alias": "customMoveFn"; "required": false; }; "customTransferFn": { "alias": "customTransferFn"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * This directive is used to provide drag & drop with keyboard support.
 * It should be used together with directive fdDndKeyboardGroup.
 * We are using _groups from fdDndKeyboardGroup and adding a possibility to move cards.
 * Please see example below:
 * @Component({
 * selector: 'cdk-drag-drop-example',
 * template: `<div
 *               cdkDragListGroup
 *               fdDndKeyboardGroup
 *               [groups]="groups"
 *           >
 *               <div
 *                   *ngFor="let group of groups; let groupIndex = index"
 *                   cdkDragList
 *               >
 *                   Group #{{ groupIndex }}
 *                   <div
 *                       *ngFor="let item of group; let index = index"
 *                       cdkDrag
 *                       fdDndKeyboardItem
 *                       [itemIndex]="index"
 *                       [groupIndex]="groupIndex"
 *                       [dndKeyboardDisabled]="flag for disable/enable keyboard navigation if needed"
 *                       tabindex="0"
 *                   >
 *                       Item #{{ item }}
 *                   </div>
 *               </div>
 *           </div>`,
 * })
 * export class CdkDragDropExample {
 *   groups = [
 *        [1, 2, 3],
 *        [4, 5, 6],
 *      ];
 *   }
 */
declare class DndKeyboardItemDirective implements OnInit, OnDestroy {
    private readonly _dndGroup;
    private readonly _elementRef;
    /** item index in group(column) */
    itemIndex: number;
    /** group(column) index */
    groupIndex: number;
    /** @hidden */
    private readonly _onDestroy$;
    /** @hidden */
    constructor(_dndGroup: DndKeyboardGroupDirective, _elementRef: ElementRef);
    /** @hidden */
    _onKeyDown(event: KeyboardEvent): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DndKeyboardItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DndKeyboardItemDirective, "[fdkDndKeyboardItem], [fdDndKeyboardItem]", never, { "itemIndex": { "alias": "itemIndex"; "required": false; }; "groupIndex": { "alias": "groupIndex"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class DragAndDropModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DragAndDropModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DragAndDropModule, never, [typeof i1.DragDropModule, typeof DndItemDirective, typeof DndListDirective, typeof DndKeyboardGroupDirective, typeof DndKeyboardItemDirective], [typeof DndItemDirective, typeof DndListDirective, typeof DndKeyboardGroupDirective, typeof DndKeyboardItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DragAndDropModule>;
}

declare class OnlyDigitsDirective {
    private readonly _el;
    /** Allow using decimal */
    decimal: boolean;
    /** Define decimal separator
     * Default: .(dot)
     */
    decimalSeparator: string;
    /** @hidden */
    private _inputElement;
    /** @hidden */
    private _hasDecimalPoint;
    /** @hidden */
    constructor(_el: ElementRef);
    /** @hidden */
    onKeyDown(e: KeyboardEvent): void;
    /** @hidden */
    onPaste(event: any): void;
    /** @hidden */
    onDrop(event: DragEvent): void;
    /** @hidden */
    private _pasteData;
    /** @hidden */
    private _insertAtCursor;
    /** @hidden */
    private _triggerEvent;
    /** @hidden */
    private _sanitizeInput;
    /** @hidden */
    private _isValidDecimal;
    /** @hidden */
    private get _getSelection();
    /** @hidden */
    private _forecastValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<OnlyDigitsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<OnlyDigitsDirective, "[fdkOnlyDigits]", never, { "decimal": { "alias": "decimal"; "required": false; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class OnlyDigitsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<OnlyDigitsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<OnlyDigitsModule, never, [typeof OnlyDigitsDirective], [typeof OnlyDigitsDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<OnlyDigitsModule>;
}

declare class TruncateDirective implements AfterViewInit {
    /**
     * Width in pixel for truncation of an element, by default 200
     */
    readonly fdkTruncateWidth: i0.InputSignalWithTransform<number, unknown>;
    /**
     * Truncating state
     */
    readonly fdkTruncateState: i0.InputSignal<boolean>;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    private _truncateTarget;
    /** @hidden
     * saves default style of element before truncating
     */
    private _defaultStyle;
    /** @hidden */
    private _defaultStyleCaptured;
    /**
     * Root native element
     */
    get rootElement(): HTMLElement;
    /** @hidden */
    constructor();
    /**
     * Method saves default style of target element before first truncate.
     */
    setDefaultStyle(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    private _truncate;
    static ɵfac: i0.ɵɵFactoryDeclaration<TruncateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TruncateDirective, "[fdkTruncate]", never, { "fdkTruncateWidth": { "alias": "fdkTruncateWidth"; "required": false; "isSignal": true; }; "fdkTruncateState": { "alias": "fdkTruncateState"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class TruncatedTitleDirective implements AfterContentChecked {
    private _elRef;
    /** @hidden */
    constructor(_elRef: ElementRef);
    /** @hidden */
    ngAfterContentChecked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatedTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TruncatedTitleDirective, "[fdkTruncatedTitle], [fdTruncatedTitle], [fd-truncate-title]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class TruncateModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TruncateModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TruncateModule, never, [typeof TruncateDirective, typeof TruncatedTitleDirective], [typeof TruncateDirective, typeof TruncatedTitleDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TruncateModule>;
}

declare class LineClampTargetDirective {
    /**
     * Target text for clamping
     */
    readonly fdLineClampTargetText: i0.InputSignal<string>;
    /**
     * Event with target instance for clamping
     */
    readonly update: i0.OutputEmitterRef<LineClampTargetDirective>;
    /** @hidden */
    private readonly _elementRef;
    /**
     * @hidden
     * Tracks whether the directive has completed its initial render.
     * Used to prevent a double emission on startup: afterNextRender handles
     * the first emit, so the effect must skip its own initial execution.
     */
    private _initialized;
    /**
     * Native element of clamping target
     */
    get targetElement(): HTMLElement;
    /** @hidden */
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LineClampTargetDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LineClampTargetDirective, "[fdkLineClampTarget], [fdLineClampTarget], [fd-lineclamp-target]", ["fdLineClampTarget"], { "fdLineClampTargetText": { "alias": "fdLineClampTargetText"; "required": false; "isSignal": true; }; }, { "update": "update"; }, never, never, true, never>;
}
declare class LineClampDirective {
    /**
     * Count lines for clamping
     */
    readonly fdLineClampLines: i0.InputSignalWithTransform<number, unknown>;
    /**
     * Clamping state
     */
    readonly fdLineclampState: i0.InputSignal<boolean>;
    /**
     * Event return count of lines from the target
     */
    readonly lineCountUpdate: i0.OutputEmitterRef<number>;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    private readonly _renderer;
    /** @hidden */
    private readonly _viewportSize$;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private _lineClampTarget;
    /** @hidden */
    private _originalText;
    /**
     * @hidden
     * Determined once in the constructor — before effect() runs — so that
     * the very first effect execution already has the correct value.
     */
    private _isNativeSupport;
    /**
     * Root native element of clamping box
     */
    get rootElement(): HTMLElement;
    /** @hidden */
    constructor();
    /** @hidden */
    reset(): void;
    /** @hidden */
    refreshTarget(event: LineClampTargetDirective): void;
    /** @hidden
     * Refresh clamp styles based on state and line count
     */
    refreshClamp(state: boolean, lineCount: number): void;
    /** @hidden
     * Truncate text in the target box, if browser not support lineclamp style
     */
    private _truncate;
    /** @hidden
     * Get lineheight for rootelement, if browser not support lineclamp style
     */
    private _getLineHeight;
    /** @hidden
     * Setup native styles for lineclamp text
     */
    private _applyNative;
    /** @hidden
     * Reset native styles for lineclamp text
     */
    private _resetNative;
    /** @hidden */
    private _checkLineCount;
    static ɵfac: i0.ɵɵFactoryDeclaration<LineClampDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LineClampDirective, "[fdkLineClamp]", ["fdLineClamp"], { "fdLineClampLines": { "alias": "fdLineClampLines"; "required": false; "isSignal": true; }; "fdLineclampState": { "alias": "fdLineclampState"; "required": false; "isSignal": true; }; }, { "lineCountUpdate": "lineCountUpdate"; }, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class LineClampModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LineClampModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LineClampModule, never, [typeof LineClampTargetDirective, typeof LineClampDirective], [typeof LineClampTargetDirective, typeof LineClampDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LineClampModule>;
}

declare class OverflowListItemDirective {
    el: ElementRef;
    /** @hidden */
    constructor(el: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<OverflowListItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<OverflowListItemDirective, "[fdkOverflowListItem]", never, {}, {}, never, never, true, never>;
}

declare class OverflowListDirective implements AfterViewInit {
    private _el;
    /**
     * @description Offset to calculate correct position
     */
    overflowOffset: number;
    /**
     * @description Flag representing rtl mode
     */
    isRtl: boolean;
    /**
     * @description value of display property of existed list items
     */
    itemCssBlockValue: string;
    /**
     * @description Emits when changed amount of extra items
     */
    overflowChanged: EventEmitter<number>;
    /**
     * @description References to QueryList of OverflowListItemDirective
     */
    overflowItems: QueryList<OverflowListItemDirective>;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private _resizeObserver;
    /** @hidden */
    private _mutationObserver;
    /** @hidden Track whether a recalculation microtask is already scheduled. */
    private _recalcScheduled;
    /** @hidden */
    constructor(_el: ElementRef);
    /** @hidden */
    ngAfterViewInit(): void;
    /**
     * @description Get amount of extra items in current list
     * */
    getAmountOfExtraItems(): number;
    /**
     * @description Schedule overflow recalculation via microtask.
     * Microtasks execute after DOM mutations but before the browser paints,
     * so items are measured and hidden before the user ever sees them overflow.
     * Multiple calls within the same task are coalesced by the _recalcScheduled flag.
     */
    calculateOverflow(): void;
    /** @hidden */
    private _initResizeObserver;
    /**
     * @hidden
     * @description Watch for DOM content changes within items.
     * - childList: detects items added/removed (e.g. new tabs rendered by @for)
     * - characterData: detects text content changes (e.g. label updates, i18n)
     * Does NOT watch attributes, so our own measurement (hidden/display toggles)
     * and the consumer's CSS class changes won't cause infinite loops.
     */
    private _initMutationObserver;
    /** @hidden */
    private _calculateAmountOfOverflowedItems;
    /**
     * @hidden
     * @param arrItems
     * @param containerWidth
     * @param checkWithOffset
     * */
    private _checkWidthWithOffset;
    /**
     * @param arrItems
     * @hidden
     * */
    private _clearTempStyles;
    static ɵfac: i0.ɵɵFactoryDeclaration<OverflowListDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<OverflowListDirective, "[fdkOverflowList]", never, { "overflowOffset": { "alias": "overflowOffset"; "required": false; }; "isRtl": { "alias": "isRtl"; "required": false; }; "itemCssBlockValue": { "alias": "itemCssBlockValue"; "required": false; }; }, { "overflowChanged": "overflowChanged"; }, ["overflowItems"], never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class OverflowListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<OverflowListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<OverflowListModule, never, [typeof OverflowListDirective, typeof OverflowListItemDirective], [typeof OverflowListDirective, typeof OverflowListItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<OverflowListModule>;
}

/**
 * Directive to repeatably render template N times.
 *
 * @deprecated Use Angular's built-in `@for` control flow with the `range()` utility function instead.
 * Example: `@for (i of range(3); track i) { <div>Item {{ i }}</div> }`
 * This directive will be removed in a future major version.
 */
declare class RepeatDirective implements OnChanges {
    private readonly _templateRef;
    private readonly _viewContainerRef;
    /** Number of times to render a template. */
    count: number;
    /** @hidden */
    constructor(_templateRef: TemplateRef<any>, _viewContainerRef: ViewContainerRef);
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RepeatDirective, "[fdkRepeat]", never, { "count": { "alias": "fdkRepeat"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class RepeatModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<RepeatModule, never, [typeof RepeatDirective], [typeof RepeatDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<RepeatModule>;
}

declare class ResizeHandleDirective {
    elementRef: ElementRef;
    /** @hidden */
    constructor(elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeHandleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeHandleDirective, "[fdkResizeHandle]", never, {}, {}, never, never, true, never>;
}

declare class ResizeDirective implements OnChanges, AfterViewInit, OnDestroy {
    private _elementRef;
    /** Element limiting resizable container growth */
    resizeBoundary: string | HTMLElement;
    /** Whether resizable behaviour should be disabled */
    disabled: boolean;
    /** Additional class to be applied to the Element ref during resize. */
    fdkResizeClass: string;
    /** Localization of resize handle inside resizable container */
    resizeHandleLocation: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
    /** Resize handle reference - should be used if Resize handle is not a ContentChild of resizable container */
    set setResizeHandleReference(value: ResizeHandleDirective);
    /** Emits event when resizing has tarted */
    onResizeStart: EventEmitter<void>;
    /** Emits event when resizing has ended */
    onResizeEnd: EventEmitter<void>;
    /** @hidden Reference to Resize handle */
    set resizeHandleReference(value: Nullable<ResizeHandleDirective>);
    get resizeHandleReference(): Nullable<ResizeHandleDirective>;
    /** @hidden */
    private _resizeHandleReference;
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    private _resizeSubscriptions;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    constructor(_elementRef: ElementRef<HTMLElement>);
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _unsubscribe;
    /** @hidden Sets Resize listeners */
    private _setResizeListeners;
    /** @hidden Creates resize function*/
    private _getResizeFunction;
    /** @hidden Creates move function */
    private _getMoveOffsetFunction;
    /** @hidden Return boundary container */
    private _findResizeContainer;
    /** @hidden Check whether resizable container is overflowing boundary container */
    private _getBoundaryOverflowFunction;
    /** @hidden Create Observable notifying on resize actions */
    private _getResizeEventsNotifiers;
    /** @hidden Block resizable container pointer events when resizing  */
    private _blockOtherPointerEvents;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeDirective, "[fdkResize]", never, { "resizeBoundary": { "alias": "fdkResizeBoundary"; "required": false; }; "disabled": { "alias": "fdkResizeDisabled"; "required": false; }; "fdkResizeClass": { "alias": "fdkResizeClass"; "required": false; }; "resizeHandleLocation": { "alias": "fdkResizeHandleLocation"; "required": false; }; "setResizeHandleReference": { "alias": "fdkResizeResizeHandleRef"; "required": false; }; }, { "onResizeStart": "onResizeStart"; "onResizeEnd": "onResizeEnd"; }, ["resizeHandleReference"], never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class ResizeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ResizeModule, never, [typeof ResizeDirective, typeof ResizeHandleDirective], [typeof ResizeDirective, typeof ResizeHandleDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ResizeModule>;
}

declare class TemplateDirective {
    /** Name of the template */
    readonly name: i0.InputSignal<string>;
    /** @hidden */
    readonly templateRef: TemplateRef<any>;
    /** @hidden */
    getName(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateDirective, "[fdkTemplate]", never, { "name": { "alias": "fdkTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class TemplateModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TemplateModule, never, [typeof TemplateDirective], [typeof TemplateDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TemplateModule>;
}

interface AutoCompleteEvent {
    term: string;
    forceClose: boolean;
}
declare class AutoCompleteDirective {
    /** Values that will fill missing text in the input. */
    options: any[];
    /**
     * Input text, that is taken from ngModel of formControl,
     * there has to be difference between native input value and model value
     */
    inputText: string;
    /** Whether the auto complete directive should be enabled */
    enable: boolean;
    /** Display function. Accepts an object of the same type as the
     * items passed to dropdownValues as argument, and outputs a string.
     * An arrow function can be used to access the *this* keyword in the calling component.
     * See search input examples for details. */
    displayFn: (value: any) => string;
    /** Event thrown, when the auto ahead text is accepted */
    readonly onComplete: EventEmitter<AutoCompleteEvent>;
    /** @hidden */
    private readonly _completeKeys;
    /** @hidden */
    private readonly _fillKeys;
    /** @hidden */
    private readonly _stopKeys;
    /** @hidden */
    private oldValue;
    /** @hidden */
    private lastKeyUpEvent;
    /** @hidden */
    private _isComposing;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    constructor();
    /** Matcher function for testing the str for a search term */
    matcher: (str: string, searchTerm: string) => boolean;
    /** @hidden */
    _handleKeyboardEvent(event: KeyboardEvent): void;
    /** @hidden */
    private _typeahead;
    /** @hidden */
    private _isControlKey;
    /** @hidden */
    private _defaultDisplay;
    /** @hidden */
    private _triggerTypeAhead;
    /** @hidden */
    private _sendCompleteEvent;
    /** @hidden */
    private _moveIndicatorToLastCharacter;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoCompleteDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoCompleteDirective, "[fdkAutoComplete]", never, { "options": { "alias": "options"; "required": false; }; "inputText": { "alias": "inputText"; "required": false; }; "enable": { "alias": "enable"; "required": false; }; "displayFn": { "alias": "displayFn"; "required": false; }; "matcher": { "alias": "matcher"; "required": false; }; }, { "onComplete": "onComplete"; }, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class AutoCompleteModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoCompleteModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AutoCompleteModule, never, [typeof AutoCompleteDirective], [typeof AutoCompleteDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AutoCompleteModule>;
}

declare class ClickedDirective {
    /**
     * Event name.
     */
    static eventName: string;
    /**
     * Event emitted when user either clicks with mouse, or
     * clicks on space or enter keys
     */
    readonly fdkClicked: i0.OutputEmitterRef<KeyboardEvent | MouseEvent>;
    /** @hidden */
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ClickedDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickedDirective, "[fdkClicked]", never, {}, { "fdkClicked": "fdkClicked"; }, never, never, true, never>;
}

/**
 * @deprecated
 * ClickedBehaviorModule is deprecated and will be removed in the next major release. Use ClickedDirective instead.
 */
declare class ClickedBehaviorModule {
    /** @hidden */
    constructor();
    /** @hidden */
    static forRoot(): ModuleWithProviders<ClickedBehaviorModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClickedBehaviorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ClickedBehaviorModule, never, [typeof ClickedDirective], [typeof ClickedDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ClickedBehaviorModule>;
}

/**
 * Returns Observable that emits when element is clicked. Uses Renderer2 to listen to events.
 * @param element
 * @param renderer
 */
declare function elementClick$(element: ElementRef<HTMLElement> | HTMLElement, renderer?: Renderer2): Observable<MouseEvent | KeyboardEvent>;

declare class FdkClickedProvider extends Subject<MouseEvent | KeyboardEvent> implements OnDestroy {
    private readonly _elementRef;
    private readonly _renderer;
    /** @hidden */
    private _preventDefault;
    /** @hidden */
    private _listeners;
    /** @hidden */
    private readonly _fdkClickedEventManagerPluginLoaded;
    /** @hidden */
    constructor(_elementRef: ElementRef<Element>, _renderer: Renderer2, eventManagerPlugins: any[]);
    /** @hidden */
    setPreventDefault(val: boolean): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _initialize;
    static ɵfac: i0.ɵɵFactoryDeclaration<FdkClickedProvider, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FdkClickedProvider>;
}

/**
 * @deprecated
 * ClickedBehaviorModule is deprecated and will be removed in the next major release. Use ClickedDirective instead.
 */
declare const ClickedBehaviorModuleForRootLoadedOnce: InjectionToken<boolean>;
/**
 * Provides ClickedEventPlugin to the application
 * @deprecated
 */
declare function provideFdkClicked(): Provider[];

interface DisabledViewModifier {
    setDisabledState: (isDisabled: boolean) => void;
}

type Base$1 = Observable<boolean> & DisabledViewModifier;
interface DisabledBehavior extends Base$1 {
    fdkDisabled: boolean;
}

declare class DisabledBehaviorDirective extends ReplaySubject<boolean> implements DisabledBehavior, DisabledViewModifier {
    private _elementRef;
    private _destroyRef;
    private _clicked;
    /**
     * Whether the element is disabled.
     */
    readonly fdkDisabledInput: i0.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether to add `disabledClass` class to the element.
     */
    readonly addDisabledClass: i0.InputSignalWithTransform<boolean, unknown>;
    /**
     * Disabled css class to apply to the element.
     */
    readonly disabledClass: i0.InputSignal<string>;
    /**
     * Getter for fdkDisabled to maintain interface compatibility.
     */
    get fdkDisabled(): boolean;
    /** @hidden */
    private _previousDisabledState;
    /** @hidden */
    constructor(_elementRef: ElementRef<HTMLElement>, _destroyRef: DestroyRef, _clicked: FdkClickedProvider);
    /** @hidden */
    setDisabledState: (isDisabled: boolean) => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DisabledBehaviorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DisabledBehaviorDirective, "[fdkDisabled]", never, { "fdkDisabledInput": { "alias": "fdkDisabled"; "required": false; "isSignal": true; }; "addDisabledClass": { "alias": "addDisabledClass"; "required": false; "isSignal": true; }; "disabledClass": { "alias": "disabledClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class DisabledBehaviorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DisabledBehaviorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DisabledBehaviorModule, never, [typeof DisabledBehaviorDirective], [typeof DisabledBehaviorDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DisabledBehaviorModule>;
}

type SelectableListValueType<T> = T extends any[] ? Array<any> : any;
declare abstract class SelectComponentRootToken<T = any> {
    abstract selected?: SelectableListValueType<T>;
    abstract selectedChange: Observable<SelectableListValueType<T>>;
    abstract multiple?: BooleanInput;
    abstract toggle?: BooleanInput;
    abstract onChange: (value: SelectableListValueType<T>) => void;
}

declare abstract class SelectableItemToken<ElementType extends Element = HTMLElement, TValue = ElementType> implements HasElementRef<ElementType> {
    abstract value: TValue;
    abstract fdkSelectableItem?: boolean;
    abstract readonly elementRef: ElementRef<ElementType>;
    abstract clicked: Observable<MouseEvent | KeyboardEvent>;
    abstract setSelected(isSelected: boolean): void;
    abstract getSelected(): boolean;
}

type SelectionItemsList<ElementType extends Element, ValueType = ElementType> = QueryList<SelectableItemToken<ElementType, ValueType>> | Observable<SelectableItemToken<ElementType, ValueType>[]> | SelectableItemToken<ElementType, ValueType>[];
declare class SelectionService<ElementType extends Element, ValueType = ElementType> {
    private _cd;
    /** @hidden */
    value$: Observable<SelectableListValueType<ValueType>>;
    /** @hidden */
    private _items$;
    /** @hidden */
    private _value$;
    /** @hidden */
    private _normalizedValue$;
    /** @hidden */
    private _rootComponent;
    /** @hidden */
    private _destroyRef;
    /** @hidden */
    private _clear$;
    /** @hidden */
    private _value;
    /** @hidden */
    constructor(_cd: ChangeDetectorRef);
    /**
     * Register main select component, which holds config
     * */
    registerRootComponent(rootComponent: SelectComponentRootToken<ElementType>): void;
    /**
     * Clear listeners
     */
    clear(): void;
    /**
     * Initialize watcher for selection changes and user interactions
     * */
    initialize(list: SelectionItemsList<ElementType, ValueType>): void;
    /**
     * Sets Value, on which service looks at and updates UI accordingly
     * */
    setValue(v: SelectableListValueType<ElementType>): void;
    /** @hidden */
    getValue(): SelectableListValueType<ElementType>;
    /**
     * Start listening for item interactions. Will destroy() first.
     * Will silently continue if service was not initialized first.
     * */
    listenToItemInteractions(): void;
    /** @hidden */
    selectItem(item: SelectableItemToken<ElementType, ValueType>): void;
    /** @hidden */
    deselectItem(item: SelectableItemToken<ElementType, ValueType>): void;
    /** @hidden */
    private get _isMultipleMode();
    /** @hidden */
    private _itemClicked;
    /** @hidden */
    private _getSelectedValues;
    /** @hidden */
    private _getProperValues;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionService<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionService<any, any>>;
}

declare class SelectableListDirective<T extends Element = HTMLElement, V = any> implements SelectComponentRootToken<T>, AfterViewInit {
    private _selectionService;
    /** @hidden */
    selectedChange: EventEmitter<SelectableListValueType<T>>;
    /** @hidden */
    toggle: boolean;
    /** @hidden */
    multiple: boolean;
    /** @hidden */
    set selected(value: SelectableListValueType<T>);
    /** @hidden */
    selectableItems: QueryList<SelectableItemToken<T, V>>;
    /** @hidden */
    constructor(_selectionService: SelectionService<T, V>);
    /** @hidden */
    select(item: SelectableItemToken<T, V>): void;
    /** @hidden */
    deselect(item: SelectableItemToken<T, V>): void;
    /** @hidden */
    toggleSelect(item: SelectableItemToken<T, V>): void;
    /** @hidden */
    onChange(value: SelectableListValueType<T>): void;
    /** @hidden */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableListDirective<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectableListDirective<any, any>, "[fdkSelectableList]", ["fdkSelectableList"], { "toggle": { "alias": "toggle"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "selectedChange": "selectedChange"; }, ["selectableItems"], never, true, never>;
    static ngAcceptInputType_toggle: unknown;
    static ngAcceptInputType_multiple: unknown;
}

declare class DisabledObserver {
    /** @hidden */
    private readonly _attributeObserver;
    /** @hidden */
    static isDisabled(el: Element): boolean;
    /** @hidden */
    observe(element: HasElementRef<Element> | Element | ElementRef<Element>): Observable<boolean>;
    /** @hidden */
    unobserve(element: HasElementRef<Element> | Element | ElementRef<Element>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DisabledObserver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DisabledObserver>;
}

declare class FdkDisabledProvider extends ReplaySubject<boolean> implements DisabledBehavior, OnDestroy {
    private elementRef;
    private selfDisabled$?;
    private parentDisabled$?;
    /** @Hidden */
    fdkDisabled: boolean;
    /** @Hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    private readonly disabledObserver;
    /** @hidden */
    private readonly _viewModifiers$;
    /** @hidden */
    private _disabledChange$;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>, selfDisabled$?: DisabledBehavior | undefined, parentDisabled$?: DisabledBehavior | undefined);
    /** @hidden */
    addViewModifier(modifier: DisabledViewModifier): void;
    /** @hidden */
    setDisabledState(isDisabled: boolean): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _getDisabledChange$;
    /** @hidden */
    private _getInitialViewModifiers;
    static ɵfac: i0.ɵɵFactoryDeclaration<FdkDisabledProvider, [null, { optional: true; self: true; }, { optional: true; skipSelf: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FdkDisabledProvider>;
}

declare const FDK_DISABLED_DIRECTIVE: InjectionToken<DisabledBehavior>;

/** @hidden */
declare function setDisabledState(element: HasElementRef<Element> | Element | ElementRef<Element>, isDisabled: boolean, disabledClass: string, addDisabledClass: boolean): void;

interface ReadonlyViewModifier {
    setReadonlyState: (isReadonly: boolean) => void;
}

declare class DefaultReadonlyViewModifier implements ReadonlyViewModifier {
    private elementRef;
    /** @hidden */
    constructor(elementRef: ElementRef<Element>);
    /** @hidden */
    setReadonlyState: (isDisabled: boolean) => void;
}

type Base = Observable<boolean> & ReadonlyViewModifier;
interface ReadonlyBehavior extends Base {
    fdkReadonly: boolean;
}

declare class FdkReadonlyProvider extends ReplaySubject<boolean> implements ReadonlyBehavior, OnDestroy {
    private elementRef;
    private selfReadonly$;
    private parentReadonly$;
    /** @Hidden */
    fdkReadonly: boolean;
    /** @hidden */
    private readonly _viewModifiers$;
    /** @hidden */
    private _readonlyChange$;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly readonlyObserver;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    constructor(elementRef: ElementRef<Element>, selfReadonly$: ReadonlyBehavior, parentReadonly$: ReadonlyBehavior);
    /** @hidden */
    addViewModifier(modifier: ReadonlyViewModifier): void;
    /** @hidden */
    setReadonlyState(isReadonly: boolean): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _getReadonlyChange$;
    /** @hidden */
    private _getInitialViewModifiers;
    static ɵfac: i0.ɵɵFactoryDeclaration<FdkReadonlyProvider, [null, { optional: true; self: true; }, { optional: true; skipSelf: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FdkReadonlyProvider>;
}

declare const FDK_READONLY_DIRECTIVE: InjectionToken<unknown>;

declare class ReadonlyBehaviorDirective extends ReplaySubject<boolean> implements ReadonlyBehavior, AfterViewInit {
    private _elementRef;
    private _destroyRef;
    /** @Hidden */
    set fdkReadonly(value: boolean);
    get fdkReadonly(): boolean;
    /** @Hidden */
    _readonly: boolean;
    /** @hidden */
    private readonly _readonlyInput$;
    /** @hidden */
    constructor(_elementRef: ElementRef<HTMLElement>, _destroyRef: DestroyRef);
    /** @Hidden */
    setReadonlyState: (isReadonly: boolean) => void;
    /** @hidden */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReadonlyBehaviorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ReadonlyBehaviorDirective, "[fdkReadonly]", never, { "fdkReadonly": { "alias": "fdkReadonly"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_fdkReadonly: unknown;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class ReadonlyBehaviorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ReadonlyBehaviorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ReadonlyBehaviorModule, never, [typeof ReadonlyBehaviorDirective], [typeof ReadonlyBehaviorDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ReadonlyBehaviorModule>;
}

declare class ReadonlyObserver {
    /** @Hidden */
    private readonly _attributeObserver;
    /** @Hidden */
    static isReadonly(element: Element): boolean;
    /** @hidden */
    observe(element: HasElementRef<Element> | Element | ElementRef<Element>): Observable<boolean>;
    /** @Hidden */
    unobserve(element: HasElementRef<Element> | Element | ElementRef<Element>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReadonlyObserver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ReadonlyObserver>;
}

/** @Hidden */
declare function setReadonlyState(element: HasElementRef<Element> | Element | ElementRef<Element>, isReadonly: boolean): void;

declare class SelectableItemDirective<ElementType extends Element = HTMLElement, ValueType = any> implements SelectableItemToken<ElementType, ValueType> {
    private provider;
    private disabled$;
    private readonly$;
    private selectionService;
    readonly elementRef: ElementRef<ElementType>;
    /** @hidden */
    set value(val: ValueType);
    get value(): ValueType;
    /** @hidden */
    set fdkSelectableItem(value: BooleanInput);
    get fdkSelectableItem(): boolean;
    /** @hidden */
    clicked: Observable<MouseEvent | KeyboardEvent>;
    /** Event emitted when selection state being changed for selectable item. */
    selected: EventEmitter<boolean>;
    /** @hidden */
    private _value;
    /** @hidden */
    private _selected;
    /** @hidden */
    private _selectable;
    /** @hidden */
    constructor(provider: Partial<SelectableItemToken<ElementType, ValueType>>, disabled$: FdkDisabledProvider, readonly$: FdkReadonlyProvider, selectionService: SelectionService<ElementType, ValueType>, elementRef: ElementRef<ElementType>, _clicked: FdkClickedProvider);
    /** @hidden */
    getSelected(): boolean;
    /** @hidden */
    setSelected(isSelected: boolean): void;
    /** @hidden */
    private _listenToDisablingEvents;
    /** @hidden */
    private _updateSelectionAndSelectableWatcher;
    /** @hidden */
    private _updateSelectableWatcher;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableItemDirective<any, any>, [{ optional: true; }, null, null, null, null, null]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectableItemDirective<any, any>, "[fdkSelectableItem]", ["fdkSelectableItem"], { "value": { "alias": "value"; "required": false; }; "fdkSelectableItem": { "alias": "fdkSelectableItem"; "required": false; }; }, { "clicked": "clicked"; "selected": "selected"; }, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class SelectableListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectableListModule, never, [typeof SelectableListDirective, typeof SelectableItemDirective], [typeof SelectableListDirective, typeof SelectableItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SelectableListModule>;
}

declare class TabbableElementService {
    private readonly _checker;
    private readonly _document;
    /** @hidden */
    constructor(_checker: InteractivityChecker, _document: Document | null);
    /** Get the first tabbable element from a DOM subtree (inclusive). */
    getTabbableElement(root: HTMLElement, focusLastElement?: boolean, skipSelf?: boolean): HTMLElement | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabbableElementService, [null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TabbableElementService>;
}

declare class InitialFocusDirective implements AfterViewInit {
    private _elmRef;
    private readonly _tabbableService;
    /**
     * CSS selector of an element that should be focused.
     */
    fdkInitialFocus: string;
    /**
     * Whether initial focus enabled for a current element.
     */
    set enabled(value: boolean);
    get enabled(): boolean;
    /**
     * Whether to focus last element in a found array of elements.
     */
    focusLastElement: boolean;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    private readonly _enabled$;
    /** @hidden */
    constructor(_elmRef: ElementRef<HTMLElement>, _tabbableService: TabbableElementService);
    /** @hidden */
    ngAfterViewInit(): void;
    /**
     * @hidden
     * Searches for an appropriate focusable element
     */
    private _getFocusableElement;
    /** @hidden */
    private _focus;
    static ɵfac: i0.ɵɵFactoryDeclaration<InitialFocusDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InitialFocusDirective, "[fdkInitialFocus]", never, { "fdkInitialFocus": { "alias": "fdkInitialFocus"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; "focusLastElement": { "alias": "focusLastElement"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class InitialFocusModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<InitialFocusModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<InitialFocusModule, never, [typeof InitialFocusDirective], [typeof InitialFocusDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<InitialFocusModule>;
}

declare const ResponsiveBreakpoints: {
    readonly S: 600;
    readonly M: 1024;
    readonly L: 1440;
};
type breakpointName = keyof typeof ResponsiveBreakpoints | 'XL';
type BreakpointName = Lowercase<breakpointName> | Uppercase<breakpointName>;
/** @hidden */
declare function getBreakpointName(width: number): breakpointName;

/**
 * Directive to show/hide element on specific breakpoint or range of window width.
 * Uses native ngIf directive to show/hide element.
 */
declare class BreakpointDirective implements OnChanges, AfterViewInit {
    private readonly templateRef;
    private readonly viewContainer;
    /**
     * Provide list of the breakpoints to show element on.
     * */
    set fdkBreakpoint(value: BreakpointName[]);
    /**
     * Show element on S breakpoint.
     * S - 0 - 599px
     * */
    showOnS: boolean;
    /**
     * Show element on M breakpoint.
     * M - 0 - 1023px
     * */
    showOnM: boolean;
    /**
     * Show element on L breakpoint.
     * L - 0 - 1439px
     * */
    showOnL: boolean;
    /**
     * Show element on XL breakpoint.
     *  */
    showOnXL: boolean;
    /**
     * Show element on breakpoint less than provided value.
     * */
    fdkBreakpointLt: number;
    /**
     * Show element on breakpoint greater than provided value.
     *  */
    fdkBreakpointGt: number;
    /**
     * Observe element width changes.
     */
    set observationSource(value: HTMLElement | ElementRef<HTMLElement>);
    /** @hidden */
    templateViewRef?: EmbeddedViewRef<unknown>;
    /** @hidden */
    onChanges$: Subject<void>;
    /** @hidden */
    _sizeObservable$: BehaviorSubject<Observable<number>>;
    /** @hidden */
    private viewportSize$;
    /** @hidden */
    private _destroyRef;
    /** @hidden */
    private _resizeObserverService;
    /** @hidden */
    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnChanges(): void;
    /** @hidden */
    private _shouldShow;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreakpointDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BreakpointDirective, "[fdkBreakpoint], [fdkBreakpointS], [fdkBreakpointM], [fdkBreakpointL], [fdkBreakpointXL], [fdkBreakpointLt], [fdkBreakpointGt]", never, { "fdkBreakpoint": { "alias": "fdkBreakpoint"; "required": false; }; "showOnS": { "alias": "fdkBreakpointS"; "required": false; }; "showOnM": { "alias": "fdkBreakpointM"; "required": false; }; "showOnL": { "alias": "fdkBreakpointL"; "required": false; }; "showOnXL": { "alias": "fdkBreakpointXL"; "required": false; }; "fdkBreakpointLt": { "alias": "fdkBreakpointLt"; "required": false; }; "fdkBreakpointGt": { "alias": "fdkBreakpointGt"; "required": false; }; "observationSource": { "alias": "fdkBreakpointObserve"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_showOnS: unknown;
    static ngAcceptInputType_showOnM: unknown;
    static ngAcceptInputType_showOnL: unknown;
    static ngAcceptInputType_showOnXL: unknown;
}
declare class BreakpointModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BreakpointModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BreakpointModule, never, [typeof BreakpointDirective], [typeof BreakpointDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BreakpointModule>;
}

declare class IntersectionSpyDirective implements OnInit {
    /** Intersection offset in px. */
    offset: number;
    /** Intersection observer options. */
    viewportOptions: IntersectionObserverInit;
    /** Event emitted when intersection observer emits with the current element. */
    intersected: EventEmitter<boolean>;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionSpyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IntersectionSpyDirective, "[fdkIntersectionSpy]", never, { "offset": { "alias": "fdkIntersectionSpy"; "required": false; }; "viewportOptions": { "alias": "viewportOptions"; "required": false; }; }, { "intersected": "intersected"; }, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class UtilsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UtilsModule, never, [typeof FocusableItemModule, typeof FocusableListModule, typeof FocusableGridModule, typeof DragAndDropModule, typeof OnlyDigitsModule, typeof TruncateModule, typeof LineClampModule, typeof OverflowListModule, typeof RepeatModule, typeof ResizeModule, typeof TemplateModule, typeof AutoCompleteModule, typeof DisabledBehaviorModule, typeof SelectableListModule, typeof ReadonlyBehaviorModule, typeof ClickedDirective, typeof InitialFocusModule, typeof BreakpointModule, typeof IntersectionSpyDirective], [typeof FocusableItemModule, typeof FocusableListModule, typeof FocusableGridModule, typeof DragAndDropModule, typeof OnlyDigitsModule, typeof TruncateModule, typeof LineClampModule, typeof OverflowListModule, typeof RepeatModule, typeof ResizeModule, typeof TemplateModule, typeof AutoCompleteModule, typeof DisabledBehaviorModule, typeof SelectableListModule, typeof ReadonlyBehaviorModule, typeof ClickedDirective, typeof InitialFocusModule, typeof BreakpointModule, typeof IntersectionSpyDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UtilsModule>;
}

/** @hidden */
declare abstract class AbstractFdNgxClass implements HasElementRef, OnInit, OnChanges {
    /** @hidden */
    abstract _setProperties(): void;
    /** @hidden */
    class: string;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    constructor();
    /** @hidden */
    _setClassToElement(className: string): void;
    /** @hidden */
    _clearElementClass(): void;
    /** @hidden */
    _addClassToElement(className: string): void;
    /** @hidden */
    _addStyleToElement(attribute: any, value: any): void;
    /** @hidden */
    ngOnChanges(): void;
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFdNgxClass, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFdNgxClass, never, never, { "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
}

interface SubscriptionStrategy<T = any> {
    /**
     * @description Awaits object to resolve it's value and passes it to the callback function.
     * @param obj Object to be awaited.
     * @param updateLatestValue Callback function where awaited value will be passed.
     * as an argument
     */
    createSubscription(obj: Observable<T> | Promise<T> | (() => void) | T, updateLatestValue: (value: T) => void): Promise<void>;
}

/**
 * @description Executes function and passes returned value into callback function.
 */
declare class FunctionStrategy<T> implements SubscriptionStrategy<T> {
    /** @hidden */
    createSubscription(fn: () => T, updateLatestValue: (v: T) => any): Promise<void>;
}

/**
 * @description Converts observable into Promise and passes returned value into callback function.
 */
declare class ObservableStrategy<T> implements SubscriptionStrategy<T> {
    /** @hidden */
    createSubscription(async: Observable<T>, updateLatestValue: any): Promise<void>;
}

/**
 * @description awaits for promise to resolve it's value and passes returned value into callback function.
 */
declare class PromiseStrategy<T> implements SubscriptionStrategy<T> {
    /** @hidden */
    createSubscription(async: Promise<T>, updateLatestValue: (v: T) => any): Promise<void>;
}

/**
 * @description Selects appropriate strategy on how to resolve function value
 * @param obj object to get value from
 * @returns appropriate strategy to retrieve value from the object
 */
declare function selectStrategy<T = any>(obj: Observable<T> | Promise<T> | (() => void) | T): SubscriptionStrategy<T>;

/**
 * @description Passes value object into callback function.
 */
declare class ValueStrategy<T> implements SubscriptionStrategy<T> {
    /** @hidden */
    createSubscription(value: T, updateLatestValue: (v: T) => any): Promise<void>;
}

/** @hidden */
declare function coerceArraySafe<T>(value: T | T[]): T[];

/**
 * A component that can be used to attach a portal to a DOM element, without explicitly creating portal instances on place.
 * This is useful when you have a list of the components or templates, or HTMLElmets, and you want to attach them to the DOM
 * dynamically in a loop.
 */
declare class DynamicPortalComponent implements AfterViewInit {
    /** The DOM element to attach */
    set domElement(value: HTMLElement | ElementRef<HTMLElement> | string);
    /** The component to attach */
    set component(value: ComponentType<any>);
    /** The template to attach */
    set template(value: TemplateRef<any>);
    /** The Content which should be attached and can be any of the items */
    set auto(value: DynamicPortalComponent['domElement' | 'component' | 'template']);
    /** Emits when the portal is attached */
    attached: EventEmitter<Element | EmbeddedViewRef<any> | ComponentRef<any>>;
    /** @hidden */
    portalOutlet?: CdkPortalOutlet;
    /** @hidden */
    private portalContent$;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private viewContainerRef;
    /** @hidden */
    private renderer;
    /** @hidden */
    private elementRef;
    /** @hidden */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPortalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPortalComponent, "fdk-dynamic-portal", never, { "domElement": { "alias": "domElement"; "required": false; }; "component": { "alias": "component"; "required": false; }; "template": { "alias": "template"; "required": false; }; "auto": { "alias": "auto"; "required": false; }; }, { "attached": "attached"; }, never, never, true, never>;
}

declare const MOBILE_CONFIG_ERROR = "Missing configuration object for mobile version of the component.\n    Consult the documentation on how to provide MobileModeConfiguration object for this component.\n";
declare const THEME_SWITCHER_ROUTER_MISSING_ERROR = "You need to import RouterModule to enable theme settings via the url.";
declare const INVALID_DATE_ERROR = "Invalid Date";

type OverflowPriority = 'always' | 'never' | 'low' | 'high' | 'disappear';
declare const OVERFLOW_PRIORITY_SCORE: Map<OverflowPriority, number>;

/**
 * Instead of `/\p{L}/u` because of it's not working in IE11 and Edge
 * - https://github.com/Microsoft/ChakraCore/issues/2969
 * */
declare const LETTERS_UNICODE_RANGE = "[A-Za-z\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]";
declare const ANY_LANGUAGE_LETTERS_REGEX: RegExp;
declare const ANY_LANGUAGE_LETTERS_GROUP_REGEX: RegExp;

/**
 * Polyfill for `/\p{Nd}/u` to work in IE11 and Edge
 */
declare const DECIMAL_NUMBER_UNICODE_RANGE = "[0-9\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE6-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29\u1040-\u1049\u1090-\u1099\u17E0-\u17E9\u1810-\u1819\u1946-\u194F\u19D0-\u19D9\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\uA620-\uA629\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19]";
declare const DECIMAL_NUMBER_UNICODE_REGEX: RegExp;
declare const DECIMAL_NUMBER_UNICODE_GROUP_REGEX: RegExp;

type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc['length']]>;
type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
type ColorAccent = IntRange<1, 11>;

type Hash<valueType> = {
    [key in string | number]: valueType;
};

type NestedKeyOf<ObjectType extends object> = {
    [Key in keyof ObjectType & (string | number)]: ObjectType[Key] extends object ? `${Key}` | `${Key}.${NestedKeyOf<ObjectType[Key]>}` : `${Key}`;
}[keyof ObjectType & (string | number)];
type ObjectPathType<T, K extends keyof T | string> = K extends keyof T ? T[K] : K extends `${infer First}.${infer Rest}` ? First extends keyof T ? ObjectPathType<T[First], Rest> : never : never;

type Size = 'xs' | 's' | 'm' | 'l' | 'xl';

/**
 * Method decorator to apply css class to a component through native element
 * decorator will store original method in variable and wrap it with custom one
 * component has to implement CssClassBuilder interface
 * more info abour method decorator: https://www.typescriptlang.org/docs/handbook/decorators.html#method-decorators
 * @param target a component
 * @param propertyKey name of the method
 * @param descriptor method
 */
declare function applyCssClass(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;

/**
 * Method decorator to apply css styles to a component through native element
 * decorator will store original method in variable and wrap it with custom one
 * component has to implement HasElementRef or CssStyleBuilder interface
 * more info abour method decorator: https://www.typescriptlang.org/docs/handbook/decorators.html#method-decorators
 * @param target a component
 * @param propertyKey name of the method
 * @param descriptor method
 */
declare function applyCssStyle(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;

/**
 * Decorator for coercing passed value to boolean, using @angular/cdk coerceBooleanProperty
 */
declare const coerceBoolean: PropertyDecorator;

declare const coerceCssPixel: PropertyDecorator;

/**
 * Function, which generates decorator. Passed mutator will be called during value set
 */
declare function alternateSetter(mutator: (value: any, self: Record<string | symbol, any>) => any): PropertyDecorator;

interface DeprecatedSelectorModel {
    deprecated: string;
    current: string;
}
/** @hidden */
declare function getDeprecatedModel(current: string, deprecated: string): DeprecatedSelectorModel;
/** @hidden */
declare function deprecatedModelProvider(current: string, deprecated: string): ValueProvider;
declare const FD_DEPRECATED_DIRECTIVE_SELECTOR: InjectionToken<DeprecatedSelectorModel>;
declare abstract class DeprecatedSelector {
    /** @hidden */
    protected _selectors: DeprecatedSelectorModel | null;
    /** @hidden */
    constructor();
    /** @hidden */
    protected _messageGenerator(deprecated: string, current: string): string;
}

/** Directive to apply Angular Material FocusKeyManager to lists.
 * To be used with FocusKeyManagerItemDirective
 */
declare class FocusKeyManagerListDirective<TItem extends FocusableOption = Record<any, any> & FocusableOption> implements OnChanges, AfterContentInit, OnDestroy {
    /** Orientation for the FocusKeyManager */
    orientation: 'horizontal' | 'vertical';
    /** Skip predicate for the FocusKeyManager */
    skipPredicate: (item: TItem) => boolean;
    /** @hidden */
    readonly _items: QueryList<TItem>;
    /** @hidden */
    get focusKeyManager(): FocusKeyManager<TItem>;
    /** @hidden */
    private _focusKeyManager;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    private readonly _isRtl;
    /** @hidden */
    private readonly _cdr;
    /** @hidden */
    constructor();
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Focus certain list's item */
    focusItem(item: number | TItem): any;
    /** @hidden */
    private _applyOrientation;
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusKeyManagerListDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusKeyManagerListDirective<any>, "[fdkFocusKeyManagerList]", never, { "orientation": { "alias": "orientation"; "required": false; }; "skipPredicate": { "alias": "skipPredicate"; "required": false; }; }, {}, ["_items"], never, true, never>;
}

/** Directive to apply Angular Material FocusKeyManager to lists.
 * To be used with FocusKeyManagerItemDirective
 */
declare class FocusKeyManagerItemDirective implements FocusableOption {
    private readonly _list;
    private readonly _elRef;
    /** Whether item should be initially focused */
    initialFocus: boolean;
    /** @hidden */
    get _tabindex(): number;
    /** Native element of the item */
    get nativeElement(): any;
    /** @hidden */
    private get _focusKeyManager();
    /** @hidden */
    constructor(_list: FocusKeyManagerListDirective, _elRef: ElementRef);
    /** @hidden */
    _onFocus(): void;
    /** @hidden */
    _onKeydown(event: KeyboardEvent): void;
    /** Focus current item native element */
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusKeyManagerItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusKeyManagerItemDirective, "[fdkFocusKeyManagerItem]", never, { "initialFocus": { "alias": "initialFocus"; "required": false; }; "_tabindex": { "alias": "_tabindex"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_initialFocus: unknown;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class FocusKeyManagerHelpersModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusKeyManagerHelpersModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FocusKeyManagerHelpersModule, never, [typeof FocusKeyManagerItemDirective, typeof FocusKeyManagerListDirective], [typeof FocusKeyManagerItemDirective, typeof FocusKeyManagerListDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FocusKeyManagerHelpersModule>;
}

declare const FOCUSABLE_ITEM: InjectionToken<FocusableOption>;

declare const FDK_FOCUSABLE_GRID_DIRECTIVE: InjectionToken<unknown>;

/**
 * Directive will stop propagation and prevent default of click, if selected area is coming from
 * directive's host element. This gives ability to not cancel all clicks on element, just the ones
 * which include selection
 */
declare class IgnoreClickOnSelectionDirective {
    private document;
    private _elementRef;
    /** @hidden */
    constructor(document: Document, _elementRef: ElementRef<HTMLElement>);
    /** Host click listener. Checks for selection existence and if finds one, checks anchor */
    clicked($event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgnoreClickOnSelectionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgnoreClickOnSelectionDirective, "[fdkIgnoreClickOnSelection]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class IgnoreClickOnSelectionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgnoreClickOnSelectionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgnoreClickOnSelectionModule, never, [typeof IgnoreClickOnSelectionDirective], [typeof IgnoreClickOnSelectionDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgnoreClickOnSelectionModule>;
}

declare const IgnoreClickOnSelectionDirectiveToken: InjectionToken<unknown>;

type ContentDensity = 'cozy' | 'condensed' | 'compact';

interface CssClassBuilder extends HasElementRef {
    /**
     * The class for the component
     **/
    class: Nullable<string> | InputSignal<string | undefined>;
    /**
     * Method to build component css class
     */
    buildComponentCssClass(): string[];
}

interface CssStyleBuilder extends HasElementRef {
    buildComponentCssStyle(): Hash<number | string>;
}

interface KeyboardSupportItemInterface extends FocusableOption {
    keyDown: OutputEmitterRef<KeyboardEvent>;
    click(): void;
}

interface ModuleDeprecation {
    alternative: {
        name: string;
        link: string | string[];
        fragment?: string;
    };
    message: string;
}

type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
}[Keys];
type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
}[Keys];

declare class ResizeObserverDirective implements HasElementRef {
    /**
     * The reference to the Resize target element.
     **/
    readonly elementRef: ElementRef<HTMLElement>;
    /**
     * Observable that emits when the element is resized.
     * Use this for programmatic subscriptions.
     **/
    readonly resizeEvents$: rxjs.Observable<ResizeObserverEntry[]>;
    /**
     * When the element is resized, emits an array of ResizeObserverEntry objects.
     **/
    readonly resized: i0.OutputRef<ResizeObserverEntry[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeObserverDirective, "[fdkResizeObserver]", ["fdkResizeObserver"], {}, { "resized": "resized"; }, never, never, true, never>;
}

declare const FDK_SELECTABLE_ITEM_PROVIDER: InjectionToken<unknown>;

declare const DND_ITEM: InjectionToken<unknown>;
declare const DND_LIST: InjectionToken<unknown>;

interface DynamicComponentConfig {
    /** Data to pass along to the content through the dynamic component reference service. */
    data?: any;
    /** The container that the dynamic component is appended to. By default, it is appended to the body. */
    container?: HTMLElement | 'body';
    containerRef?: ViewContainerRef;
}

declare abstract class DynamicComponentContainer<T = TemplateRef<any> | Type<any>> {
    elementRef: ElementRef;
    protected _injector: Injector;
    /** @hidden */
    abstract portalOutlet: CdkPortalOutlet;
    /** @hidden Load received content */
    protected abstract _loadContent(): void;
    /** @hidden */
    childContent: Nullable<T>;
    /** @hidden */
    protected _componentRef: ComponentRef<any> | EmbeddedViewRef<any>;
    /** @hidden */
    protected _contentLoaded$: BehaviorSubject<boolean>;
    /** @hidden */
    protected constructor(elementRef: ElementRef, _injector: Injector);
    /** @hidden Load received content as component */
    protected _createFromComponent(content: Type<any>): void;
    /** @hidden Load received content as embedded view */
    protected _createFromTemplate(content: TemplateRef<any>, context: any): void;
}

declare class DynamicComponentInjector implements Injector {
    private _parentInjector;
    private _additionalTokens;
    /** @hidden */
    constructor(_parentInjector: Injector, _additionalTokens: WeakMap<any, any>);
    /**
     *
     * @param token
     * @param notFoundValue
     */
    get(token: any, notFoundValue?: any): void;
}

/**
 * Service used to dynamically generate components like dialogs/alerts/notifications
 */
declare class DynamicComponentService {
    private readonly _componentFactoryResolver;
    private readonly _applicationRef;
    private readonly _injector;
    private readonly _compiler;
    /** @hidden */
    constructor(_componentFactoryResolver: ComponentFactoryResolver, _applicationRef: ApplicationRef, _injector: Injector, _compiler: Compiler);
    /**
     * Function that creates dynamic component and injects services to allow communication between component and outside
     * @param content Type of the component content
     * @param componentType Type of component that should be rendered.
     * @param config Configuration that will be passed to the component.
     * @param inject  enables to provide preconfigured component injector and dependencies
     */
    createDynamicComponent<T>(content: TemplateRef<any> | Type<any> | string | Record<string, any>, componentType: Type<T>, config: DynamicComponentConfig, inject?: {
        injector?: Injector;
        services?: any[];
    }): ComponentRef<T>;
    /**
     * Function that creates dynamic component and injects services to allow communication between component and outside
     * @param content Type of the component content
     * @param moduleType Type of module that should be compiled.
     * @param componentType Type of component that should be rendered.
     * @param containerRef The container that the dynamic component is appended to.
     * @param injector enables to provide preconfigured component injector
     */
    createDynamicModule<M, C>(content: TemplateRef<any> | Type<any> | string | Record<string, any>, moduleType: Type<M> | NgModuleFactory<M>, componentType: Type<C>, containerRef: ViewContainerRef, injector?: Injector): Promise<ComponentRef<C>>;
    /** Function that destroys dynamic component */
    destroyComponent(componentRef: ComponentRef<any>): void;
    /** @hidden */
    private _createDependencyMap;
    /** @hidden */
    private _attachToContainer;
    /** @hidden */
    private _createComponent;
    /** @hidden */
    private _passExternalContent;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicComponentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicComponentService>;
}

/**
 * Creates provider for ConsumerClass
 */
declare function consumerProviderFactory<T = any>(ConsumerClass: new (injector: Injector, additionalConfig: Record<any, any> | undefined) => T, providedConfiguration?: Record<any, any>): Provider;

declare const pxToNum: (pixels: string) => number;
declare const toNativeElement: (element: HTMLElement | ElementRef) => HTMLElement;
/** Return elements capacity (width subtract by element padding)
 * @param element - HTMLelement or element reference
 * */
declare function getElementCapacity(element: HTMLElement | ElementRef): number;
/** Return elements width
 * @param element - HTMLelement or element reference
 * @param withMargin - weather to add element margins to width
 * */
declare function getElementWidth(element: HTMLElement | ElementRef, withMargin?: boolean): number;

/** Get document font size in pixels. */
declare function getDocumentFontSize(): number;

/**
 * RxJS wrapper for IntersectionObserver class.
 * @param target HTML element to spy on.
 * @param options @see {IntersectionObserverInit}
 * @returns {Observable} with observer entries.
 */
declare function intersectionObservable(target: Element, options?: IntersectionObserverInit): Observable<IntersectionObserverEntry[]>;

/** Determines whether provided value is valid content density */
declare function isValidContentDensity(size: any): size is ContentDensity;
/**
 * Determines if "compact" styles should be applied based on provided content density
 */
declare function isCompactDensity(size: ContentDensity): boolean;

/**
 * Function checks whether the passed number is odd.
 * @param number number to check.
 * @returns Boolean whether the number is odd.
 */
declare function isOdd(number: number): boolean;

declare class KeyUtil {
    /**
     * Function used to unify key identification across different browsers using KeyCodes
     *
     * @param event     - KeyboardEvent
     * @param keyCode   - event.key name matching W3C specification / (ASSCI char. codes)
     * */
    static isKeyCode(event: KeyboardEvent, keyCode: number | number[]): boolean;
    /**
     * Function used to unify key identification across different browsers
     *
     * @param event     - KeyboardEvent
     * @param keyType   - Type of key
     * */
    static isKeyType(event: KeyboardEvent, keyType: 'alphabetical' | 'numeric' | 'control' | 'ime'): boolean;
}

/**
 * Utility functions to replace lodash-es functionality with native JavaScript.
 */
/**
 * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned.
 * @param obj The object to query
 * @param path The path of the property to get
 * @param defaultValue The value returned if the resolved value is undefined
 * @returns The resolved value
 */
declare function get<TDefault = undefined>(obj: any, path: string | string[], defaultValue?: TDefault): TDefault extends undefined ? any : TDefault;
/**
 * Sets the value at path of object. If a portion of path doesn't exist, it's created.
 * @param obj The object to modify
 * @param path The path of the property to set
 * @param value The value to set
 * @returns The object
 */
declare function set<T = any>(obj: T, path: string | string[], value: any): T;
/**
 * Deep clones an object, handling functions and other non-cloneable values.
 * For objects with functions or class instances, it creates a new object and copies properties.
 * Observables and class instances are copied by reference to avoid circular reference issues.
 * @param obj The object to clone
 * @param seen WeakSet to track visited objects and prevent infinite recursion
 * @returns The cloned object
 */
declare function cloneDeep<T>(obj: T, seen?: WeakSet<WeakKey>): T;
/**
 * Deep merges two or more objects, with properties from source objects overwriting those in the target.
 * @param target The target object
 * @param sources The source objects
 * @returns The merged object
 */
declare function merge<T>(target: T, ...sources: Partial<T>[]): T;
/**
 * Merges two objects with a customizer function.
 * @param target The target object
 * @param source The source object
 * @param customizer The function to customize assigned values
 * @returns The merged object
 */
declare function mergeWith<T>(target: T, source: Partial<T>, customizer: (targetValue: any, sourceValue: any, key: string) => any): T;
/**
 * Creates an array of unique values from the given array.
 * @param array The array to inspect
 * @returns The new array of unique values
 */
declare function uniq<T>(array: T[]): T[];
/**
 * Creates an array of unique values from an array based on a property.
 * @param array The array to inspect
 * @param iteratee The iteratee invoked per element
 * @returns The new duplicate free array
 */
declare function uniqBy<T>(array: T[], iteratee: ((item: T) => any) | string): T[];
/**
 * Flattens an array a single level deep.
 * @param array The array to flatten
 * @returns The new flattened array
 */
declare function flatten<T>(array: T[][]): T[];
/**
 * Creates an object composed of keys generated from the results of running each element through iteratee.
 * The corresponding value of each key is the number of times the key was returned by iteratee.
 * @param array The array to iterate over
 * @param iteratee The iteratee to transform keys
 * @returns The composed aggregate object
 */
declare function countBy<T>(array: T[], iteratee: ((item: T) => any) | string): Record<string, number>;
/**
 * Concatenates arrays.
 * @param arrays The arrays to concatenate
 * @returns The new concatenated array
 */
declare function concat<T>(...arrays: (T | T[])[]): T[];
/**
 * Escapes HTML characters in a string.
 * Converts characters like <, >, &, ", and ' to their HTML entity equivalents.
 * @param str The string to escape
 * @returns The escaped string
 */
declare function escape(str: string): string;

/** Module deprecations provider */
declare function moduleDeprecationsProvider(classRef: any): Provider;
/** Module deprecations provider factory */
declare function moduleDeprecationsFactory(factory: FactorySansProvider): Provider;

/** Parse file size to bytes */
declare function parserFileSize(fileSize: string): number;

/** Get random number from 1 to 10. */
declare function getRandomColorAccent(): ColorAccent;

/**
 * Creates an array of numbers from 0 to n-1, optionally transformed by a map function.
 * Useful for iterating a fixed number of times in templates with `@for` or generating
 * transformed sequences.
 *
 * @param length The number of elements in the array
 * @param mapFn Optional function to transform each index into a value
 * @returns An array of numbers from 0 to n-1, or transformed values if mapFn is provided
 *
 * @example
 * // Simple iteration (returns [0, 1, 2])
 * range(3)
 *
 * // With transformation (returns ['Item 0', 'Item 1', 'Item 2'])
 * range(3, i => `Item ${i}`)
 *
 * // In component for template iteration:
 * readonly loadingRange = range(3);
 *
 * // In template:
 * @for (i of loadingRange; track i) {
 *   <div>Item {{ i }}</div>
 * }
 */
declare function range<T = number>(length: number, mapFn?: (index: number) => T): T[];

/**
 * RxJS wrapper for ResizeObserver class.
 * @param target HTML element to spy on.
 * @param options @see {ResizeObserverOptions}
 * @returns {Observable} with observer entries.
 */
declare function resizeObservable(target: Element, options?: ResizeObserverOptions): Observable<ResizeObserverEntry[]>;

/**
 * Function used to scroll specified element by some distance
 *
 * @param containerElement     - Container element scrolled
 * @param distanceToScroll     - Distance of scroll in px
 * */
declare function scrollTop(containerElement: Element, distanceToScroll: number): void;

/** Generate a UUID v4 */
declare function uuidv4(): string;

/**
 * Creates an observable that emits when the component is destroyed.
 * @param destroyRef
 */
declare const destroyObservable: (destroyRef?: DestroyRef) => Observable<void>;

/** @hidden */
interface DfsOptions<T> {
    children: string | ((item: T) => Array<T>);
    shouldVisit: (item: T) => boolean;
    postOrder: boolean;
}
/**
 * Depth-first search algorithm, which traverses a tree/graph/tree-like structure.
 * callback is called for each item in the collection. The order of the callback calls
 * depends on the options. By default, the algorithm is post-order, which means that
 * the callback is called for each item after its children have been visited.
 *
 * @param collection
 * @param callback
 * @param options
 */
declare function dfs<T>(collection: Array<T>, callback: (item: T) => void, options?: Partial<DfsOptions<T>>): void;

/**
 * Retrieves native element from ElementRef.
 */
declare function getNativeElement<T extends Element = HTMLElement>(element: {
    elementRef: ElementRef<T>;
} | T | ElementRef<T>): T;
/**
 * Checks whether object has element reference in it.
 */
declare function hasElementRef<T extends Element = HTMLElement>(something: any): something is {
    elementRef: ElementRef<T>;
};

/**
 * Utility type, that allows to track and select ranges of elements while using multi-selection.
 *
 * @usage
 * Imagine we have a simple list of checkboxes:
 * ```html
 * <input
 *  #checkboxInput
 *  *ngFor="let o of options; let idx = index"
 *  type="checkbox"
 *  [checked]="selectionModel.checked(o)"
 *  (click)="toggle(idx, $event)"
 *  >
 * ```
 * With the given layout the logic should be as follows:
 * ```typescript
 * export class YourComponent {
 *  options = ['a', 'b', 'c'];
 *  readonly selectionModel = new SelectionModel(true);
 *
 *  private readonly _rangeSelector = new RangeSelector();
 *
 *
 *  toggle(idx: number, event: PointerEvent): void {
 *      // getting the toggled value of the checkbox
 *      const toggledSelection = event.target.value;
 *
 *      // registering the selection of current checkbox
 *      this._rangeSelector.onRangeElementToggled(idx, event);
 *
 *      // Apply value to each element in range.
 *      // If checkbox was toggled without shift pressed or without previously selected one,
 *      // this method will select only it.
 *      this._rangeSelector.applyValueToEachInRange(idx => {
 *          if (toggledSelection) {
 *              this.selectionModel.select(options[idx]);
 *          } else {
 *              this.selectionModel.deselect(options[idx]);
 *          }
 *      });
 *  }
 * }
 * ```
 */
declare class RangeSelector {
    /** @hidden */
    private _previousSelectedIndex;
    /** @hidden */
    private _state;
    /**
     * Last registered selection state (either multiple or single).
     * Is updated on each `onRangeElementClicked` invokation. Will be `null` initially or once `reset()` is called.
     */
    get lastRangeSelectionState(): RangeSelectionState | null;
    /**
     * The method that should be used to register each checkbox toggle.
     * Accepts two arguments: `index` and `event`. If none provided, will reset existing state.
     * Otherwise will register current index as last checked.
     *
     * If toggling was done with "shift" pressed and there's a previously registered index, will register a range selection.
     * At the same time if checkbox was toggled without shift pressed or without previously selected one, this method will select only it.
     *
     * After calling this method it's recommended to use `applyValueToEachInRange` to actually toggle each checkbox in range.
     *
     * See usage example on this class itself.
     */
    onRangeElementToggled(index?: number, event?: KeyboardEvent | MouseEvent | TouchEvent): RangeSelectionState | null;
    /**
     * Allows to apply selection to each item in selection range.
     * Accepts a function to apply selection to each item by registered index.
     *
     * See usage example on this class itself.
     */
    applyValueToEachInRange(selectionMethod: (index: number) => void): void;
    /** Resets selection state. Useful when the list of selectable items is changed (e.g. by filtering, sorting, page change) */
    reset(): void;
    /** @hidden */
    private _isNonNegativeInteger;
}
interface RangeSelectionState {
    isRangeSelection: boolean;
    from: number;
    to: number;
}

/** @hidden */
declare function warnOnce(message: string): void;

declare const LIST_ITEM_COMPONENT: InjectionToken<string[]>;
interface ListItemInterface {
    selected: boolean;
    link: boolean;
    focus(): void;
}

type FdkAsyncProperty<T> = T | Observable<T> | Promise<T>;
declare class AsyncOrSyncPipe implements OnDestroy, PipeTransform {
    /** @hidden */
    private _cdr;
    /** @hidden */
    private _asyncPipe;
    /** @hidden */
    constructor(ref: ChangeDetectorRef);
    /**
     * Transforms raw async-like value into static one.
     * @param value raw value. Can be either a static value, or Promise-like, or Observable-like.
     */
    transform<T>(value: FdkAsyncProperty<T>): T | null;
    /** @Hidden */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncOrSyncPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AsyncOrSyncPipe, "fdkAsyncOrSync", true>;
}

declare class DisplayFnPipe implements PipeTransform {
    /** Transform value with display function. */
    transform(value: any, displayFn: any, ...args: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DisplayFnPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DisplayFnPipe, "displayFnPipe", true>;
}

declare class FilterStringsPipe implements PipeTransform {
    /**
     * Performs filtering.
     * @param values Array of items.
     * @param params Search parameters.
     */
    transform(values: any[] | undefined, params: {
        searchTerm: Nullable<string>;
        key: string;
    }): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterStringsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterStringsPipe, "fdFilterStrings", true>;
}

declare class IsCompactDensityPipe implements PipeTransform {
    /** Check if the content density is compact. */
    transform(size: ContentDensity): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsCompactDensityPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsCompactDensityPipe, "isCompactDensity", true>;
}

declare class MakeAsyncPipe implements PipeTransform {
    /**
     * Transforms raw value into observable.
     * @param value raw value. Can be either a static value, or Promise-like, or Observable-like.
     */
    transform<T>(value: T | Promise<T> | Observable<T>): Observable<T> | Promise<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MakeAsyncPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MakeAsyncPipe, "fdkMakeAsync", true>;
}

declare class SearchHighlightPipe implements PipeTransform {
    /** Highlight search term in string. */
    transform(value: string, matches: string | Array<[number, number]>, active?: boolean, includeSpans?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchHighlightPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SearchHighlightPipe, "highlight", true>;
}

declare class TwoDigitsPipe implements PipeTransform {
    /** Transform number to two digits. */
    transform(value: number, enable?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwoDigitsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TwoDigitsPipe, "twoDigits", true>;
}

declare class SafePipe implements PipeTransform {
    protected sanitizer: DomSanitizer;
    /** @hidden */
    constructor(sanitizer: DomSanitizer);
    /** Sanitize HTML string. */
    transform(value: any, type: string): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", true>;
}

declare class ValueByPathPipe implements PipeTransform {
    /** Get value by path. */
    transform(value: any, key: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ValueByPathPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ValueByPathPipe, "valueByPath", true>;
}

declare class TruncatePipe implements PipeTransform {
    /** Truncate string to given length. */
    transform(value: string, limit?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TruncatePipe, "truncate", true>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PipeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PipeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PipeModule, never, [typeof DisplayFnPipe, typeof SearchHighlightPipe, typeof TwoDigitsPipe, typeof SafePipe, typeof ValueByPathPipe, typeof IsCompactDensityPipe, typeof TruncatePipe, typeof FilterStringsPipe, typeof MakeAsyncPipe, typeof AsyncOrSyncPipe], [typeof DisplayFnPipe, typeof SearchHighlightPipe, typeof TwoDigitsPipe, typeof SafePipe, typeof ValueByPathPipe, typeof IsCompactDensityPipe, typeof TruncatePipe, typeof FilterStringsPipe, typeof MakeAsyncPipe, typeof AsyncOrSyncPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PipeModule>;
}

declare const DEFAULT_CONTENT_DENSITY: ContentDensity;
/**
 * Service taking care of ContentDensity
 */
declare class ContentDensityService {
    /** Content Density BehaviourSubject */
    readonly contentDensity: BehaviorSubject<ContentDensity>;
    /** @hidden */
    constructor();
    /** @hidden */
    get _contentDensityListener(): Observable<ContentDensity>;
    /** @hidden */
    get _isCompactDensity(): Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContentDensityService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ContentDensityService>;
}

declare class FocusTrapService {
    /** @hidden */
    private _focusTrapInstances;
    /**
     * Creates focus trap instance for defined element
     * @param element Container for which to create focus trap
     * @param userOptions Focus-trap specific configuration
     * @returns {string} Unique ID of focus trap instance
     */
    createFocusTrap(element: string | HTMLElement | SVGElement | (string | HTMLElement | SVGElement)[], userOptions?: Options): string;
    /**
     * Activates focus trap for defined ID
     * @param id Unique ID of focus trap instance
     */
    activateFocusTrap(id: string): void;
    /**
     * Deactivates focus trap for defined ID
     * @param id Unique ID of focus trap instance
     */
    deactivateFocusTrap(id: string): void;
    /**
     * Pauses current focus trap.
     */
    pauseCurrentFocusTrap(): void;
    /**
     * Unpauses current focus trap.
     */
    unpauseCurrentFocusTrap(): void;
    /**
     * Get focus trap instance by ID.
     * @param id ID of the instance.
     * @returns Focus trap instance if exists.
     */
    getFocusTrapInstance(id: string): FocusTrap | undefined;
    /** @hidden */
    private _getLastTrapedItem;
    /** @hidden */
    private _focusTrapExists;
    static ɵfac: i0.ɵɵFactoryDeclaration<FocusTrapService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FocusTrapService>;
}

type FocusEscapeDirection = 'up' | 'down';
declare class KeyboardSupportService<T> implements OnDestroy {
    /** Subject that is thrown, when focus escapes the list */
    focusEscapeList: Subject<FocusEscapeDirection>;
    /** @hidden  */
    private readonly _destroyRef;
    /** An RxJS Subject that will kill the data stream upon queryList changes (for unsubscribing)  */
    private readonly _onRefresh$;
    /** @hidden */
    private _keyManager;
    /** @hidden */
    get keyManager(): FocusKeyManager<T>;
    /** @hidden
     * allow tab key navigation. default is true.
     */
    private _tabKeyNavigation;
    /** @hidden */
    setKeyboardService(queryList: QueryList<KeyboardSupportItemInterface & T>, wrap?: boolean, tabKeyNavigation?: boolean): void;
    /** @hidden */
    onKeyDown(event: KeyboardEvent): void;
    /** Destroys KeyboardSupportService dependencies */
    ngOnDestroy(): void;
    /** @hidden */
    private _refreshEscapeLogic;
    static ɵfac: i0.ɵɵFactoryDeclaration<KeyboardSupportService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KeyboardSupportService<any>>;
}

declare class LocalStorageService {
    /** @hidden */
    private _storage;
    /** @hidden */
    constructor();
    /** Get item from local storage. */
    get(key: string): any;
    /** Set item in local storage. */
    set(key: string, value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
}

declare class AttributeObserver implements OnDestroy {
    private _mutationObserverFactory;
    /** @Hidden */
    private readonly _observedElements;
    /** @hidden */
    constructor(_mutationObserverFactory: MutationObserverFactory);
    /** @hidden */
    ngOnDestroy(): void;
    /** @Hidden */
    observe(elementOrRef: Element | ElementRef<Element> | HasElementRef<Element>): Observable<MutationRecord[]>;
    /** @Hidden */
    unobserve(element: HasElementRef<Element> | Element | ElementRef<Element>): void;
    /** @hidden */
    private _observeElement;
    /** @Hidden */
    private _unobserveElement;
    /** @hidden */
    private _cleanupObserver;
    static ɵfac: i0.ɵɵFactoryDeclaration<AttributeObserver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AttributeObserver>;
}

declare class ResizeObserverFactory {
    /** Factory to create ResizeObserver if it's present in browser.  */
    create(callback: ResizeObserverCallback): ResizeObserver | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeObserverFactory>;
}
declare class ResizeObserverService implements OnDestroy {
    private _resizeObserverFactory;
    /** @hidden */
    private _observedElements;
    /** @hidden */
    constructor(_resizeObserverFactory: ResizeObserverFactory);
    /** @hidden */
    ngOnDestroy(): void;
    /** Observe the given element and emit whenever its size changes. */
    observe(elementOrRef: Element | ElementRef<Element>): Observable<ResizeObserverEntry[]>;
    /**
     * Observes the given element by using the existing MutationObserver if available, or creating a
     * new one if not.
     */
    private _observeElement;
    /**
     * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is
     * observing this element.
     */
    private _unobserveElement;
    /** Clean up the underlying MutationObserver for the specified element. */
    private _cleanupObserver;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeObserverService>;
}

/** Injection token for overriding RTL languages. */
declare const RTL_LANGUAGE: InjectionToken<string[]>;
/**
 * Service for managing RTL (Right-to-Left) state.
 *
 * Uses signals for reactive state management and is fully compatible with zoneless change detection.
 * The language list is used to determine if RTL should be enabled at startup based on the browser's language.
 * Users can override the default RTL languages by providing the `RTL_LANGUAGE` injection token.
 *
 * @example
 * ```typescript
 * // Reading RTL state
 * readonly isRtl = computed(() => this._rtlService.rtl());
 *
 * // Updating RTL state
 * this._rtlService.rtl.set(true);
 * ```
 */
declare class RtlService {
    /**
     * Writable signal for RTL state.
     *
     * Read the current value: `rtl()`
     * Set a new value: `rtl.set(value)`
     * Update based on current value: `rtl.update(current => !current)`
     */
    readonly rtl: WritableSignal<boolean>;
    /**
     * Signal for RTL value.
     * @deprecated Use `rtl()` instead. This alias will be removed in a future version.
     */
    get rtlSignal(): WritableSignal<boolean>;
    /** @hidden */
    private readonly _injectedRtlLanguages;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<RtlService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RtlService>;
}

interface ToastGlobalPosition {
    left?: string;
    right?: string;
    bottom?: string;
    top?: string;
    center: boolean;
    centerVertically?: boolean;
}
interface ToastGlobalConnectedPosition extends ConnectedPosition {
    boundTo: HTMLElement;
}
declare const toastConnectedTopPosition: ConnectedPosition;
declare const toastConnectedTopLeftPosition: ConnectedPosition;
declare const toastConnectedTopRightPosition: ConnectedPosition;
declare const toastConnectedBottomPosition: ConnectedPosition;
declare const toastConnectedBottomLeftPosition: ConnectedPosition;
declare const toastConnectedBottomRightPosition: ConnectedPosition;
/**
 * Base Toast Position class.
 */
declare abstract class BaseToastPosition {
    /**
     * Position strategy of the first item.
     */
    global: ToastGlobalPosition | ToastGlobalConnectedPosition;
    /**
     * Position strategy of the newly added items.
     */
    connected: ConnectedPosition;
    /**
     * Scroll strategy. Used when global position is bound to some HTML element on the page.
     */
    scrollPosition?: ScrollStrategy;
}
/**
 * Toast Position class.
 * The first item will pop from the top-center of the screen.
 * New items will stack after the first item.
 */
declare class ToastTopCenterPosition extends BaseToastPosition {
    /** @hidden */
    static global: ToastGlobalPosition;
    /** @hidden */
    static connected: ConnectedPosition;
}
/**
 * Toast Position class.
 * The first item will pop from the bottom-center of the screen.
 * New items will stack before first item.
 */
declare class ToastBottomCenterPosition extends BaseToastPosition {
    /** @hidden */
    static global: ToastGlobalPosition;
    /** @hidden */
    static connected: ConnectedPosition;
}
/**
 * Toast Position class.
 * The first item will pop from the top-left of the screen.
 * New items will stack after first item.
 */
declare class ToastTopLeftPosition extends ToastTopCenterPosition {
    /** @hidden */
    static global: {
        left: string;
        center: boolean;
        right?: string;
        bottom?: string;
        top?: string;
        centerVertically?: boolean;
    };
    /** @hidden */
    static connected: ConnectedPosition;
}
/**
 * Toast Position class.
 * The first item will pop from the top-right of the screen.
 * New items will stack after first item.
 */
declare class ToastTopRightPosition extends ToastTopCenterPosition {
    /** @hidden */
    static global: {
        right: string;
        center: boolean;
        left?: string;
        bottom?: string;
        top?: string;
        centerVertically?: boolean;
    };
    /** @hidden */
    static connected: ConnectedPosition;
}
/**
 * Toast Position class.
 * The first item will pop from the bottom-left of the screen.
 * New items will stack before first item.
 */
declare class ToastBottomLeftPosition extends ToastBottomCenterPosition {
    /** @hidden */
    static global: {
        left: string;
        center: boolean;
        right?: string;
        bottom?: string;
        top?: string;
        centerVertically?: boolean;
    };
    /** @hidden */
    static connected: ConnectedPosition;
}
/**
 * Toast Position class.
 * The first item will pop from the bottom-right of the screen.
 * New items will stack before first item.
 */
declare class ToastBottomRightPosition extends ToastBottomCenterPosition {
    /** @hidden */
    static global: {
        right: string;
        center: boolean;
        left?: string;
        bottom?: string;
        top?: string;
        centerVertically?: boolean;
    };
    /** @hidden */
    static connected: ConnectedPosition;
}

/**
 * Base Configuration class used when opening a Toast.
 */
declare class BaseToastConfig<T = any> {
    /**
     * Data being injected into the child component.
     */
    data?: T;
    /**
     * Aria-label for the message toast component element.
     */
    ariaLabel?: string;
    /**
     * Toast position strategy.
     */
    positionStrategy?: BaseToastPosition;
    /**
     * Toast minimum width.
     */
    minWidth?: number | string;
    /**
     * Toast maximum width.
     */
    maxWidth?: number | string;
    /**
     * Toast minimum height.
     */
    minHeight?: number | string;
    /**
     * Toast maximum height.
     */
    maxHeight?: number | string;
    /**
     * Toast width.
     */
    width?: number | string;
    /**
     * Toast height.
     */
    height?: number | string;
    /**
     * Toast ID.
     */
    id?: string;
    /** Whether the toast should be animated. */
    animated?: boolean | undefined;
}

interface ToastContainerComponent<P> {
    config: P;
    readonly onExit$: Subject<void>;
    readonly onEnter$: Subject<void>;
    overlayRef: OverlayRef;
    enter(): void;
    exit(): void;
    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
}

declare abstract class BaseToastRef<T = any, P = any, C extends ToastContainerComponent<P> = ToastContainerComponent<P>> {
    containerInstance: C;
    overlayRef: OverlayRef;
    positionStrategy: BaseToastPosition;
    /** The instance of the component is making up the content of the Toast. */
    instance: T;
    /** @hidden */
    _defaultPositionStrategy: boolean;
    /** @hidden
     * Used for flagging the toast as an anchor for all next appearing toasts.
     */
    _isAnchor: boolean;
    /**
     * @hidden
     * Subject for notifying the user that the Toast has been dismissed.
     */
    protected readonly _afterDismissed$: Subject<void>;
    /** @hidden */
    protected constructor(containerInstance: C, overlayRef: OverlayRef, positionStrategy: BaseToastPosition);
    /** Dismisses the Toast. */
    dismiss(): void;
    /** Gets an observable that is notified when the Toast is finished closing. */
    afterDismissed(): Observable<void>;
    /** Gets an observable that is notified when the Toast has opened and appeared. */
    afterOpened(): Observable<void>;
    /**
     * @hidden
     * Cleans up the DOM after closing.
     */
    protected _finishDismiss(): void;
}

interface ToastTextComponent {
    toastRef: BaseToastRef;
    message: string;
}

declare abstract class BaseToastService<P extends BaseToastConfig, C extends ToastContainerComponent<P> = ToastContainerComponent<P>> {
    /** Component for simple text toast. */
    protected abstract toastTextComponent: Type<ToastTextComponent>;
    /** Component for Toast Container. */
    protected abstract toastContainerComponent: Type<C>;
    /** Injection token for Toast Data. */
    protected abstract toastDataInjectionToken: InjectionToken<any>;
    /** Toast Position Strategy. */
    protected abstract toastPositionStrategy: BaseToastPosition;
    /** Toast default config. */
    protected abstract defaultConfig: P;
    /**
     * Opens a Toast with the provided configuration.
     * @param toast accepts string, Component or TemplateRef.
     */
    abstract open<T>(toast: string | Type<T> | TemplateRef<T>): BaseToastRef<ToastTextComponent | T | EmbeddedViewRef<T>, P>;
    abstract openFromString(message: string, config: P): BaseToastRef<ToastTextComponent, P>;
    /**
     * Opens a Toast with provided component inside.
     * @param component Component to render inside a Toast.
     * @param config Toast configuration.
     * @returns Toast reference.
     */
    abstract openFromComponent<T>(component: Type<T>, config: P): BaseToastRef<T, P>;
    /**
     * Opens a Toast with provided Template Reference.
     * @param template Template Reference to render inside a Toast.
     * @param config Toast configuration.
     * @returns Toast reference.
     */
    abstract openFromTemplate(template: TemplateRef<any>, config: P): BaseToastRef<EmbeddedViewRef<any>>;
    /**
     * Gets Toast Container providers.
     * @param config Toast Config.
     */
    protected abstract getContainerComponentProviders(config: P): StaticProvider[];
    /**
     * Gets Toast Content providers.
     * @param config Toast Config.
     * @param toastRef Toast Reference.
     */
    protected abstract getContentComponentProviders<T>(config: P, toastRef: BaseToastRef<T>): StaticProvider[];
    /**
     * Creates Toast Reference for provided container and overlay.
     * @param containerRef Container reference.
     * @param overlayRef Overlay Reference.
     * @param positionStrategy Position Strategy
     */
    protected abstract getToastRef<T>(containerRef: C, overlayRef: OverlayRef, positionStrategy: BaseToastPosition): BaseToastRef<T | EmbeddedViewRef<any>, P>;
    /**
     * @hidden
     * Array of all current toasts.
     */
    protected _toasts: BaseToastRef[];
    /**
     * @hidden
     */
    protected _toastsMap: Map<BaseToastPosition, BaseToastRef<any, any, ToastContainerComponent<any>>[]>;
    /** @hidden */
    protected readonly overlay: Overlay;
    /** @hidden */
    protected readonly injector: Injector;
    /** @hidden */
    private readonly _destroyRef;
    /**
     * Dismisses all Toasts.
     */
    hideAll(): void;
    /**
     * Returns `true` if there are some message toasts currently open. `False` otherwise.
     */
    hasOpenMessageToasts(): boolean;
    /**
     * Sets new position strategy for all Toast items.
     * @param newStrategy New Position Strategy
     */
    setNewPositionStrategy(newStrategy: BaseToastPosition): void;
    /**
     * @hidden
     * Places a new component or a template as the content of the Toast container.
     */
    protected _attach<T>(content: ComponentType$1<T> | TemplateRef<T>, userConfig?: P): BaseToastRef<T | EmbeddedViewRef<any>, P>;
    /**
     * Attaches the Toast container component to the overlay.
     */
    protected attachToastContainerComponent(overlayRef: OverlayRef, config: P): C;
    /**
     * Creates an injector to be used inside a Toast component.
     * @param config Config that was used to create the Toast.
     * @param toastRef Reference to the Toast.
     */
    protected createContentComponentInjector<T>(config: P, toastRef: BaseToastRef<T>): Injector;
    /**
     * Animates the old Toast out and the new one in.
     */
    protected animateToast<T>(toastRef: BaseToastRef<T | EmbeddedViewRef<any>, P>): void;
    /**
     * @hidden
     * Creates a new overlay and places it in the correct location.
     */
    private _createOverlay;
    /**
     * @hidden
     * @returns Initial Position Strategy of the Toast Overlay Reference.
     */
    private _getPositionStrategy;
    /**
     * @hidden
     * @param needlePosition
     * @private
     */
    private _getLastToastWithSamePosition;
    /**
     * @hidden
     * @param connectedElm element to connect with.
     * @param positionStrategy Position Strategy
     * @returns Flexible Connected Position Strategy for Overlay Reference.
     */
    private _composeFlexibleConnectedPosition;
    /**
     * @hidden
     * @returns Default Global Position for Overlay Reference.
     */
    private _composeGlobalPosition;
    /** @hidden */
    private _refreshOverlayPositions;
    /** @hidden */
    private _updateOverlayPositionStrategy;
    /**
     * @hidden
     * Updates the position of a current Overlay Reference.
     * @returns New Position Strategy.
     * @param toast Toast Reference
     */
    private _updatePositionStrategy;
    /** @hidden */
    private _isBoundGlobalPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseToastService<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BaseToastService<any, any>>;
}

interface ToastDurationDismissibleContainerComponent<P> extends ToastContainerComponent<P> {
    mouseover$: Subject<void>;
    mouseleave$: Subject<void>;
}

declare abstract class BaseToastContainerComponent<P extends BaseToastConfig = BaseToastConfig> extends BasePortalOutlet implements ToastContainerComponent<P> {
    config: P;
    /** Method, which is triggered when the Toast component is ready to be shown. Used to trigger animations. */
    abstract enter(): void;
    /** Method, which is triggered when the Toast component is ready to be removed. Used to trigger animations. */
    abstract exit(): void;
    /**
     * @hidden
     * The portal outlet inside this container into which the Toast content will be loaded.
     */
    readonly _portalOutlet: i0.Signal<CdkPortalOutlet>;
    /** Min width of the toast component. */
    readonly minWidth: string;
    /** Max width of the toast component. */
    readonly maxWidth: string;
    /** Width of the toast component. */
    readonly width: string;
    /** Min height of the toast component. */
    readonly minHeight: string;
    /** Max height of the toast component. */
    readonly maxHeight: string;
    /** Height of the toast component. */
    readonly height: string;
    /** Subject for notifying that the Toast has finished exiting from view. */
    readonly onExit$: Subject<void>;
    /** Subject for notifying that the Toast has finished entering the view. */
    readonly onEnter$: Subject<void>;
    /** Overlay reference */
    overlayRef: OverlayRef;
    /** Aria label. */
    readonly ariaLabel: string | undefined | null;
    /** ID of the Toast. */
    readonly id: string | undefined | null;
    /** @hidden */
    protected constructor(config: P);
    /**
     * Attaches component to the portal.
     */
    attachComponentPortal<C>(portal: ComponentPortal<C>): ComponentRef<C>;
    /**
     * Attaches Template to the portal.
     * @param portal
     */
    attachTemplatePortal<T>(portal: TemplatePortal<T>): EmbeddedViewRef<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseToastContainerComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseToastContainerComponent<any>, never, never, {}, {}, never, never, true, never>;
}

/**
 * Base configuration class used when opening a Toast which automatically destroys after some time.
 */
declare class BaseToastDurationDismissibleConfig<T = any> extends BaseToastConfig<T> {
    /**
     * The length of time in milliseconds to wait before automatically dismissing the Message Toast.
     */
    duration?: number | undefined;
    /**
     * Whether the message toast should stay visible if the cursor is over it.
     * Default is `true`
     */
    mousePersist?: boolean;
}

declare abstract class BaseToastAnimatedContainerComponent<P extends BaseToastConfig> extends BaseToastContainerComponent<P> implements OnDestroy {
    /** @hidden */
    private readonly _animated;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private _currentAnimation;
    /** @hidden */
    constructor(config: P);
    /** Begin animation of Message Toast entrance into view. */
    enter(): void;
    /** Begin animation of Message Toast removal. */
    exit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /**
     * @hidden
     * Defers the exit notification to the next microtask. Helps prevent
     * errors where we end up removing an element which is in the middle of an animation.
     */
    private _completeExit;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseToastAnimatedContainerComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseToastAnimatedContainerComponent<any>, never, never, {}, {}, never, never, true, never>;
}

declare abstract class BaseToastDurationDismissibleContainerComponent<P extends BaseToastConfig> extends BaseToastAnimatedContainerComponent<P> implements OnDestroy, ToastDurationDismissibleContainerComponent<P> {
    /** Subject for notifying that component is out of hover. */
    readonly mouseleave$: Subject<void>;
    /** Subject for notifying that component is hovered. */
    readonly mouseover$: Subject<void>;
    /** @Hidden */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseToastDurationDismissibleContainerComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseToastDurationDismissibleContainerComponent<any>, never, never, {}, {}, never, never, true, never>;
}

/**
 * Base toast reference for toasts that can be dismissed after a duration and support mouse hover persistence.
 * Extends BaseToastRef with timer management capabilities for auto-dismissing toasts.
 */
declare abstract class BaseToastDurationDismissibleRef<T = any, P extends BaseToastConfig<T> = any, C extends BaseToastDurationDismissibleContainerComponent<P> = BaseToastDurationDismissibleContainerComponent<P>> extends BaseToastRef<T, P, C> {
    /**
     * Timeout ID for the duration setTimeout call. Used to clear the timeout if the toast is
     * dismissed before the duration passes.
     */
    protected durationTimeoutId: ReturnType<typeof setTimeout>;
    /** Dismisses the toast and clears the timeout. */
    dismiss(): void;
    /** Dismisses the Toast component after some duration */
    dismissAfter(duration: number): void;
    /** Cancels current dismiss timeout */
    cancelDismiss(): void;
}

declare abstract class BaseDismissibleToastService<P extends BaseToastDurationDismissibleConfig, C extends BaseToastDurationDismissibleContainerComponent<P> = BaseToastDurationDismissibleContainerComponent<P>> extends BaseToastService<P, C> {
    /**
     * Animates the old Toast out and the new one in.
     */
    protected animateToast<T>(toastRef: BaseToastDurationDismissibleRef<T | EmbeddedViewRef<any>, P>): void;
}

declare const ModuleDeprecations: InjectionToken<ModuleDeprecation>;

/**
 * Injection token for the viewport size observable.
 * Emits the viewport size in pixels, which are outputted by the ViewportRuler
 * from @angular/cdk/overlay.
 */
declare const ViewportSizeObservable: InjectionToken<Observable<number>>;

/**
 * Helper function check whether passed data is a JS object (including function).
 */
declare function isJsObject(obj: any): obj is object | Function;
/**
 * Helper function checks whether passed value is not empty.
 */
declare function isPresent(obj: any): boolean;
/**
 * Helper function check whether passed value is empty.
 */
declare function isBlank(obj: any): obj is undefined | null;
/**
 * Helper function checks whether passed value is a boolean.
 */
declare function isBoolean(obj: any): obj is boolean;
/**
 * Helper function checks whether passed value is a valid number.
 */
declare function isNumber(obj: any): obj is number;
/**
 * Helper function checks whether passed value is a string.
 */
declare function isString(obj: any): obj is string;
/**
 * Helper function checks whether passed value is a function
 */
declare function isFunction(obj: any): boolean;
/** @hidden */
declare function isType(obj: any): obj is Function;
/**
 * Helper function checks whether passed value is a record of `T` values.
 */
declare function isStringMap<T = any>(obj: any): obj is Record<string, T>;
/**
 * Helper function checks whether passed value is an `object`.
 */
declare function isObject<T>(item: T): boolean;
/**
 * Helper function checks whether passed value is a promise.
 */
declare function isPromise<T = any>(obj: any): obj is Promise<T>;
/**
 * Helper function checks whether passed value is an Observable/Subscribable.
 */
declare function isSubscribable<T = any>(obj: any | Observable<T>): obj is Observable<T>;

export { ANY_LANGUAGE_LETTERS_GROUP_REGEX, ANY_LANGUAGE_LETTERS_REGEX, AbstractFdNgxClass, AsyncOrSyncPipe, AttributeObserver, AutoCompleteDirective, AutoCompleteModule, BaseDismissibleToastService, BaseToastConfig, BaseToastContainerComponent, BaseToastDurationDismissibleConfig, BaseToastDurationDismissibleContainerComponent, BaseToastDurationDismissibleRef, BaseToastPosition, BaseToastRef, BaseToastService, BreakpointDirective, BreakpointModule, ClickedBehaviorModule, ClickedBehaviorModuleForRootLoadedOnce, ClickedDirective, ContentDensityService, DECIMAL_NUMBER_UNICODE_GROUP_REGEX, DECIMAL_NUMBER_UNICODE_RANGE, DECIMAL_NUMBER_UNICODE_REGEX, DEFAULT_CONTENT_DENSITY, DND_ITEM, DND_LIST, DefaultReadonlyViewModifier, DeprecatedSelector, DisabledBehaviorDirective, DisabledBehaviorModule, DisabledObserver, DisplayFnPipe, DndItemDirective, DndKeyboardGroupDirective, DndKeyboardItemDirective, DndListDirective, DragAndDropModule, DynamicComponentContainer, DynamicComponentInjector, DynamicComponentService, DynamicPortalComponent, ELEMENT_REF_EXCEPTION, FDK_DISABLED_DIRECTIVE, FDK_FOCUSABLE_GRID_DIRECTIVE, FDK_FOCUSABLE_ITEM_DIRECTIVE, FDK_FOCUSABLE_LIST_DIRECTIVE, FDK_INDIRECT_FOCUSABLE_ITEM_ORDER, FDK_READONLY_DIRECTIVE, FDK_SELECTABLE_ITEM_PROVIDER, FD_DEPRECATED_DIRECTIVE_SELECTOR, FOCUSABLE_ITEM, FdkClickedProvider, FdkDisabledProvider, FdkReadonlyProvider, FilterStringsPipe, FocusKeyManagerHelpersModule, FocusKeyManagerItemDirective, FocusKeyManagerListDirective, FocusTrapService, FocusableGridDirective, FocusableGridModule, FocusableItemDirective, FocusableItemModule, FocusableListDirective, FocusableListModule, FocusableObserver, FunctionStrategy, INVALID_DATE_ERROR, IgnoreClickOnSelectionDirective, IgnoreClickOnSelectionDirectiveToken, IgnoreClickOnSelectionModule, IndirectFocusableItemDirective, IndirectFocusableListDirective, InitialFocusDirective, InitialFocusModule, IntersectionSpyDirective, IsCompactDensityPipe, KeyUtil, KeyboardSupportService, LETTERS_UNICODE_RANGE, LIST_ITEM_COMPONENT, LineClampDirective, LineClampModule, LineClampTargetDirective, LocalStorageService, MOBILE_CONFIG_ERROR, MakeAsyncPipe, ModuleDeprecations, OVERFLOW_PRIORITY_SCORE, ObservableStrategy, OnlyDigitsDirective, OnlyDigitsModule, OverflowListDirective, OverflowListItemDirective, OverflowListModule, PipeModule, PromiseStrategy, RTL_LANGUAGE, RangeSelector, ReadonlyBehaviorDirective, ReadonlyBehaviorModule, ReadonlyObserver, RepeatDirective, RepeatModule, ResizeDirective, ResizeHandleDirective, ResizeModule, ResizeObserverDirective, ResizeObserverFactory, ResizeObserverService, ResponsiveBreakpoints, RtlService, SafePipe, SearchHighlightPipe, SelectComponentRootToken, SelectableItemDirective, SelectableItemToken, SelectableListDirective, SelectableListModule, SelectionService, THEME_SWITCHER_ROUTER_MISSING_ERROR, TabbableElementService, TemplateDirective, TemplateModule, ToastBottomCenterPosition, ToastBottomLeftPosition, ToastBottomRightPosition, ToastTopCenterPosition, ToastTopLeftPosition, ToastTopRightPosition, TruncateDirective, TruncateModule, TruncatePipe, TruncatedTitleDirective, TwoDigitsPipe, UtilsModule, ValueByPathPipe, ValueStrategy, ViewportSizeObservable, alternateSetter, applyCssClass, applyCssStyle, cloneDeep, coerceArraySafe, coerceBoolean, coerceCssPixel, concat, consumerProviderFactory, countBy, deprecatedModelProvider, destroyObservable, dfs, elementClick$, escape, flatten, get, getBreakpointName, getDeprecatedModel, getDocumentFontSize, getElementCapacity, getElementWidth, getNativeElement, getRandomColorAccent, hasElementRef, intersectionObservable, isBlank, isBoolean, isCompactDensity, isFunction, isItemFocusable, isJsObject, isNumber, isObject, isOdd, isPresent, isPromise, isString, isStringMap, isSubscribable, isType, isValidContentDensity, merge, mergeWith, moduleDeprecationsFactory, moduleDeprecationsProvider, parserFileSize, provideFdkClicked, pxToNum, range, resizeObservable, scrollIntoView, scrollTop, selectStrategy, set, setDisabledState, setReadonlyState, toNativeElement, toastConnectedBottomLeftPosition, toastConnectedBottomPosition, toastConnectedBottomRightPosition, toastConnectedTopLeftPosition, toastConnectedTopPosition, toastConnectedTopRightPosition, uniq, uniqBy, uuidv4, warnOnce };
export type { AutoCompleteEvent, BreakpointName, CellFocusedEventAnnouncer, ColorAccent, ContentDensity, CssClassBuilder, CssStyleBuilder, DeprecatedSelectorModel, DisabledBehavior, DisabledViewModifier, DndItem, DragoverPredicate, DropPredicate, DynamicComponentConfig, ElementChord, ElementPosition, Enumerate, FdDndDropEventMode, FdDndDropType, FdDropEvent, FdkAsyncProperty, FocusEscapeDirection, FocusableCellPosition, FocusableItem, FocusableItemPosition, FocusableListItemFocusedEvent, FocusableListKeydownEvent, FocusableListPosition, HasElementRef, Hash, IntRange, KeyboardSupportItemInterface, LinkPosition, ListItemInterface, ModuleDeprecation, NestedKeyOf, Nullable, NullableObject, ObjectPathType, OverflowPriority, RangeSelectionState, ReadonlyBehavior, ReadonlyViewModifier, RequireAtLeastOne, RequireOnlyOne, ScrollPosition, SelectableListValueType, SelectionItemsList, Size, SubscriptionStrategy, ToastContainerComponent, ToastDurationDismissibleContainerComponent, ToastGlobalConnectedPosition, ToastGlobalPosition, ToastTextComponent };