@design-factory/design-factory 15.2.0

package/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Public API Surface of design-factory
+ */
+export * from './lib/index';

package/lib/angular/accessibility/accessibility.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./directives/skip-link.directive";
+import * as i2 from "./components/skip-links-container/skip-links-container.component";
+export { SkipLinksContainerComponent } from './components/skip-links-container/skip-links-container.component';
+export { SkipLinkDirective } from './directives/skip-link.directive';
+export declare class DfAccessibilityModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAccessibilityModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfAccessibilityModule, never, [typeof i1.SkipLinkDirective, typeof i2.SkipLinksContainerComponent], [typeof i1.SkipLinkDirective, typeof i2.SkipLinksContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfAccessibilityModule>;
+}

package/lib/angular/accessibility/components/skip-links-container/skip-links-container.component.d.ts

@@ -0,0 +1,13 @@
+import { AfterContentInit, OnDestroy, ChangeDetectorRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SkipLinksContainerComponent implements AfterContentInit, OnDestroy {
+    private changeDetector;
+    inFocus: boolean;
+    private links;
+    private focusSubscription;
+    constructor(changeDetector: ChangeDetectorRef);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkipLinksContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkipLinksContainerComponent, "df-skip-links-container", never, {}, {}, ["links"], ["*"], true, never>;
+}

package/lib/angular/accessibility/directives/skip-link.directive.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SkipLinkDirective {
+    private readonly element;
+    private readonly document;
+    class: string;
+    inFocus: EventEmitter<boolean>;
+    onFocus(): void;
+    onClick(): void;
+    onBlur(): void;
+    constructor(element: ElementRef, document: any);
+    private focusOnTarget;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkipLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkipLinkDirective, "[dfSkipLink]", never, {}, { "inFocus": "inFocus"; }, never, never, true, never>;
+}

package/lib/angular/alert/alert.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../icon/insert/insert-icon.module";
+import * as i2 from "@ng-bootstrap/ng-bootstrap";
+export declare class DfAlertModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfAlertModule, never, [typeof i1.DfInsertIconModule], [typeof i2.NgbAlertModule, typeof i1.DfInsertIconModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfAlertModule>;
+}

package/lib/angular/animation/ngbTransition.d.ts

@@ -0,0 +1,16 @@
+import { NgZone } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+export type NgbTransitionStartFn<T = any> = (element: HTMLElement, animation: boolean, context: T) => NgbTransitionEndFn | void;
+export type NgbTransitionEndFn = () => void;
+export interface NgbTransitionOptions<T> {
+    animation: boolean;
+    runningTransition: 'continue' | 'stop';
+    context?: T;
+}
+export interface NgbTransitionCtx<T> {
+    transition$: Subject<any>;
+    complete: () => void;
+    context: T;
+}
+export declare const ngbRunTransition: <T>(zone: NgZone, element: HTMLElement, startFn: NgbTransitionStartFn<T>, options: NgbTransitionOptions<T>) => Observable<undefined>;
+export declare const ngbCompleteTransition: (element: HTMLElement) => void;

package/lib/angular/animation/util.d.ts

@@ -0,0 +1,14 @@
+import { NgZone } from '@angular/core';
+import { OperatorFunction } from 'rxjs';
+/**
+ * Creates an observable where all callbacks are executed inside a given zone
+ *
+ * @param zone Angular Zone element
+ */
+export declare function runInZone<T>(zone: NgZone): OperatorFunction<T, T>;
+export declare function getTransitionDurationMs(element: HTMLElement): number;
+/**
+ * Force a browser reflow
+ * @param element element where to apply the reflow
+ */
+export declare function reflow(element: HTMLElement): DOMRect;

package/lib/angular/card/card-advanced.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./manage-card-selection.directive";
+export { DfManageCardSelectionDirective } from './manage-card-selection.directive';
+export declare class DfAdvancedCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAdvancedCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfAdvancedCardModule, never, [typeof i1.DfManageCardSelectionDirective], [typeof i1.DfManageCardSelectionDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfAdvancedCardModule>;
+}

package/lib/angular/card/manage-card-selection.directive.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef, AfterViewInit, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DfManageCardSelectionDirective implements AfterViewInit {
+    private readonly element;
+    private readonly renderer;
+    private input;
+    set dfManageCardSelected(isSelected: boolean);
+    constructor(element: ElementRef, renderer: Renderer2);
+    ngAfterViewInit(): void;
+    click(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfManageCardSelectionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfManageCardSelectionDirective, "[dfManageCardSelected]", never, { "dfManageCardSelected": { "alias": "dfManageCardSelected"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/angular/datepicker/closedatepicker.directive.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CloseInputDatePickerDirective {
+    private elementRef;
+    inputDatePicker: any;
+    constructor(elementRef: ElementRef);
+    onClick(targetElement: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CloseInputDatePickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CloseInputDatePickerDirective, "[dfCloseInputDatePicker]", never, { "inputDatePicker": { "alias": "dfCloseInputDatePicker"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/angular/datepicker/datepicker-keyboard-nav.service.d.ts

@@ -0,0 +1,7 @@
+import { NgbDatepicker, NgbDatepickerKeyboardService } from '@ng-bootstrap/ng-bootstrap';
+import * as i0 from "@angular/core";
+export declare class DfDatepickerKeyboardService extends NgbDatepickerKeyboardService {
+    processKey(event: KeyboardEvent, dp: NgbDatepicker): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfDatepickerKeyboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfDatepickerKeyboardService>;
+}

package/lib/angular/datepicker/datepicker-range.directive.d.ts

@@ -0,0 +1,31 @@
+import { ElementRef, Renderer2, OnInit, OnDestroy, DoCheck, AfterViewInit } from '@angular/core';
+import { DfDirectionDetectionService } from '../right-to-left/directionDetection.service';
+import * as i0 from "@angular/core";
+/**
+ * My dfDatepickerRange directive
+ */
+export declare class DfDatepickerRangeDirective implements OnInit, OnDestroy, DoCheck, AfterViewInit {
+    private readonly renderer;
+    readonly el: ElementRef;
+    private readonly dfDirectionServ;
+    private inputsElements;
+    private isDisabled;
+    private readonly siblingsNode;
+    private readonly removeListener;
+    private focusState;
+    private direction?;
+    constructor(renderer: Renderer2, el: ElementRef, dfDirectionServ: DfDirectionDetectionService);
+    ngOnInit(): void;
+    initInput(el: HTMLInputElement, index: number): void;
+    removeFocus(): void;
+    ngAfterViewInit(): void;
+    /**
+     * You need to manually update the direction or update the icon
+     * if the direction (rtl / ltr) is changing dynamically
+     */
+    updateDirection(): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfDatepickerRangeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfDatepickerRangeDirective, "[dfDatepickerRange]", ["dfDatepickerRange"], {}, {}, never, never, true, never>;
+}

package/lib/angular/datepicker/datepicker-range.service.d.ts

@@ -0,0 +1,32 @@
+import { NgbCalendar, NgbDate, NgbDateParserFormatter, NgbDatepicker, NgbDropdown } from '@ng-bootstrap/ng-bootstrap';
+import * as i0 from "@angular/core";
+export declare class DfDatepickerRangeService {
+    private readonly calendar;
+    private readonly formatter;
+    fromDate: NgbDate | null;
+    toDate: NgbDate | null;
+    hoveredDate: NgbDate | null;
+    fromDateAsStr: string;
+    toDateAsStr: string;
+    startDate: NgbDate | null;
+    getFocusBack: HTMLInputElement | HTMLButtonElement | null;
+    dropDown?: NgbDropdown;
+    isClosingOnToDate: boolean;
+    datepicker: NgbDatepicker | null;
+    constructor(calendar: NgbCalendar, formatter: NgbDateParserFormatter);
+    onDateSelection(date: NgbDate): void;
+    setFocus(): void;
+    returnFocus(): void;
+    openChange(event: boolean): void;
+    toggle(dropDown: NgbDropdown, element?: HTMLInputElement | HTMLButtonElement | null, datepicker?: NgbDatepicker | null): void;
+    isSelected(date: NgbDate): boolean;
+    isFrom(date: NgbDate): boolean;
+    isTo(date: NgbDate): boolean;
+    isBetween(date: NgbDate): boolean;
+    effectiveToDate(): NgbDate | null | undefined;
+    parseInput(previous: NgbDate, typed: string): NgbDate | null;
+    updateFrom(typed: string): void;
+    updateTo(typed: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfDatepickerRangeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfDatepickerRangeService>;
+}

package/lib/angular/datepicker/datepicker.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-bootstrap/ng-bootstrap";
+import * as i2 from "./closedatepicker.directive";
+import * as i3 from "./datepicker-range.directive";
+import * as i4 from "../inputs/input-advanced.module";
+export { CloseInputDatePickerDirective } from './closedatepicker.directive';
+export { DfDatepickerRangeDirective } from './datepicker-range.directive';
+export declare class DfDatePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfDatePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfDatePickerModule, never, [typeof i1.NgbDropdownModule, typeof i2.CloseInputDatePickerDirective, typeof i3.DfDatepickerRangeDirective], [typeof i2.CloseInputDatePickerDirective, typeof i1.NgbDatepickerModule, typeof i4.DfAdvancedInputModule, typeof i3.DfDatepickerRangeDirective, typeof i1.NgbDropdownModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfDatePickerModule>;
+}

package/lib/angular/footer/footer.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../mediaqueries/media.module";
+import * as i2 from "@ng-bootstrap/ng-bootstrap";
+export declare class DfFooterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfFooterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfFooterModule, never, [typeof i1.DfMediaModule, typeof i2.NgbAccordionModule], [typeof i1.DfMediaModule, typeof i2.NgbAccordionModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfFooterModule>;
+}

package/lib/angular/icon/amadeus-icon.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class DfAmadeusIconComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAmadeusIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfAmadeusIconComponent, "df-amadeus-icon", never, {}, {}, never, never, true, never>;
+}

package/lib/angular/icon/icon.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./amadeus-icon";
+export { DfAmadeusIconComponent } from './amadeus-icon';
+export declare class DfIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfIconModule, never, [typeof i1.DfAmadeusIconComponent], [typeof i1.DfAmadeusIconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfIconModule>;
+}

package/lib/angular/icon/insert/insert-icon.directive.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef, Renderer2, AfterViewInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DfInsertIconDirective implements AfterViewInit {
+    private readonly el;
+    private readonly renderer;
+    private readonly supportedCmps;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngAfterViewInit(): void;
+    getIconClassFromClasses(cssClasses: DOMTokenList): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfInsertIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfInsertIconDirective, "ngb-alert[dfInsertAlertIcon],ngb-toast[dfInsertToastIcon]", never, {}, {}, never, never, true, never>;
+}

package/lib/angular/icon/insert/insert-icon.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./insert-icon.directive";
+export { DfInsertIconDirective } from './insert-icon.directive';
+export declare class DfInsertIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfInsertIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfInsertIconModule, never, [typeof i1.DfInsertIconDirective], [typeof i1.DfInsertIconDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfInsertIconModule>;
+}

package/lib/angular/inputs/click/trigger-click.directive.d.ts

@@ -0,0 +1,9 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DfTriggerClickDirective {
+    private readonly elementRef;
+    constructor(elementRef: ElementRef);
+    triggerClick(event: KeyboardEvent | MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfTriggerClickDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfTriggerClickDirective, "[dfTriggerClick]", never, {}, {}, never, never, true, never>;
+}

package/lib/angular/inputs/icon/inputicon.directive.d.ts

@@ -0,0 +1,28 @@
+import { ElementRef, Renderer2, OnInit, DoCheck, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export type DfDirection = 'append' | 'prepend';
+/**
+ * My dfInputIcon directive
+ */
+export declare class DfInputIconDirective implements OnInit, DoCheck, OnDestroy {
+    private readonly renderer;
+    private readonly el;
+    dfInputIcon: DfDirection[];
+    private button;
+    private removeListener?;
+    private isDisabled;
+    private readonly siblingsNode;
+    constructor(renderer: Renderer2, el: ElementRef);
+    ngDoCheck(): void;
+    ngOnInit(): void;
+    /**
+     * onBlur catch blur event to set the focused to false
+     */
+    onBlur(): void;
+    onFocus(): void;
+    onTab(e: KeyboardEvent): void;
+    ngOnDestroy(): void;
+    private initButtonHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfInputIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfInputIconDirective, "[dfInputIcon]", ["dfInputIcon"], { "dfInputIcon": { "alias": "dfInputIcon"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/angular/inputs/input-advanced.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./click/trigger-click.directive";
+import * as i2 from "./icon/inputicon.directive";
+export { DfTriggerClickDirective } from './click/trigger-click.directive';
+export { DfInputIconDirective } from './icon/inputicon.directive';
+export declare class DfAdvancedInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAdvancedInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfAdvancedInputModule, never, [typeof i1.DfTriggerClickDirective, typeof i2.DfInputIconDirective], [typeof i1.DfTriggerClickDirective, typeof i2.DfInputIconDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfAdvancedInputModule>;
+}

package/lib/angular/mediaqueries/ifMedia.directive.d.ts

@@ -0,0 +1,26 @@
+import { OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+import { DfMedia } from './media.service';
+import * as i0 from "@angular/core";
+/**
+ * Directive using the matchMedia JS feature (https://developer.mozilla.org/fr/docs/Web/API/Window/matchMedia)
+ * to be able to add or remove an element like ngIf is doing.
+ * Import DfMediaModule from DF to use all media elements provided
+ */
+export declare class DfIfMediaDirective implements OnDestroy {
+    private readonly _viewContainerRef;
+    private readonly _template;
+    private readonly _mediaService;
+    private _viewInstance;
+    private readonly _subscription;
+    /**
+     * Input of the directive
+     * @param mediaOrBreakpoints either media query string/Array of string or in case of BS usage a
+     * string/Array of string of the breakpoints name (sm...).
+     */
+    set dfIfMedia(mediaOrBreakpoints: string | string[]);
+    constructor(_viewContainerRef: ViewContainerRef, _template: TemplateRef<any>, _mediaService: DfMedia);
+    ngOnDestroy(): void;
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfIfMediaDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfIfMediaDirective, "[dfIfMedia]", never, { "dfIfMedia": { "alias": "dfIfMedia"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/angular/mediaqueries/media.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./ifMedia.directive";
+export { DfIfMediaDirective } from './ifMedia.directive';
+export declare class DfMediaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfMediaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfMediaModule, never, [typeof i1.DfIfMediaDirective], [typeof i1.DfIfMediaDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfMediaModule>;
+}

package/lib/angular/mediaqueries/media.service.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from 'rxjs';
+import { DfBreakpoints, DfMediaObserver } from './mediaUtils.service';
+import * as i0 from "@angular/core";
+/**
+ * Services you can use to get indication about the current width screen of your application
+ * the matchMedia JS feature (https://developer.mozilla.org/fr/docs/Web/API/Window/matchMedia)
+ */
+export declare class DfMedia {
+    private readonly mediaObserver;
+    private readonly _breakPointsService;
+    constructor(mediaObserver: DfMediaObserver, _breakPointsService: DfBreakpoints);
+    initQueries(mediaOrBreakpoints: string | string[], breakPoints?: {
+        [key: string]: string;
+    }): string[];
+    /**
+     * Getter to have the observable indication if you are or not in the current scope of your queries
+     * If one queries is matching result is `True` otherwise result is `False`
+     * @param mediaOrBreakpoints either media query string/Array of string or/and in case of BS usage a
+     * string/Array of string of the breakpoints name (sm...).
+     */
+    getObservable(mediaOrBreakpoints: string | string[]): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfMedia, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfMedia>;
+}

package/lib/angular/mediaqueries/mediaUtils.service.d.ts

@@ -0,0 +1,75 @@
+import { InjectionToken, OnDestroy } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare const DF_BREAKPOINTS_VAR_DEFAULT: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    xxl: string;
+    xxxl: string;
+};
+export declare const BREAKPOINTS_VARS: InjectionToken<{
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    xxl: string;
+    xxxl: string;
+}>;
+export declare class DfBreakpoints {
+    private readonly _breakPointsVar;
+    private readonly platformID;
+    private readonly _breakPoints$;
+    constructor(_breakPointsVar: {
+        [breakpoint: string]: string;
+    }, platformID: Object);
+    get breakPoints$(): Observable<{} | null>;
+    private initBreakpoints;
+    generate(sizes: any[][]): {};
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfBreakpoints, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfBreakpoints>;
+}
+export interface MediaQueryListMeta {
+    mediaQueryList: MediaQueryList;
+    mediaQueryList$: BehaviorSubject<MediaQueryListEvent>;
+}
+export interface MediaBreakpointsState {
+    matches: boolean;
+    breakpoints: {
+        [key: string]: boolean;
+    };
+}
+export declare class DfMediaQuery {
+    private readonly _isBrowser;
+    constructor(platformId: Object);
+    notSupported(query: string): Partial<MediaQueryList>;
+    matchMedia(query: string): MediaQueryList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfMediaQuery, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfMediaQuery>;
+}
+export declare class DfMediaObserver implements OnDestroy {
+    private readonly _mediaQuery;
+    private readonly _subscription;
+    private readonly _queries;
+    constructor(_mediaQuery: DfMediaQuery);
+    /**
+     * Verifies if at least one of the provided media-queries is matching
+     * the current viewport
+     */
+    matches(queries: string[] | string): boolean;
+    /**
+     * Produces an observable for a set of media-queries that will emit
+     * meta information for any changes of the given queries.
+     * @param value One or more media-queries to be observed.
+     * @returns A stream of matches meta object for the given media-queries.
+     */
+    observe(queries: string | string[]): Observable<MediaBreakpointsState>;
+    ngOnDestroy(): void;
+    private _flattenQueries;
+    private _registerQuery;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfMediaObserver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfMediaObserver>;
+}

package/lib/angular/modal/modal.service.d.ts

@@ -0,0 +1,13 @@
+import { NgbModalOptions, NgbModalRef } from '@ng-bootstrap/ng-bootstrap';
+import { NgbModal } from '@ng-bootstrap/ng-bootstrap';
+import { RendererFactory2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DfModalService {
+    private modalService;
+    private rendererFactory;
+    private renderer;
+    constructor(modalService: NgbModal, rendererFactory: RendererFactory2);
+    open(content: any, options?: NgbModalOptions): NgbModalRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfModalService>;
+}

package/lib/angular/popover/config/popover.config.d.ts

@@ -0,0 +1,8 @@
+import { NgbConfig, NgbPopoverConfig } from '@ng-bootstrap/ng-bootstrap';
+import * as i0 from "@angular/core";
+export declare class DfPopoverConfig extends NgbPopoverConfig {
+    autoClose: "outside";
+    constructor(ngbConfig?: NgbConfig);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfPopoverConfig, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfPopoverConfig>;
+}

package/lib/angular/popover/popover.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-bootstrap/ng-bootstrap";
+export declare class DfPopoverModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfPopoverModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfPopoverModule, never, never, [typeof i1.NgbPopoverModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfPopoverModule>;
+}

package/lib/angular/progressbar/progressbar.component.d.ts

@@ -0,0 +1,71 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class DfProgressbarComponent implements OnInit, OnDestroy {
+    infiniteAnimation: boolean;
+    /**
+     * Current value of the progressBar. If 'maxValue' is not defined, value represents a percentage. Otherwise, progress
+     * bar percentage value will be computed based on the ratio of 'value/maxValue'
+     */
+    private _value;
+    set value(newValue: number);
+    get value(): number;
+    private _maxValue;
+    set maxValue(newValue: number);
+    get maxValue(): number;
+    /**
+     * Text to be displayed on top of the progressbar
+     */
+    private _text;
+    set text(newText: string);
+    get text(): string;
+    /**
+     * Observable used to trigger the start of the loading.
+     * When emitting, progressbar will start to randomly increment toward 100%.
+     */
+    start$?: Observable<any>;
+    /**
+     * Observable used to trigger the end of the loading.
+     * When emitting, it forces the progressbar to reach 100%.
+     */
+    end$?: Observable<any>;
+    /**
+     * Id of the label used to describe the progress bar.
+     * It is used in priority compared to the ariaLabel.
+     */
+    ariaLabelledBy?: string;
+    /**
+     * Aria label used to describe the progress bar if no ariaLabelledBy is specified.
+     */
+    ariaLabel?: string;
+    private _percentageValue;
+    set percentageValue(newValue: number);
+    get percentageValue(): number;
+    percentageValueChange: EventEmitter<number>;
+    computedText: string;
+    displayProgressBar: boolean;
+    FADING_DELAY_MS: number;
+    private startSubscription?;
+    private endSubscription?;
+    private intervalId;
+    private animationOngoing;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private updateText;
+    private updatePercentageValue;
+    /**
+     * Randomly increase the percentage but making sure that it can never reach 100%
+     */
+    private increasePercentage;
+    /**
+     * Clears the 'setInterval' function so that the automatic increase of the progressbar stops
+     */
+    private stopAutomaticIncrement;
+    /**
+     * Periodically calls a function which increments the value of the progressbar
+     */
+    private startAutomaticIncrement;
+    private resetProgressBarValues;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfProgressbarComponent, "df-progressbar", never, { "infiniteAnimation": { "alias": "infiniteAnimation"; "required": false; }; "value": { "alias": "value"; "required": false; }; "maxValue": { "alias": "maxValue"; "required": false; }; "text": { "alias": "text"; "required": false; }; "start$": { "alias": "start$"; "required": false; }; "end$": { "alias": "end$"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "percentageValueChange": "percentageValueChange"; }, never, never, true, never>;
+}

package/lib/angular/progressbar/progressbar.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./progressbar.component";
+import * as i2 from "@ng-bootstrap/ng-bootstrap";
+export { DfProgressbarComponent } from './progressbar.component';
+export declare class DfProgressbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfProgressbarModule, never, [typeof i1.DfProgressbarComponent], [typeof i1.DfProgressbarComponent, typeof i2.NgbProgressbarModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfProgressbarModule>;
+}

package/lib/angular/progressindicator/default/default-spinner.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class DfDefaultSpinnerComponent {
+    isGlobalSpinner: boolean;
+    contentClass: string;
+    ariaLabel?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfDefaultSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfDefaultSpinnerComponent, "df-default-spinner", never, { "isGlobalSpinner": { "alias": "isGlobalSpinner"; "required": false; }; "contentClass": { "alias": "contentClass"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/angular/progressindicator/progressindicator-backdrop.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class DfProgressIndicatorBackdropComponent {
+    get classes(): string;
+    backdropClass?: string;
+    isGlobalBackdrop: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressIndicatorBackdropComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfProgressIndicatorBackdropComponent, "df-progressindicator-backdrop", never, { "backdropClass": { "alias": "backdropClass"; "required": false; }; "isGlobalBackdrop": { "alias": "isGlobalBackdrop"; "required": false; }; }, {}, never, never, true, never>;
+}