@fundamental-ngx/cdk 0.38.3-rc.4

package/utils/drag-and-drop/dnd.interfaces.d.ts

@@ -0,0 +1,33 @@
+import { ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+export declare type LinkPosition = 'after' | 'before';
+export interface ElementChord {
+    x: number;
+    y: number;
+    position: LinkPosition;
+    stickToPosition?: boolean;
+    width: number;
+    height: number;
+}
+export interface FdDropEvent<T> {
+    items: Array<T>;
+    replacedItemIndex: number;
+    draggedItemIndex: number;
+}
+export interface ElementPosition {
+    x: number;
+    y: number;
+}
+export interface DndItem {
+    elementRef: ElementRef;
+    getElementCoordinates: (isBefore: boolean, gridMode: boolean) => ElementChord;
+    removeLine: () => void;
+    removeReplaceIndicator: () => void;
+    createLine: (linkPosition: LinkPosition, gridMode: boolean) => void;
+    createReplaceIndicator: () => void;
+    moved: Observable<ElementPosition>;
+    released: Observable<void>;
+    started: Observable<void>;
+    listDraggable: boolean;
+    changeCDKDragState: () => void;
+}

package/utils/drag-and-drop/drag-and-drop.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./dnd-item/dnd-item.directive";
+import * as i2 from "./dnd-list/dnd-list.directive";
+import * as i3 from "./dnd-keyboard-group/dnd-keyboard-group.directive";
+import * as i4 from "./dnd-keyboard-item/dnd-keyboard-item.directive";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/cdk/drag-drop";
+export declare class DragAndDropModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragAndDropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DragAndDropModule, [typeof i1.DndItemDirective, typeof i2.DndListDirective, typeof i3.DndKeyboardGroupDirective, typeof i4.DndKeyboardItemDirective], [typeof i5.CommonModule, typeof i6.DragDropModule], [typeof i1.DndItemDirective, typeof i2.DndListDirective, typeof i3.DndKeyboardGroupDirective, typeof i4.DndKeyboardItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DragAndDropModule>;
+}

package/utils/drag-and-drop/index.d.ts

@@ -0,0 +1,7 @@
+export * from './dnd-item/dnd-item.directive';
+export * from './dnd-keyboard-group/dnd-keyboard-group.directive';
+export * from './dnd-keyboard-item/dnd-keyboard-item.directive';
+export * from './dnd-list/dnd-list.directive';
+export * from './dnd.interfaces';
+export * from './drag-and-drop.module';
+export * from './tokens';

package/utils/drag-and-drop/tokens.d.ts

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

package/utils/dynamic-component/dynamic-component-config.d.ts

@@ -0,0 +1,6 @@
+export 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';
+}

package/utils/dynamic-component/dynamic-component-container.d.ts

@@ -0,0 +1,19 @@
+import { ComponentFactoryResolver, ComponentRef, ElementRef, EmbeddedViewRef, TemplateRef, Type, ViewContainerRef } from '@angular/core';
+export declare abstract class DynamicComponentContainer<T = TemplateRef<any> | Type<any>> {
+    protected _elementRef: ElementRef;
+    protected _componentFactoryResolver: ComponentFactoryResolver;
+    /** @hidden */
+    abstract containerRef: ViewContainerRef;
+    /** @hidden */
+    childContent: T | undefined;
+    /** @hidden */
+    protected _componentRef: ComponentRef<any> | EmbeddedViewRef<any>;
+    /** @hidden */
+    constructor(_elementRef: ElementRef, _componentFactoryResolver: ComponentFactoryResolver);
+    /** @hidden Load received content */
+    protected abstract _loadContent(): void;
+    /** @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;
+}

package/utils/dynamic-component/dynamic-component-injector.d.ts

@@ -0,0 +1,13 @@
+import { Injector } from '@angular/core';
+export 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;
+}

package/utils/dynamic-component/dynamic-component.service.d.ts

@@ -0,0 +1,46 @@
+import { ComponentFactoryResolver, ApplicationRef, Injector, ComponentRef, TemplateRef, Type, Compiler, NgModuleFactory, ViewContainerRef } from '@angular/core';
+import { DynamicComponentConfig } from './dynamic-component-config';
+import * as i0 from "@angular/core";
+/**
+ * Service used to dynamically generate components like dialogs/alerts/notifications
+ */
+export 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>;
+}

package/utils/dynamic-component/index.d.ts

@@ -0,0 +1,4 @@
+export * from './dynamic-component-config';
+export * from './dynamic-component-container';
+export * from './dynamic-component-injector';
+export * from './dynamic-component.service';

package/utils/functions/consumer-provider-factory.d.ts

@@ -0,0 +1,5 @@
+import { Injector, Provider } from '@angular/core';
+/**
+ * Creates provider for ConsumerClass
+ */
+export declare function consumerProviderFactory<T = any>(ConsumerClass: new (injector: Injector, additionalConfig: Record<any, any> | undefined) => T, providedConfiguration?: Record<any, any>): Provider;

