@fundamental-ngx/cdk 0.38.3-rc.4

package/utils/datatypes/color-accent.datatype.d.ts

@@ -0,0 +1 @@
+export declare type ColorAccent = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;

package/utils/datatypes/hash.datatype.d.ts

@@ -0,0 +1,3 @@
+export declare type Hash<valueType> = {
+    [key in string | number]: valueType;
+};

package/utils/datatypes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hash.datatype';
+export * from './size.datatype';
+export * from './color-accent.datatype';

package/utils/datatypes/size.datatype.d.ts

@@ -0,0 +1 @@
+export declare type Size = 'xs' | 's' | 'm' | 'l' | 'xl';

package/utils/decorators/apply-css-class.decorator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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
+ */
+export declare function applyCssClass(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;

package/utils/decorators/apply-css-style.decorator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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
+ */
+export declare function applyCssStyle(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;

package/utils/decorators/coerce-boolean.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Decorator for coercing passed value to boolean, using @angular/cdk coerceBooleanProperty
+ */
+export declare const coerceBoolean: PropertyDecorator;

package/utils/decorators/coerce-css-pixel.d.ts

@@ -0,0 +1 @@
+export declare const coerceCssPixel: PropertyDecorator;

package/utils/decorators/index.d.ts

@@ -0,0 +1,5 @@
+export * from './apply-css-class.decorator';
+export * from './apply-css-style.decorator';
+export * from './coerce-boolean';
+export * from './coerce-css-pixel';
+export * from './setter-alternator';

package/utils/decorators/setter-alternator.d.ts

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

package/utils/deprecated-selector.class.d.ts

@@ -0,0 +1,14 @@
+import { InjectionToken } from '@angular/core';
+export interface DeprecatedSelectorModel {
+    deprecated: string;
+    current: string;
+}
+/** @hidden */
+export declare function getDeprecatedModel(current: string, deprecated: string): DeprecatedSelectorModel;
+export declare const FD_DEPRECATED_DIRECTIVE_SELECTOR: InjectionToken<DeprecatedSelectorModel>;
+export declare abstract class DeprecatedSelector {
+    /** @hidden */
+    protected _selectors: DeprecatedSelectorModel | null;
+    /** @hidden */
+    constructor();
+}

package/utils/directives/auto-complete/auto-complete.directive.d.ts

@@ -0,0 +1,58 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export interface AutoCompleteEvent {
+    term: string;
+    forceClose: boolean;
+}
+export declare class DeprecatedAutoCompleteDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedAutoCompleteDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedAutoCompleteDirective, "[fdAutoComplete], [fd-auto-complete]", never, {}, {}, never, never, true, never>;
+}
+export declare class AutoCompleteDirective {
+    private _elementRef;
+    /** 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 */
+    constructor(_elementRef: ElementRef);
+    /** @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], [fdAutoComplete], [fd-auto-complete]", never, { "options": "options"; "inputText": "inputText"; "enable": "enable"; "displayFn": "displayFn"; }, { "onComplete": "onComplete"; }, never, never, true, never>;
+}

package/utils/directives/auto-complete/auto-complete.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./auto-complete.directive";
+export declare class AutoCompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoCompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AutoCompleteModule, never, [typeof i1.AutoCompleteDirective, typeof i1.DeprecatedAutoCompleteDirective], [typeof i1.AutoCompleteDirective, typeof i1.DeprecatedAutoCompleteDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AutoCompleteModule>;
+}

package/utils/directives/clicked/clicked-behavior.module.d.ts

@@ -0,0 +1,12 @@
+import { ModuleWithProviders } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./clicked.directive";
+export declare class ClickedBehaviorModule {
+    /** @hidden */
+    constructor(clickedBehaviorModuleForRootLoadedOnce: boolean);
+    /** @hidden */
+    static forRoot(): ModuleWithProviders<ClickedBehaviorModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickedBehaviorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClickedBehaviorModule, [typeof i1.ClickedDirective], never, [typeof i1.ClickedDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClickedBehaviorModule>;
+}

package/utils/directives/clicked/clicked-event.plugin.d.ts

@@ -0,0 +1,22 @@
+import * as i0 from "@angular/core";
+declare type EventHandlerFunction = ($event: Event) => void;
+declare type HandlerRemoveFunction = () => void;
+export declare class ClickedEventPlugin {
+    private document;
+    private platformId;
+    /** @hidden */
+    constructor(document: Document, platformId: any);
+    /** @hidden */
+    addEventListener(element: HTMLElement, eventName: string, handler: EventHandlerFunction): ($event: Event) => void;
+    /** @hidden */
+    addGlobalEventListener(higherOrderElement: string, eventName: string, handler: EventHandlerFunction): HandlerRemoveFunction;
+    /** @hidden */
+    supports(eventName: string): boolean;
+    /** @hidden */
+    private _parseHigherOrderElement;
+    /** @hidden */
+    private _setupEventBinding;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickedEventPlugin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClickedEventPlugin>;
+}
+export {};

package/utils/directives/clicked/clicked.directive.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedClickedDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedClickedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedClickedDirective, "[fnClicked]", never, {}, {}, never, never, true, never>;
+}
+export declare class ClickedDirective {
+    /**
+     * Event name.
+     */
+    static eventName: string;
+    /**
+     * FdkClicked output. Sole purpose of existence of this directive is to just silence Angular Language Service.
+     * This is only viable solution, since NO_ERRORS_SCHEMA silences everything and valuable exception might slip
+     * through your eyes.
+     */
+    fdkClicked: Observable<MouseEvent | KeyboardEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickedDirective, "[fdkClicked]", never, {}, { "fdkClicked": "fdkClicked"; }, never, never, false, never>;
+}

package/utils/directives/clicked/fdk-clicked-provider.service.d.ts

@@ -0,0 +1,24 @@
+import { ElementRef, OnDestroy, Renderer2 } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FdkClickedProvider extends Subject<MouseEvent | KeyboardEvent> implements OnDestroy {
+    private _elementRef;
+    private _renderer;
+    private eventManagerPlugins;
+    /** @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>;
+}

package/utils/directives/clicked/index.d.ts

@@ -0,0 +1,3 @@
+export * from './clicked-behavior.module';
+export * from './clicked.directive';
+export * from './fdk-clicked-provider.service';

package/utils/directives/disabled/default-disabled-view-modifier.d.ts

@@ -0,0 +1,9 @@
+import { ElementRef } from '@angular/core';
+import { DisabledViewModifier } from './disabled-view-modifier.interface';
+export declare class DefaultDisabledViewModifier implements DisabledViewModifier {
+    private elementRef;
+    /** @hidden */
+    constructor(elementRef: ElementRef<Element>);
+    /** @hidden */
+    setDisabledState: (isDisabled: boolean) => void;
+}

package/utils/directives/disabled/disabled-behavior.directive.d.ts

@@ -0,0 +1,35 @@
+import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ReplaySubject } from 'rxjs';
+import { DisabledBehavior } from './disabled-behavior.interface';
+import { DisabledViewModifier } from './disabled-view-modifier.interface';
+import { FdkClickedProvider } from '../clicked';
+import { DestroyedService } from '../../services/destroyed.service';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedDisabledBehaviorDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedDisabledBehaviorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedDisabledBehaviorDirective, "[fnDisabled]", never, {}, {}, never, never, true, never>;
+}
+export declare class DisabledBehaviorDirective extends ReplaySubject<boolean> implements OnDestroy, AfterViewInit, DisabledBehavior, DisabledViewModifier {
+    private _elementRef;
+    private _destroy$;
+    private _clicked;
+    /** @hidden */
+    set fdkDisabled(value: BooleanInput);
+    get fdkDisabled(): boolean;
+    /** @hidden */
+    private _disabled;
+    /** @hidden */
+    private readonly _fdkDisableInput$;
+    /** @hidden */
+    constructor(_elementRef: ElementRef<HTMLElement>, _destroy$: DestroyedService, _clicked: FdkClickedProvider);
+    /** @hidden */
+    setDisabledState: (isDisabled: boolean) => void;
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisabledBehaviorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DisabledBehaviorDirective, "[fdkDisabled]", never, { "fdkDisabled": "fdkDisabled"; }, {}, never, never, true, never>;
+}

