@fundamental-ngx/cdk 0.56.5 → 0.57.0-rc.0

package/utils/index.d.ts

@@ -1,24 +1,3253 @@
-export * from './utils.module';
-export * from './abstract-fd-ngx-class';
-export * from './async-strategy';
-export * from './coercion/array';
-export * from './components';
-export * from './consts';
-export * from './datatypes';
-export * from './decorators';
-export * from './deprecated-selector.class';
-export * from './directives';
-export * from './directives/breakpoints/responsive-breakpoints';
-export * from './drag-and-drop';
-export * from './dynamic-component';
-export * from './functions';
-export * from './helpers';
-export * from './interfaces';
-export * from './list-item/list-item-utils';
-export * from './models/nullable';
-export * from './pipes';
-export * from './services';
-export * from './toast';
-export * from './tokens/module-deprecations.token';
-export * from './tokens/viewport-size.observable';
-export * from './typecheck';
+import * as i0 from '@angular/core';
+import { ElementRef, EventEmitter, DestroyRef, NgZone, InjectionToken, OnDestroy, Injector, OnChanges, AfterViewInit, SimpleChanges, AfterContentInit, Renderer2, QueryList, Signal, ChangeDetectorRef, OnInit, AfterContentChecked, TemplateRef, ViewContainerRef, ModuleWithProviders, Provider, EmbeddedViewRef, ComponentRef, ValueProvider, InputSignal, Type, ComponentFactoryResolver, ApplicationRef, Compiler, NgModuleFactory, FactorySansProvider, PipeTransform, StaticProvider } from '@angular/core';
+import { Observable, Subject, BehaviorSubject, ReplaySubject } 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 { MutationObserverFactory } from '@angular/cdk/observers';
+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 { AnimationTriggerMetadata } from '@angular/animations';
+import { ConnectedPosition, ScrollStrategy, OverlayRef, Overlay, ComponentType as ComponentType$1, OverlayContainer } 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 {
+    /** Whether the item is focusable. Default is true. */
+    set fdkFocusableItem(val: boolean);
+    get fdkFocusableItem(): boolean;
+    /** Function, which returns a string to be announced by screen-reader whenever an item which is in grid receives focus. */
+    cellFocusedEventAnnouncer: CellFocusedEventAnnouncer;
+    /** Event emitted when the cell receives focus, not being emitted when focus moves between item's children. */
+    readonly cellFocused: EventEmitter<FocusableItemPosition>;
+    /** Element reference. */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /** @hidden */
+    readonly keydown: Subject<KeyboardEvent>;
+    /** @hidden */
+    _position: FocusableItemPosition;
+    /** @hidden */
+    protected readonly _destroyRef: DestroyRef;
+    /** @hidden */
+    protected readonly _zone: NgZone;
+    /** @hidden */
+    private _focusable;
+    /** @hidden */
+    private _tabbableElements;
+    /** @hidden */
+    private _tabbable;
+    /** @hidden */
+    private _timerId;
+    /** @hidden */
+    private readonly _focusableObserver;
+    /** @hidden */
+    private readonly _tabbableElementService;
+    /** @hidden */
+    private readonly _liveAnnouncer;
+    /** @hidden */
+    private readonly _renderer2;
+    /** @hidden */
+    private readonly _document;
+    /** @hidden */
+    constructor();
+    /** @hidden */
+    element: () => HTMLElement;
+    /** @hidden */
+    isFocusable(): boolean;
+    /** @hidden */
+    focus(): void;
+    /** Set tabbable state */
+    setTabbable(state: boolean): void;
+    /** @hidden */
+    private _onFocusin;
+    /** @hidden */
+    private _onFocusout;
+    /** @hidden */
+    private _onKeydown;
+    /** @hidden */
+    private _enableTabbableElements;
+    /** @hidden */
+    private _disableTabbableElements;
+    /** @hidden */
+    private _defaultItemFocusedEventAnnouncer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusableItemDirective, "[fdkFocusableItem]", never, { "fdkFocusableItem": { "alias": "fdkFocusableItem"; "required": false; }; "cellFocusedEventAnnouncer": { "alias": "cellFocusedEventAnnouncer"; "required": false; }; }, { "cellFocused": "cellFocused"; }, never, never, true, never>;
+    static ngAcceptInputType_fdkFocusableItem: unknown;
+}
+
+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 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 FocusableObserver {
+    private _attributeObserver;
+    /** @hidden */
+    constructor(_attributeObserver: 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: BehaviorSubject<FocusableItem[]>;
+    /** @hidden */
+    _indirectChildrenMap: Map<FocusableItem, number | (() => number)>;
+    /** @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;
+}
+interface FocusableListKeydownEvent {
+    list: FocusableListDirective;
+    event: KeyboardEvent;
+    activeItemIndex: Nullable<number>;
+}
+interface ItemsQueryList<T> extends Iterable<T> {
+    changes: Observable<ItemsQueryList<T>>;
+    length: number;
+    toArray(): T[];
+    find(predicate: (item: T, index: number) => boolean): Nullable<T>;
+    get(index: number): Nullable<T>;
+    forEach(param: (item: T, index: number) => void): void;
+}
+declare class FocusableListDirective implements OnChanges, 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. */
+    navigationDirection: 'horizontal' | 'vertical' | 'grid';
+    /** Direction of the content. */
+    contentDirection: '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.
+     */
+    wrap: boolean;
+    /** Function, which returns a string to be announced by screen-reader whenever an row which is in grid receives focus. */
+    listFocusedEventAnnouncer: (position: FocusableListPosition) => string;
+    /** Event emitted when list's item focused, contains item's position info. */
+    readonly itemFocused: EventEmitter<FocusableListItemFocusedEvent>;
+    /** @hidden */
+    readonly _projectedFocusableItems: ItemsQueryList<FocusableItem>;
+    /** @hidden */
+    get _focusableItems(): ItemsQueryList<FocusableItem>;
+    /** @hidden */
+    _items: ItemsQueryList<FocusableItem> | undefined;
+    /** @hidden */
+    readonly _gridItemFocused$: Subject<FocusableItemPosition>;
+    /** @hidden */
+    readonly _gridListFocused$: Subject<FocusableListPosition>;
+    /** @hidden */
+    readonly _keydown$: Subject<FocusableListKeydownEvent>;
+    /** @hidden */
+    _isVisible: boolean;
+    /** @hidden */
+    protected readonly _destroyRef: DestroyRef;
+    /** @hidden */
+    protected _focusable: boolean;
+    /** @hidden */
+    private _gridPosition;
+    /** @hidden */
+    private _keyManager?;
+    /** @hidden */
+    private _tabbable;
+    /** @hidden */
+    private readonly _refreshItems$;
+    /** @hidden */
+    private readonly _refresh$;
+    /** @hidden */
+    private readonly _renderer;
+    /** @hidden */
+    private readonly _elementRef;
+    /** @hidden */
+    private readonly _liveAnnouncer;
+    /** @hidden */
+    private readonly _focusableObserver;
+    /** @hidden */
+    private readonly _document;
+    /** @hidden */
+    get _tabindex(): number;
+    /** @hidden */
+    constructor();
+    /** @hidden */
+    _onKeydown(event: KeyboardEvent): void;
+    /** @hidden */
+    _onFocus(): Promise<void>;
+    /** @hidden */
+    ngOnChanges(changes: SimpleChanges): void;
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /** Set items programmatically. */
+    setItems(items: ItemsQueryList<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; }; "contentDirection": { "alias": "contentDirection"; "required": false; }; "wrap": { "alias": "wrap"; "required": false; }; "listFocusedEventAnnouncer": { "alias": "listFocusedEventAnnouncer"; "required": false; }; }, { "itemFocused": "itemFocused"; }, ["_projectedFocusableItems"], never, true, never>;
+    static ngAcceptInputType_focusable: unknown;
+    static ngAcceptInputType_wrap: unknown;
+}
+
+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 */
+    _preventKeydown: boolean;
+    /** @hidden */
+    private readonly _destroyRef;
+    /** @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;
+    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"], never, true, never>;
+    static ngAcceptInputType_wrapHorizontally: unknown;
+}
+
+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 */
+    private readonly _initialClass;
+    /** @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>;
+}
+
+declare const RTL_LANGUAGE: InjectionToken<string[]>;
+declare class RtlService {
+    /** RTL value */
+    rtl: BehaviorSubject<boolean>;
+    /** Signal wrapper for RTL value. */
+    rtlSignal: Signal<boolean>;
+    /** @hidden */
+    constructor(injectedRtlLanguages: string[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtlService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RtlService>;
+}
+
+/**
+ * This directive is used to provide drag & drop with keyboard support.
+ * It should be used together with directive fdDndKeyboardItem.
+ */
+declare class DndKeyboardGroupDirective {
+    private readonly _cdr;
+    private readonly _rtlService;
+    /** 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 */
+    constructor(_cdr: ChangeDetectorRef, _rtlService: 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, [null, { optional: true; }]>;
+    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>;
+}
+
+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>;
+}
+
+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 OnChanges, AfterViewInit {
+    private readonly _elementRef;
+    /**
+     * Width in pixel for truncation of an element , by default
+     */
+    set fdkTruncateWidth(value: Nullable<number>);
+    /**
+     * Truncating state
+     */
+    fdkTruncateState: boolean;
+    /** @hidden */
+    private _customWidthCount;
+    /** @hidden */
+    private _truncateTarget;
+    /** @hidden
+     * saves default style of element before truncating
+     */
+    private _defaultStyle;
+    /** @hidden */
+    private takeDefaultStyleOnce;
+    /** @hidden
+     * truncation style for truncating element
+     */
+    private _truncationStyle;
+    /** @hidden */
+    constructor(_elementRef: ElementRef);
+    /**
+     * Root native element
+     */
+    get rootElement(): HTMLElement;
+    /**
+     * Method saves default style of target element before first truncate.
+     */
+    setDefaultStyle(): void;
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /** @hidden */
+    ngOnChanges(): void;
+    /** @hidden */
+    private _truncate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TruncateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TruncateDirective, "[fdkTruncate]", never, { "fdkTruncateWidth": { "alias": "fdkTruncateWidth"; "required": false; }; "fdkTruncateState": { "alias": "fdkTruncateState"; "required": false; }; }, {}, 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>;
+}
+
+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 implements OnChanges, AfterViewInit {
+    private readonly _elementRef;
+    /**
+     * Target text for clamping
+     */
+    fdLineClampTargetText: string;
+    /**
+     * Event with target instance for clamping
+     */
+    update: EventEmitter<LineClampTargetDirective>;
+    /** @hidden */
+    constructor(_elementRef: ElementRef);
+    /**
+     * Native element of clamping target
+     */
+    get targetElement(): HTMLElement;
+    /** @hidden */
+    ngOnChanges(): void;
+    /** @hidden */
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LineClampTargetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LineClampTargetDirective, "[fdkLineClampTarget], [fdLineClampTarget], [fd-lineclamp-target]", ["fdLineClampTarget"], { "fdLineClampTargetText": { "alias": "fdLineClampTargetText"; "required": false; }; }, { "update": "update"; }, never, never, true, never>;
+}
+declare class LineClampDirective implements OnChanges, AfterViewInit {
+    private readonly _elementRef;
+    private readonly _renderer;
+    /**
+     * Count lines for clamping
+     */
+    set fdLineClampLines(value: Nullable<number>);
+    /**
+     * Clamping state
+     */
+    fdLineclampState: boolean;
+    /**
+     * Event return count of lines from the target
+     */
+    lineCountUpdate: EventEmitter<number>;
+    /** @hidden */
+    private _lineClampTarget;
+    /** @hidden */
+    private _originalText;
+    /** @hidden */
+    private _isNativeSupport;
+    /** @hidden */
+    private _lineCount;
+    /** @hidden */
+    private viewportSize$;
+    /** @hidden */
+    private _destroyRef;
+    /** @hidden */
+    /**
+     * Root native element of clamping box
+     */
+    get rootElement(): HTMLElement;
+    /** @hidden */
+    constructor(_elementRef: ElementRef, _renderer: Renderer2);
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /** @hidden */
+    ngOnChanges(): void;
+    /** @hidden */
+    reset(): void;
+    /** @hidden */
+    refreshTarget(event: LineClampTargetDirective): void;
+    /** @hidden */
+    refreshClamp(): 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 native;
+    /** @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; }; "fdLineclampState": { "alias": "fdLineclampState"; "required": false; }; }, { "lineCountUpdate": "lineCountUpdate"; }, never, never, true, never>;
+}
+
+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;
+    private _ngZone;
+    /**
+     * @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 observer;
+    /** @hidden */
+    constructor(_el: ElementRef, _ngZone: NgZone);
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /**
+     * @description Get amount of extra items in current list
+     * */
+    getAmountOfExtraItems(): number;
+    /**
+     * @description Ensuring that calculations run in the Angular zone
+     */
+    calculateOverflow(): void;
+    private initResizeObserver;
+    /** @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>;
+}
+
+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.
+ */
+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>;
+}
+
+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;
+    private _rtlService;
+    /** 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 _direction$;
+    /** @hidden */
+    constructor(_elementRef: ElementRef<HTMLElement>, _rtlService: RtlService);
+    /** @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, [null, { optional: true; }]>;
+    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>;
+}
+
+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 {
+    templateRef: TemplateRef<any>;
+    /** Name of the template */
+    name: string;
+    /** @hidden */
+    constructor(templateRef: TemplateRef<any>);
+    /** @hidden */
+    getName(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateDirective, "[fdkTemplate]", never, { "name": { "alias": "fdkTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+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;
+    private readonly _zone;
+    /** @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>;
+}
+
+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
+     */
+    fdkClicked: Observable<MouseEvent | KeyboardEvent>;
+    /** @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 AfterViewInit, DisabledBehavior, DisabledViewModifier {
+    private _elementRef;
+    private _destroyRef;
+    private _clicked;
+    /** @hidden */
+    set fdkDisabled(value: BooleanInput);
+    get fdkDisabled(): boolean;
+    /**
+     * Whether to add `disabledClass` class to the element.
+     */
+    addDisabledClass: boolean;
+    /**
+     * Disabled css class to apply to the element.
+     */
+    disabledClass: string;
+    /** @hidden */
+    private _disabled;
+    /** @hidden */
+    private readonly _fdkDisableInput$;
+    /** @hidden */
+    constructor(_elementRef: ElementRef<HTMLElement>, _destroyRef: DestroyRef, _clicked: FdkClickedProvider);
+    /** @hidden */
+    setDisabledState: (isDisabled: boolean) => void;
+    /** @hidden */
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisabledBehaviorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DisabledBehaviorDirective, "[fdkDisabled]", never, { "fdkDisabled": { "alias": "fdkDisabled"; "required": false; }; "addDisabledClass": { "alias": "addDisabledClass"; "required": false; }; "disabledClass": { "alias": "disabledClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+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 {
+    private _attributeObserver;
+    /** @hidden */
+    constructor(_attributeObserver: 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 ngZone;
+    private elementRef;
+    private disabledObserver;
+    private selfDisabled$?;
+    private parentDisabled$?;
+    /** @Hidden */
+    fdkDisabled: boolean;
+    /** @Hidden */
+    private readonly _destroyRef;
+    /** @hidden */
+    private readonly _viewModifiers$;
+    /** @hidden */
+    private _disabledChange$;
+    /** @hidden */
+    constructor(ngZone: NgZone, elementRef: ElementRef<HTMLElement>, disabledObserver: DisabledObserver, 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, null, 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 ReadonlyObserver {
+    private _attributeObserver;
+    /** @Hidden */
+    constructor(_attributeObserver: 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>;
+}
+
+declare class FdkReadonlyProvider extends ReplaySubject<boolean> implements ReadonlyBehavior, OnDestroy {
+    private ngZone;
+    private elementRef;
+    private readonlyObserver;
+    private selfReadonly$;
+    private parentReadonly$;
+    /** @Hidden */
+    fdkReadonly: boolean;
+    /** @hidden */
+    private readonly _viewModifiers$;
+    /** @hidden */
+    private _readonlyChange$;
+    /** @hidden */
+    private readonly _destroyRef;
+    /** @hidden */
+    constructor(ngZone: NgZone, elementRef: ElementRef<Element>, readonlyObserver: ReadonlyObserver, 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, null, 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;
+}
+
+declare class ReadonlyBehaviorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReadonlyBehaviorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ReadonlyBehaviorModule, never, [typeof ReadonlyBehaviorDirective], [typeof ReadonlyBehaviorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ReadonlyBehaviorModule>;
+}
+
+/** @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>;
+}
+
+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 _ngZone;
+    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 _enabled$;
+    /** @hidden */
+    constructor(_elmRef: ElementRef<HTMLElement>, _ngZone: NgZone, _tabbableService: TabbableElementService);
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /**
+     * @hidden
+     * Executes a function when the zone is stable.
+     */
+    private _executeOnEmpty;
+    /**
+     * @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>;
+}
+
+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>;
+}
+
+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 {
+    private readonly _rtlService;
+    private readonly _cdr;
+    /** 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 _onDestroy$;
+    /** @hidden */
+    constructor(_rtlService: RtlService, _cdr: ChangeDetectorRef);
+    /** @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>, [{ optional: true; }, null]>;
+    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;
+}
+
+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>;
+}
+
+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: EventEmitter<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 {
+    /**
+     * When the element is resized, emits an array of ResizeObserverEntry objects.
+     **/
+    resized: Observable<ResizeObserverEntry[]>;
+    /**
+     * The reference to the Resize target element.
+     **/
+    elementRef: ElementRef<HTMLElement>;
+    /** @hidden */
+    private _resizeObserverService;
+    /** @hidden */
+    constructor();
+    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;
+}
+
+/** 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;
+
+/**
+ * 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>;
+}
+
+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>;
+}
+
+/**
+ * @deprecated Use Angular's built-in `DestroyRef` and `takeUntilDestroyed` instead.
+ * Will be removed in next release
+ */
+declare class DestroyedService extends ReplaySubject<void> implements OnDestroy {
+    /** @hidden */
+    constructor();
+    /** @hidden */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DestroyedService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DestroyedService>;
+}
+
+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 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>;
+}
+
+/**
+ * Animations used by the Toast components.
+ */
+declare const baseToastAnimations: {
+    readonly toastState: AnimationTriggerMetadata;
+};
+
+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;
+}
+/**
+ * Base Configuration class used when opening an animated Toast.
+ */
+declare class BaseAnimatedToastConfig<T = any> extends BaseToastConfig<T> {
+    /** 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>> {
+    overlay: Overlay;
+    injector: Injector;
+    /** 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 */
+    private _destroyRef;
+    /** @hidden */
+    protected constructor(overlay: Overlay, injector: Injector);
+    /**
+     * 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.
+     */
+    _portalOutlet: CdkPortalOutlet;
+    /** Min width of the toast component. */
+    minWidth?: string | number | null;
+    /** Max width of the toast component. */
+    maxWidth?: string | number | null;
+    /** Width of the toast component. */
+    width?: string | number | null;
+    /** Min height of the toast component. */
+    minHeight?: string | number | null;
+    /** Max height of the toast component. */
+    maxHeight?: string | number | null;
+    /** Height of the toast component. */
+    height?: string | number | null;
+    /** 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. */
+    ariaLabel: Nullable<string>;
+    /** ID of the Toast. */
+    id: Nullable<string>;
+    /** @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>;
+}
+
+declare abstract class BaseToastAnimatedContainerComponent<P extends BaseAnimatedToastConfig> extends BaseToastContainerComponent<P> implements OnDestroy {
+    /**
+     * @hidden
+     * The state of the Message Toast animations.
+     */
+    private get _animationState();
+    /**
+     * @hidden
+     * Whether the animations should be disabled.
+     */
+    private _animationsDisabled;
+    /** @hidden */
+    protected _ngZone: NgZone;
+    /** @hidden */
+    private _animationStateSignal;
+    /** @hidden */
+    constructor(config: P);
+    /**
+     * @hidden
+     * Handle end of animations, updating the state of the Message Toast.
+     */
+    private _onAnimationEnd;
+    /** Begin animation of Message Toast entrance into view. */
+    enter(): void;
+    /** Begin animation of Message Toast removal. */
+    exit(): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    /**
+     * @hidden
+     * Waits for the zone to settle before removing the element. 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>;
+    /** Emits mouseleave$ subject when component is out of hover. */
+    onMouseLeave(): void;
+    /** Emits mouseover$ subject when component is hovered. */
+    onMouseOver(): void;
+    /** @Hidden */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseToastDurationDismissibleContainerComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseToastDurationDismissibleContainerComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+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>;
+    /** @hidden */
+    protected constructor(containerInstance: C, overlayRef: OverlayRef, positionStrategy: BaseToastPosition);
+    /** 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 BaseToastActionDismissibleRef<T = any, P extends BaseToastConfig<T> = any> extends BaseToastDurationDismissibleRef<T, P> {
+    /** Subject for notifying the user that the Toast action-dismissible was called. */
+    protected readonly onAction$: Subject<string | null>;
+    /** Whether the Toast was dismissed using the action-dismissible button. */
+    protected dismissedByAction: boolean;
+    /** @hidden */
+    protected constructor(containerInstance: BaseToastDurationDismissibleContainerComponent<P>, overlayRef: OverlayRef, positionStrategy: BaseToastPosition);
+    /** Marks the Toast action-dismissible clicked. */
+    dismissWithAction(reason?: string | null): void;
+    /** Gets an observable that is notified when the Toast action-dismissible is called. */
+    onAction(): Observable<string | null>;
+    /**
+     * @hidden
+     * Cleans up the DOM after closing.
+     */
+    protected _finishDismiss(): void;
+}
+
+/**
+ * Custom overlay container for CDK Overlay.
+ */
+declare class BaseToastOverlayContainer extends OverlayContainer {
+    /**
+     * This method returns the overlay container element. It will lazily
+     * create the element the first time it is called to facilitate using
+     * the container in non-browser environments.
+     * @returns the container element
+     */
+    getContainerElement(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseToastOverlayContainer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseToastOverlayContainer>;
+}
+
+/**
+ * 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 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, BaseAnimatedToastConfig, BaseDismissibleToastService, BaseToastActionDismissibleRef, BaseToastConfig, BaseToastContainerComponent, BaseToastDurationDismissibleConfig, BaseToastDurationDismissibleContainerComponent, BaseToastDurationDismissibleRef, BaseToastOverlayContainer, 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, DestroyedService, 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, baseToastAnimations, coerceArraySafe, coerceBoolean, coerceCssPixel, consumerProviderFactory, deprecatedModelProvider, destroyObservable, dfs, elementClick$, 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, moduleDeprecationsFactory, moduleDeprecationsProvider, parserFileSize, provideFdkClicked, pxToNum, resizeObservable, scrollIntoView, scrollTop, selectStrategy, setDisabledState, setReadonlyState, toNativeElement, toastConnectedBottomLeftPosition, toastConnectedBottomPosition, toastConnectedBottomRightPosition, toastConnectedTopLeftPosition, toastConnectedTopPosition, toastConnectedTopRightPosition, 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, ItemsQueryList, KeyboardSupportItemInterface, LinkPosition, ListItemInterface, ModuleDeprecation, NestedKeyOf, Nullable, NullableObject, ObjectPathType, OverflowPriority, RangeSelectionState, ReadonlyBehavior, ReadonlyViewModifier, RequireAtLeastOne, RequireOnlyOne, ScrollPosition, SelectableListValueType, SelectionItemsList, Size, SubscriptionStrategy, ToastContainerComponent, ToastDurationDismissibleContainerComponent, ToastGlobalConnectedPosition, ToastGlobalPosition, ToastTextComponent };