@fundamental-ngx/cdk 0.38.3-rc.4

package/utils/directives/focusable-item/is-element-focusable-by-default.d.ts

@@ -0,0 +1,4 @@
+import { ElementRef } from '@angular/core';
+import { HasElementRef } from '../../interfaces';
+/** @hidden */
+export declare function isElementFocusableByDefault(el: HasElementRef<Element> | Element | ElementRef<Element>): boolean;

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

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

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

@@ -0,0 +1,25 @@
+import { AfterViewInit } from '@angular/core';
+import { FocusableListService } from './focusable-list.service';
+import { DestroyedService } from '../../services/destroyed.service';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedFocusableListDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedFocusableListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedFocusableListDirective, "[fnFocusableList]", never, {}, {}, never, never, true, never>;
+}
+export declare class FocusableListDirective implements AfterViewInit {
+    private _focusableListService;
+    private _destroy$;
+    /** Direction of navigation. */
+    navigationDirection: 'horizontal' | 'vertical';
+    /** Direction of the content. */
+    contentDirection: 'ltr' | 'rtl' | null;
+    /** @hidden */
+    private _focusableItems;
+    /** @hidden */
+    constructor(_focusableListService: FocusableListService, _destroy$: DestroyedService);
+    /** @hidden */
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusableListDirective, "[fdkFocusableList]", ["fdkFocusableList"], { "navigationDirection": "navigationDirection"; "contentDirection": "contentDirection"; }, {}, ["_focusableItems"], never, true, never>;
+}

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

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

package/utils/directives/focusable-list/focusable-list.service.d.ts

@@ -0,0 +1,35 @@
+import { OnDestroy, Renderer2 } from '@angular/core';
+import { FocusableOption } from '@angular/cdk/a11y';
+import { HasElementRef } from '../../interfaces/has-element-ref.interface';
+import * as i0 from "@angular/core";
+interface FocusableListConfig {
+    wrap?: boolean;
+    direction?: 'vertical' | 'horizontal';
+    contentDirection?: 'ltr' | 'rtl' | null;
+}
+export declare type FocusableItem = FocusableOption & HasElementRef & {
+    focusable: (() => boolean) | boolean;
+    index: number;
+};
+export declare class FocusableListService implements OnDestroy {
+    private _renderer;
+    /** @hidden */
+    private keyManager?;
+    /** @hidden */
+    private readonly _refresh$;
+    /** @hidden */
+    private readonly _destroy$;
+    /** @hidden */
+    constructor(_renderer: Renderer2);
+    /**
+     * Initializes the focusable list service with items and configuration.
+     * @param items Focusable list items.
+     * @param config Initialization configuration.
+     */
+    initialize(items: FocusableItem[], config?: FocusableListConfig): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusableListService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FocusableListService>;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export * from './focusable-list.service';
+export * from './focusable-list.module';
+export * from './focusable-list.directive';

package/utils/directives/ignore-click-on-selection/ignore-click-on-selection.directive.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef } from '@angular/core';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedIgnoreClickOnSelectionDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedIgnoreClickOnSelectionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedIgnoreClickOnSelectionDirective, "[fdIgnoreClickOnSelection]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * 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
+ */
+export 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], [fdIgnoreClickOnSelection]", never, {}, {}, never, never, true, never>;
+}

package/utils/directives/ignore-click-on-selection/ignore-click-on-selection.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./ignore-click-on-selection.directive";
+export declare class IgnoreClickOnSelectionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgnoreClickOnSelectionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgnoreClickOnSelectionModule, never, [typeof i1.IgnoreClickOnSelectionDirective, typeof i1.DeprecatedIgnoreClickOnSelectionDirective], [typeof i1.IgnoreClickOnSelectionDirective, typeof i1.DeprecatedIgnoreClickOnSelectionDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgnoreClickOnSelectionModule>;
+}

package/utils/directives/ignore-click-on-selection/tokens.d.ts

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

package/utils/directives/index.d.ts

@@ -0,0 +1,30 @@
+export * from './auto-complete/auto-complete.directive';
+export * from './auto-complete/auto-complete.module';
+export * from './focus-key-manager';
+export * from './ignore-click-on-selection/ignore-click-on-selection.directive';
+export * from './ignore-click-on-selection/ignore-click-on-selection.module';
+export * from './ignore-click-on-selection/tokens';
+export * from './initial-focus/initial-focus.directive';
+export * from './initial-focus/initial-focus.module';
+export * from './line-clamp/line-clamp.directive';
+export * from './line-clamp/line-clamp.module';
+export * from './only-digits/only-digits.directive';
+export * from './only-digits/only-digits.module';
+export * from './overflow-list/overflow-list-item.directive';
+export * from './overflow-list/overflow-list.directive';
+export * from './overflow-list/overflow-list.module';
+export * from './repeat/repeat.directive';
+export * from './repeat/repeat.module';
+export * from './resize/resize-handle.directive';
+export * from './resize/resize.module';
+export * from './resize/resize.directive';
+export * from './template/template.directive';
+export * from './template/template.module';
+export * from './truncate/truncate.directive';
+export * from './truncate/truncate.module';
+export * from './focusable-item';
+export * from './focusable-list';
+export * from './readonly';
+export * from './disabled';
+export * from './clicked';
+export * from './selectable-list';