package/utils/directives/disabled/disabled-behavior.interface.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+import { DisabledViewModifier } from './disabled-view-modifier.interface';
+declare type Base = Observable<boolean> & DisabledViewModifier;
+export interface DisabledBehavior extends Base {
+    fdkDisabled: boolean;
+}
+export {};

package/utils/directives/disabled/disabled-behavior.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./disabled-behavior.directive";
+export declare class DisabledBehaviorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisabledBehaviorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DisabledBehaviorModule, never, [typeof i1.DisabledBehaviorDirective, typeof i1.DeprecatedDisabledBehaviorDirective], [typeof i1.DisabledBehaviorDirective, typeof i1.DeprecatedDisabledBehaviorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DisabledBehaviorModule>;
+}

package/utils/directives/disabled/disabled-view-modifier.interface.d.ts

@@ -0,0 +1,3 @@
+export interface DisabledViewModifier {
+    setDisabledState: (isDisabled: boolean) => void;
+}

package/utils/directives/disabled/disabled.observer.d.ts

@@ -0,0 +1,18 @@
+import { ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { HasElementRef } from '../../interfaces/has-element-ref.interface';
+import { AttributeObserver } from '../../services/observers/attribute.observer';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/utils/directives/disabled/fdk-disabled-provider.service.d.ts

@@ -0,0 +1,35 @@
+import { ElementRef, NgZone, OnDestroy } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { DisabledObserver } from './disabled.observer';
+import { DisabledBehavior } from './disabled-behavior.interface';
+import { DisabledViewModifier } from './disabled-view-modifier.interface';
+import * as i0 from "@angular/core";
+export 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 _destroy$;
+    /** @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>;
+}

package/utils/directives/disabled/fdk-disabled.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { DisabledBehavior } from './disabled-behavior.interface';
+export declare const FDK_DISABLED_DIRECTIVE: InjectionToken<DisabledBehavior>;

package/utils/directives/disabled/index.d.ts

@@ -0,0 +1,8 @@
+export * from './disabled-behavior.directive';
+export * from './disabled-behavior.module';
+export * from './set-disabled-state';
+export * from './disabled-behavior.interface';
+export * from './disabled-view-modifier.interface';
+export * from './disabled.observer';
+export * from './fdk-disabled.token';
+export * from './fdk-disabled-provider.service';

package/utils/directives/disabled/set-disabled-state.d.ts

@@ -0,0 +1,4 @@
+import { ElementRef } from '@angular/core';
+import { HasElementRef } from '../../interfaces/has-element-ref.interface';
+/** @hidden */
+export declare function setDisabledState(element: HasElementRef<Element> | Element | ElementRef<Element>, isDisabled: boolean): void;

package/utils/directives/focus-key-manager/focus-key-manager-helpers.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./focus-key-manager-item.directive";
+import * as i2 from "./focus-key-manager-list.directive";
+export declare class FocusKeyManagerHelpersModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusKeyManagerHelpersModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FocusKeyManagerHelpersModule, never, [typeof i1.FocusKeyManagerItemDirective, typeof i2.FocusKeyManagerListDirective, typeof i1.DeprecatedFocusKeyManagerItemDirective, typeof i2.DeprecatedFocusKeyManagerListDirective], [typeof i1.FocusKeyManagerItemDirective, typeof i2.FocusKeyManagerListDirective, typeof i1.DeprecatedFocusKeyManagerItemDirective, typeof i2.DeprecatedFocusKeyManagerListDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FocusKeyManagerHelpersModule>;
+}

package/utils/directives/focus-key-manager/focus-key-manager-item.directive.d.ts

@@ -0,0 +1,37 @@
+import { FocusableOption } from '@angular/cdk/a11y';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ElementRef } from '@angular/core';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import { FocusKeyManagerListDirective } from './focus-key-manager-list.directive';
+import * as i0 from "@angular/core";
+export declare class DeprecatedFocusKeyManagerItemDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedFocusKeyManagerItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedFocusKeyManagerItemDirective, "[fd-focus-key-manager-item], [fdFocusKeyManagerItem]", never, {}, {}, never, never, true, never>;
+}
+/** Directive to apply Angular Material FocusKeyManager to lists.
+ * To be used with FocusKeyManagerItemDirective
+ */
+export declare class FocusKeyManagerItemDirective implements FocusableOption {
+    private readonly _list;
+    private readonly _elRef;
+    /** Whether item should be initially focused */
+    set initialFocus(value: BooleanInput);
+    /** @hidden */
+    get _tabindex(): number;
+    /** @hidden */
+    private _initialFocus;
+    /** 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], [fd-focus-key-manager-item], [fdFocusKeyManagerItem]", never, { "initialFocus": "initialFocus"; "_tabindex": "_tabindex"; }, {}, never, never, true, never>;
+}

package/utils/directives/focus-key-manager/focus-key-manager-list.directive.d.ts

@@ -0,0 +1,42 @@
+import { FocusableOption, FocusKeyManager } from '@angular/cdk/a11y';
+import { AfterContentInit, ChangeDetectorRef, OnChanges, OnDestroy, QueryList, SimpleChanges } from '@angular/core';
+import { RtlService } from '../../services/rtl.service';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedFocusKeyManagerListDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedFocusKeyManagerListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedFocusKeyManagerListDirective, "[fd-focus-key-manager-list], [fdFocusKeyManagerList]", never, {}, {}, never, never, true, never>;
+}
+/** Directive to apply Angular Material FocusKeyManager to lists.
+ * To be used with FocusKeyManagerItemDirective
+ */
+export declare class FocusKeyManagerListDirective implements OnChanges, AfterContentInit, OnDestroy {
+    private readonly _rtlService;
+    private readonly _cdr;
+    /** Orientation for the FocusKeyManager */
+    orientation: 'horizontal' | 'vertical';
+    /** Skip predicate for the FocusKeyManager */
+    skipPredicate: (item: Record<any, any> & FocusableOption) => boolean;
+    /** @hidden */
+    readonly _items: QueryList<FocusableOption>;
+    /** @hidden */
+    get focusKeyManager(): FocusKeyManager<FocusableOption>;
+    /** @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 | FocusableOption): any;
+    /** @hidden */
+    private _applyOrientation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusKeyManagerListDirective, [{ optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusKeyManagerListDirective, "[fdkFocusKeyManagerList], [fd-focus-key-manager-list], [fdFocusKeyManagerList]", never, { "orientation": "orientation"; "skipPredicate": "skipPredicate"; }, {}, ["_items"], never, true, never>;
+}

package/utils/directives/focus-key-manager/focus-key-manager.tokens.d.ts

@@ -0,0 +1,3 @@
+import { FocusableOption } from '@angular/cdk/a11y';
+import { InjectionToken } from '@angular/core';
+export declare const FOCUSABLE_ITEM: InjectionToken<FocusableOption>;

package/utils/directives/focus-key-manager/index.d.ts

@@ -0,0 +1,4 @@
+export * from './focus-key-manager-helpers.module';
+export * from './focus-key-manager-item.directive';
+export * from './focus-key-manager-list.directive';
+export * from './focus-key-manager.tokens';

package/utils/directives/focusable-item/default-focusable-item-view-modifier.d.ts

@@ -0,0 +1,11 @@
+import { ElementRef } from '@angular/core';
+import { FocusableItemViewModifier } from './focusable-item-view-modifier.interface';
+export declare class DefaultFocusableItemViewModifier implements FocusableItemViewModifier {
+    private elementRef;
+    /** @hidden */
+    constructor(elementRef: ElementRef<Element>);
+    /**
+     * Sets tabindex attribute value depending on whether element is focusable.
+     */
+    setFocusable(isFocusable: boolean): void;
+}

package/utils/directives/focusable-item/fdk-focusable-item-provider.service.d.ts

@@ -0,0 +1,43 @@
+import { ElementRef, NgZone, OnDestroy } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { FocusableItemViewModifier } from './focusable-item-view-modifier.interface';
+import { FocusableItemDirective } from './focusable-item.directive';
+import { FocusableObserver } from './focusable.observer';
+import * as i0 from "@angular/core";
+export declare class FdkFocusableItemProvider extends ReplaySubject<boolean> implements FocusableItemViewModifier, OnDestroy {
+    private ngZone;
+    private elementRef;
+    private focusableObserver;
+    private selfFocusable$?;
+    private parentFocusable$?;
+    /** @hidden */
+    focusable: boolean;
+    /** @hidden */
+    private readonly _viewModifiers$;
+    /** @hidden */
+    private readonly _focusableChange$;
+    /** @hidden */
+    private _focusableObserver$;
+    /** @hidden */
+    private readonly _destroy$;
+    /** @hidden */
+    constructor(ngZone: NgZone, elementRef: ElementRef<HTMLElement>, focusableObserver: FocusableObserver, selfFocusable$?: FocusableItemDirective | undefined, parentFocusable$?: FocusableItemDirective | undefined);
+    /** @hidden */
+    ngOnDestroy(): void;
+    /**
+     * Adds view modifier
+     * @param modifier
+     */
+    addViewModifier(modifier: FocusableItemViewModifier): void;
+    /**
+     * Sets focusable state of the element.
+     * @param isReadonly
+     */
+    setFocusable(isReadonly: boolean): void;
+    /** @hidden */
+    private _getInitialViewModifiers;
+    /** @hidden */
+    private _getFocusableChange$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FdkFocusableItemProvider, [null, null, null, { optional: true; self: true; }, { optional: true; skipSelf: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FdkFocusableItemProvider>;
+}

package/utils/directives/focusable-item/focusable-item-view-modifier.interface.d.ts

@@ -0,0 +1,3 @@
+export interface FocusableItemViewModifier {
+    setFocusable: (isFocusable: boolean) => void;
+}

package/utils/directives/focusable-item/focusable-item.directive.d.ts

@@ -0,0 +1,37 @@
+import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ReplaySubject } from 'rxjs';
+import { FocusableItemViewModifier } from './focusable-item-view-modifier.interface';
+import { FocusableObserver } from './focusable.observer';
+import { DestroyedService } from '../../services/destroyed.service';
+import { HasElementRef } from '../../interfaces/has-element-ref.interface';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedFocusableItemDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedFocusableItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedFocusableItemDirective, "[fnFocusableItem]", never, {}, {}, never, never, true, never>;
+}
+export declare class FocusableItemDirective extends ReplaySubject<boolean> implements HasElementRef, OnDestroy, AfterViewInit, FocusableItemViewModifier {
+    private _elementRef;
+    private _focusableObserver;
+    private _destroy$;
+    /** Whether the item is focusable. */
+    set fdkFocusableItem(val: BooleanInput);
+    get fdkFocusableItem(): boolean;
+    /** @hidden */
+    private _focusable;
+    /** @hidden */
+    private readonly _viewInit$;
+    /** @hidden */
+    constructor(_elementRef: ElementRef<HTMLElement>, _focusableObserver: FocusableObserver, _destroy$: DestroyedService);
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /** Sets focusable state of the element. */
+    setFocusable: (isFocusable: boolean) => void;
+    /** Element reference. */
+    elementRef(): ElementRef<HTMLElement>;
+    /** @hidden */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusableItemDirective, "[fdkFocusableItem]", never, { "fdkFocusableItem": "fdkFocusableItem"; }, {}, never, never, true, never>;
+}

package/utils/directives/focusable-item/focusable-item.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./focusable-item.directive";
+export declare class FocusableItemModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableItemModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FocusableItemModule, never, [typeof i1.FocusableItemDirective, typeof i1.DeprecatedFocusableItemDirective], [typeof i1.FocusableItemDirective, typeof i1.DeprecatedFocusableItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FocusableItemModule>;
+}

package/utils/directives/focusable-item/focusable.observer.d.ts

@@ -0,0 +1,18 @@
+import { ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { HasElementRef } from '../../interfaces/has-element-ref.interface';
+import { AttributeObserver } from '../../services/observers/attribute.observer';
+import * as i0 from "@angular/core";
+export declare class FocusableObserver {
+    private _attributeObserver;
+    /** @hidden */
+    constructor(_attributeObserver: AttributeObserver);
+    /** @Hidden */
+    static isFocusable(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<FocusableObserver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FocusableObserver>;
+}

package/utils/directives/focusable-item/focusable.tokens.d.ts

@@ -0,0 +1,2 @@
+import { InjectionToken } from '@angular/core';
+export declare const FDK_FOCUSABLE_ITEM_DIRECTIVE: InjectionToken<unknown>;

package/utils/directives/focusable-item/index.d.ts

@@ -0,0 +1,8 @@
+export * from './focusable-item.module';
+export * from './focusable-item.directive';
+export * from './focusable.tokens';
+export * from './set-focusable';
+export * from './focusable-item-view-modifier.interface';
+export * from './focusable.observer';
+export * from './default-focusable-item-view-modifier';
+export * from './fdk-focusable-item-provider.service';