package/utils/functions/element-size.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef } from '@angular/core';
+export declare const pxToNum: (pixels: string) => number;
+export declare const toNativeElement: (element: HTMLElement | ElementRef) => HTMLElement;
+/** Return elements capacity (width subtract by element padding)
+ * @param element - HTMLelement or element reference
+ * */
+export 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
+ * */
+export declare function getElementWidth(element: HTMLElement | ElementRef, withMargin?: boolean): number;

package/utils/functions/get-document-font-size.d.ts

@@ -0,0 +1,2 @@
+/** Get document font size in pixels. */
+export declare function getDocumentFontSize(): number;

package/utils/functions/index.d.ts

@@ -0,0 +1,12 @@
+export * from './key-util';
+export * from './element-size';
+export * from './uuidv4-generator';
+export * from './parser-file-size';
+export * from './scroll';
+export * from './random-color-accent';
+export * from './resize-observable';
+export * from './intersection-observable';
+export * from './is-compact-density';
+export * from './module-deprecations-provider';
+export * from './consumer-provider-factory';
+export * from './get-document-font-size';

package/utils/functions/intersection-observable.d.ts

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

package/utils/functions/is-compact-density.d.ts

@@ -0,0 +1,7 @@
+import { ContentDensity } from '../interfaces/content-density';
+/** Determines whether provided value is valid content density */
+export declare function isValidContentDensity(size: any): size is ContentDensity;
+/**
+ * Determines if "compact" styles should be applied based on provided content density
+ */
+export declare function isCompactDensity(size: ContentDensity): boolean;

package/utils/functions/key-util.d.ts

@@ -0,0 +1,16 @@
+export 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'): boolean;
+}

package/utils/functions/module-deprecations-provider.d.ts

@@ -0,0 +1,5 @@
+import { FactorySansProvider, Provider } from '@angular/core';
+/** Module deprecations provider */
+export declare function moduleDeprecationsProvider(classRef: any): Provider;
+/** Module deprecations provider factory */
+export declare function moduleDeprecationsFactory(factory: FactorySansProvider): Provider;

package/utils/functions/parser-file-size.d.ts

@@ -0,0 +1,2 @@
+/** Parse file size to bytes */
+export declare function parserFileSize(fileSize: string): number;

package/utils/functions/random-color-accent.d.ts

@@ -0,0 +1,3 @@
+import { ColorAccent } from '../datatypes';
+/** Get random number from 1 to 10. */
+export declare function getRandomColorAccent(): ColorAccent;

package/utils/functions/resize-observable.d.ts

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

package/utils/functions/scroll.d.ts

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

package/utils/functions/uuidv4-generator.d.ts

@@ -0,0 +1,2 @@
+/** Generate a UUID v4 */
+export declare function uuidv4(): string;

package/utils/helpers/get-native-element.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef } from '@angular/core';
+/**
+ * Retrieves native element from ElementRef.
+ */
+export declare function getNativeElement<T extends Element = HTMLElement>(element: {
+    elementRef(): ElementRef<T>;
+} | T | ElementRef<T>): T;
+/**
+ * Checks whether object has element reference in it.
+ */
+export declare function isHasElementRef<T extends Element = HTMLElement>(something: any): something is {
+    elementRef(): ElementRef<T>;
+};

package/utils/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './range-selector';
+export * from './get-native-element';

package/utils/helpers/range-selector.d.ts

@@ -0,0 +1,84 @@
+/**
+ * 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]);
+ *          }
+ *      });
+ *  }
+ * }
+ * ```
+ */
+export 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;
+}
+export interface RangeSelectionState {
+    isRangeSelection: boolean;
+    from: number;
+    to: number;
+}

package/utils/index.d.ts

@@ -0,0 +1,18 @@
+export * from './utils.module';
+export * from './typecheck';
+export * from './coercion/array';
+export * from './models/nullable';
+export * from './consts';
+export * from './datatypes';
+export * from './decorators';
+export * from './directives';
+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 './services';
+export * from './abstract-fd-ngx-class';
+export * from './pipes';
+export * from './tokens/module-deprecations.token';

package/utils/interfaces/content-density.d.ts

@@ -0,0 +1 @@
+export declare type ContentDensity = 'cozy' | 'condensed' | 'compact';

package/utils/interfaces/css-class-builder.interface.d.ts

@@ -0,0 +1,6 @@
+import { Nullable } from '../models/nullable';
+import { HasElementRef } from './has-element-ref.interface';
+export interface CssClassBuilder extends HasElementRef {
+    class: Nullable<string>;
+    buildComponentCssClass(): string[];
+}

package/utils/interfaces/css-style-builder.interface.d.ts

@@ -0,0 +1,5 @@
+import { Hash } from '../datatypes';
+import { HasElementRef } from './has-element-ref.interface';
+export interface CssStyleBuilder extends HasElementRef {
+    buildComponentCssStyle(): Hash<number | string>;
+}

package/utils/interfaces/has-element-ref.interface.d.ts

@@ -0,0 +1,5 @@
+import { ElementRef } from '@angular/core';
+export interface HasElementRef<ElementType extends Element = HTMLElement> {
+    elementRef(): ElementRef<ElementType>;
+}
+export declare const ELEMENT_REF_EXCEPTION = "HasElementRef interface has to be implemented";