package/utils/directives/initial-focus/initial-focus.directive.d.ts

@@ -0,0 +1,43 @@
+import { AfterViewInit, ElementRef, NgZone } from '@angular/core';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import { TabbableElementService } from '../../services/tabbable-element.service';
+import * as i0 from "@angular/core";
+export declare class DeprecatedInitialFocusDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedInitialFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedInitialFocusDirective, "[fdInitialFocus], [fd-initial-focus]", never, {}, {}, never, never, true, never>;
+}
+export declare class InitialFocusDirective implements AfterViewInit {
+    private _elmRef;
+    private _ngZone;
+    private readonly _tabbableService;
+    /**
+     * CSS selector of element that should be focused.
+     */
+    focusableItem: string;
+    /**
+     * Whether initial focus enabled for current element.
+     */
+    enabled: boolean;
+    /**
+     * Whether to focus last element in found array of elements.
+     */
+    focusLastElement: boolean;
+    /** @hidden */
+    constructor(_elmRef: ElementRef<HTMLElement>, _ngZone: NgZone, _tabbableService: TabbableElementService);
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /**
+     * @hidden
+     * Executes a function when the zone is stable.
+     */
+    private _executeOnStable;
+    /**
+     * @hidden
+     * Searches for appropriate focusable element
+     */
+    private _getFocusableElement;
+    /** @hidden */
+    private _focus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitialFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InitialFocusDirective, "[fdkInitialFocus], [fdInitialFocus], [fd-initial-focus]", never, { "focusableItem": "fd-initial-focus"; "enabled": "enabled"; "focusLastElement": "focusLastElement"; }, {}, never, never, true, never>;
+}

package/utils/directives/initial-focus/initial-focus.module.d.ts

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

package/utils/directives/line-clamp/line-clamp.directive.d.ts

@@ -0,0 +1,101 @@
+import { ElementRef, EventEmitter, AfterViewInit, OnDestroy, OnChanges, Renderer2, ChangeDetectorRef } from '@angular/core';
+import { Nullable } from '../../models/nullable';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedLineClampTargetDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedLineClampTargetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedLineClampTargetDirective, "[fdLineClampTarget], [fd-lineclamp-target]", never, {}, {}, never, never, true, never>;
+}
+export declare class DeprecatedLineClampDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedLineClampDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedLineClampDirective, "[fdLineClamp], [fd-lineclamp]", never, {}, {}, never, never, true, never>;
+}
+export 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": "fdLineClampTargetText"; }, { "update": "update"; }, never, never, true, never>;
+}
+export declare class LineClampDirective implements OnChanges, AfterViewInit, OnDestroy {
+    private readonly _elementRef;
+    private readonly _renderer;
+    private readonly _cdRef;
+    /**
+     * 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 windowResize$;
+    /** @hidden */
+    private _isNativeSupport;
+    /** @hidden */
+    private _lineCount;
+    /** @hidden */
+    /**
+     * Root native element of clamping box
+     */
+    get rootElement(): HTMLElement;
+    /** @hidden */
+    constructor(_elementRef: ElementRef, _renderer: Renderer2, _cdRef: ChangeDetectorRef);
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /** @hidden */
+    ngOnDestroy(): 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], [fd-lineclamp]", ["fdLineClamp"], { "fdLineClampLines": "fdLineClampLines"; "fdLineclampState": "fdLineclampState"; }, { "lineCountUpdate": "lineCountUpdate"; }, never, never, true, never>;
+}

package/utils/directives/line-clamp/line-clamp.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./line-clamp.directive";
+export declare class LineClampModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LineClampModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LineClampModule, never, [typeof i1.LineClampTargetDirective, typeof i1.LineClampDirective, typeof i1.DeprecatedLineClampDirective, typeof i1.DeprecatedLineClampTargetDirective], [typeof i1.LineClampTargetDirective, typeof i1.LineClampDirective, typeof i1.DeprecatedLineClampDirective, typeof i1.DeprecatedLineClampTargetDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LineClampModule>;
+}

package/utils/directives/only-digits/only-digits.directive.d.ts

@@ -0,0 +1,44 @@
+import { ElementRef } from '@angular/core';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedOnlyDigitsDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedOnlyDigitsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedOnlyDigitsDirective, "[fdOnlyDigits], [fd-only-digits]", never, {}, {}, never, never, true, never>;
+}
+export 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], [fdOnlyDigits], [fd-only-digits]", never, { "decimal": "decimal"; "decimalSeparator": "decimalSeparator"; }, {}, never, never, true, never>;
+}

package/utils/directives/only-digits/only-digits.module.d.ts

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