package/utils/interfaces/index.d.ts

@@ -0,0 +1,7 @@
+export * from './content-density';
+export * from './css-class-builder.interface';
+export * from './css-style-builder.interface';
+export * from './has-element-ref.interface';
+export * from './keyboard-support-item.interface';
+export * from './module-deprecation.interface';
+export * from './require.interface';

package/utils/interfaces/keyboard-support-item.interface.d.ts

@@ -0,0 +1,6 @@
+import { EventEmitter } from '@angular/core';
+import { FocusableOption } from '@angular/cdk/a11y';
+export interface KeyboardSupportItemInterface extends FocusableOption {
+    keyDown: EventEmitter<KeyboardEvent>;
+    click(): void;
+}

package/utils/interfaces/module-deprecation.interface.d.ts

@@ -0,0 +1,8 @@
+export interface ModuleDeprecation {
+    alternative: {
+        name: string;
+        link: string | string[];
+        fragment?: string;
+    };
+    message: string;
+}

package/utils/interfaces/require.interface.d.ts

@@ -0,0 +1,6 @@
+export declare 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];
+export declare 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];

package/utils/list-item/list-item-utils.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+export declare const LIST_ITEM_COMPONENT: InjectionToken<string[]>;
+export interface ListItemInterface {
+    selected: boolean;
+    link: boolean;
+    focus(): void;
+}

package/utils/models/nullable.d.ts

@@ -0,0 +1,6 @@
+/** Makes the provided type nullable */
+export declare type Nullable<T> = T | null | undefined;
+/** Makes each property of an object optional and nullable */
+export declare type NullableObject<T> = {
+    [P in keyof T]?: Nullable<T[P]>;
+};

package/utils/pipes/displayFn.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export 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", false>;
+}

package/utils/pipes/filter-strings.pipe.d.ts

@@ -0,0 +1,16 @@
+import { PipeTransform } from '@angular/core';
+import { Nullable } from '../models/nullable';
+import * as i0 from "@angular/core";
+export 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", false>;
+}

package/utils/pipes/index.d.ts

@@ -0,0 +1,9 @@
+export * from './displayFn.pipe';
+export * from './filter-strings.pipe';
+export * from './is-compact.pipe';
+export * from './pipe.module';
+export * from './safe.pipe';
+export * from './search-highlight.pipe';
+export * from './truncate.pipe';
+export * from './two-digits.pipe';
+export * from './value-by-path.pipe';

package/utils/pipes/is-compact.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { ContentDensity } from '../interfaces/content-density';
+import * as i0 from "@angular/core";
+export 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", false>;
+}

package/utils/pipes/pipe.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./displayFn.pipe";
+import * as i2 from "./search-highlight.pipe";
+import * as i3 from "./two-digits.pipe";
+import * as i4 from "./safe.pipe";
+import * as i5 from "./value-by-path.pipe";
+import * as i6 from "./is-compact.pipe";
+import * as i7 from "./truncate.pipe";
+import * as i8 from "./filter-strings.pipe";
+export declare class PipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PipeModule, [typeof i1.DisplayFnPipe, typeof i2.SearchHighlightPipe, typeof i3.TwoDigitsPipe, typeof i4.SafePipe, typeof i5.ValueByPathPipe, typeof i6.IsCompactDensityPipe, typeof i7.TruncatePipe, typeof i8.FilterStringsPipe], never, [typeof i1.DisplayFnPipe, typeof i2.SearchHighlightPipe, typeof i3.TwoDigitsPipe, typeof i4.SafePipe, typeof i5.ValueByPathPipe, typeof i6.IsCompactDensityPipe, typeof i7.TruncatePipe, typeof i8.FilterStringsPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PipeModule>;
+}

package/utils/pipes/safe.pipe.d.ts

@@ -0,0 +1,12 @@
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml, SafeStyle, SafeScript, SafeUrl, SafeResourceUrl } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export 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", false>;
+}

package/utils/pipes/search-highlight.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SearchHighlightPipe implements PipeTransform {
+    /** Highlight search term in string. */
+    transform(value: string, args: string, active?: boolean, includeSpans?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchHighlightPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SearchHighlightPipe, "highlight", false>;
+}

package/utils/pipes/truncate.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export 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", false>;
+}

package/utils/pipes/two-digits.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export 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", false>;
+}

package/utils/pipes/value-by-path.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export 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", false>;
+}

package/utils/services/content-density.service.d.ts

@@ -0,0 +1,19 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ContentDensity } from '../interfaces/content-density';
+import * as i0 from "@angular/core";
+export declare const DEFAULT_CONTENT_DENSITY: ContentDensity;
+/**
+ * Service taking care of ContentDensity
+ */
+export 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>;
+}

package/utils/services/destroyed.service.d.ts

@@ -0,0 +1,11 @@
+import { OnDestroy } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class DestroyedService extends ReplaySubject<void> implements OnDestroy {
+    /** @hidden */
+    constructor();
+    /** @hidden */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DestroyedService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DestroyedService>;
+}