package/utils/directives/overflow-list/overflow-list-item.directive.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef } from '@angular/core';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedOverflowListItemDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedOverflowListItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedOverflowListItemDirective, "[fdOverflowListItem], [fd-overflow-list-item]", never, {}, {}, never, never, true, never>;
+}
+export declare class OverflowListItemDirective {
+    el: ElementRef;
+    /** @hidden */
+    constructor(el: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverflowListItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OverflowListItemDirective, "[fdkOverflowListItem], [fdOverflowListItem], [fd-overflow-list-item]", never, {}, {}, never, never, true, never>;
+}

package/utils/directives/overflow-list/overflow-list.directive.d.ts

@@ -0,0 +1,62 @@
+import { AfterViewInit, ElementRef, EventEmitter, NgZone, OnDestroy, QueryList } from '@angular/core';
+import { OverflowListItemDirective } from './overflow-list-item.directive';
+import { ViewportRuler } from '@angular/cdk/overlay';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedOverflowListDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedOverflowListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedOverflowListDirective, "[fdOverflowList], [fd-overflow-list]", never, {}, {}, never, never, true, never>;
+}
+export declare class OverflowListDirective implements AfterViewInit, OnDestroy {
+    private _el;
+    private _viewportRuler;
+    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 _onDestroy$;
+    /** @hidden */
+    constructor(_el: ElementRef, _viewportRuler: ViewportRuler, _ngZone: NgZone);
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    /**
+     * @description Get amount of extra items in current list
+     * */
+    getAmountOfExtraItems(): number;
+    /** @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], [fdOverflowList], [fd-overflow-list]", never, { "overflowOffset": "overflowOffset"; "isRtl": "isRtl"; "itemCssBlockValue": "itemCssBlockValue"; }, { "overflowChanged": "overflowChanged"; }, ["overflowItems"], never, true, never>;
+}

package/utils/directives/overflow-list/overflow-list.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./overflow-list.directive";
+import * as i2 from "./overflow-list-item.directive";
+export declare class OverflowListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverflowListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OverflowListModule, never, [typeof i1.OverflowListDirective, typeof i2.OverflowListItemDirective, typeof i2.DeprecatedOverflowListItemDirective, typeof i1.DeprecatedOverflowListDirective], [typeof i1.OverflowListDirective, typeof i2.OverflowListItemDirective, typeof i2.DeprecatedOverflowListItemDirective, typeof i1.DeprecatedOverflowListDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OverflowListModule>;
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ReadonlyBehavior } from './readonly-behavior.interface';
+import { DestroyedService } from '../../services/destroyed.service';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedReadonlyBehaviorDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedReadonlyBehaviorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedReadonlyBehaviorDirective, "[fnReadonly]", never, {}, {}, never, never, true, never>;
+}
+export declare class ReadonlyBehaviorDirective extends ReplaySubject<boolean> implements ReadonlyBehavior, AfterViewInit, OnDestroy {
+    private _elementRef;
+    private _destroy$;
+    /** @Hidden */
+    set fdkReadonly(value: BooleanInput);
+    get fdkReadonly(): boolean;
+    /** @Hidden */
+    _readonly: boolean;
+    /** @hidden */
+    private readonly _readonlyInput$;
+    /** @hidden */
+    constructor(_elementRef: ElementRef<HTMLElement>, _destroy$: DestroyedService);
+    /** @Hidden */
+    setReadonlyState: (isReadonly: boolean) => void;
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReadonlyBehaviorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ReadonlyBehaviorDirective, "[fdkReadonly], [fnReadonly]", never, { "fdkReadonly": "fdkReadonly"; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+import { ReadonlyViewModifier } from './readonly-view-modifier.interface';
+declare type Base = Observable<boolean> & ReadonlyViewModifier;
+export interface ReadonlyBehavior extends Base {
+    fdkReadonly: boolean;
+}
+export {};

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

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

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

@@ -0,0 +1,3 @@
+export interface ReadonlyViewModifier {
+    setReadonlyState: (isReadonly: boolean) => void;
+}

package/utils/directives/readonly/readonly.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 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>;
+}

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

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

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

@@ -0,0 +1,28 @@
+import { OnChanges, SimpleChanges, TemplateRef, ViewContainerRef } from '@angular/core';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedRepeatDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedRepeatDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedRepeatDirective, "[fdRepeat]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to repeatably render template N times.
+ */
+export declare class RepeatDirective implements OnChanges {
+    private readonly _templateRef;
+    private readonly _viewContainerRef;
+    /** Number of times to render a template. */
+    count: number;
+    /**
+     * Deprecated fdRepeat input property. Use `[fdkRepeat]`.
+     */
+    deprecatedCount: number;
+    /** @hidden */
+    private get _repeatCount();
+    /** @hidden */
+    constructor(_templateRef: TemplateRef<any>, _viewContainerRef: ViewContainerRef);
+    /** @hidden */
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RepeatDirective, "[fdkRepeat], [fdRepeat]", never, { "count": "fdkRepeat"; "deprecatedCount": "fdRepeat"; }, {}, never, never, true, never>;
+}