@design-factory/design-factory 19.1.2 → 20.0.0-next.0

package/index.d.ts

@@ -1,4 +1,1885 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, ElementRef, Renderer2, OnInit, OnDestroy, DoCheck, RendererFactory2, ComponentRef, EmbeddedViewRef, TemplateRef, Type, ComponentFactoryResolver, ApplicationRef, Injector, OnChanges, EventEmitter, ChangeDetectorRef, NgZone, SimpleChanges, AfterViewChecked, AfterContentInit, InjectionToken } from '@angular/core';
+import * as i2 from '@ng-bootstrap/ng-bootstrap';
+import { NgbDate, NgbDropdown, NgbDatepicker, NgbCalendar, NgbDateParserFormatter, NgbModal, NgbModalOptions, NgbModalRef, NgbPopoverConfig, NgbConfig } from '@ng-bootstrap/ng-bootstrap';
+import { Observable } from 'rxjs';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i4 from '@ng-select/ng-select';
+import { NgSelectComponent } from '@ng-select/ng-select';
+
+declare class SkipLinkDirective {
+    readonly inFocus: i0.WritableSignal<boolean>;
+    private readonly element;
+    private readonly document;
+    focusOnTarget(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkipLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkipLinkDirective, "[dfSkipLink]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SkipLinksContainerComponent {
+    private readonly links;
+    readonly inFocus: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkipLinksContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkipLinksContainerComponent, "df-skip-links-container", never, {}, {}, ["links"], ["*"], true, never>;
+}
+
+declare class DfAccessibilityModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAccessibilityModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfAccessibilityModule, never, [typeof SkipLinkDirective, typeof SkipLinksContainerComponent], [typeof SkipLinkDirective, typeof SkipLinksContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfAccessibilityModule>;
+}
+
+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>;
+}
+
+declare class DfInsertIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfInsertIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfInsertIconModule, never, [typeof DfInsertIconDirective], [typeof DfInsertIconDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfInsertIconModule>;
+}
+
+declare class DfToastModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfToastModule, never, [typeof DfInsertIconModule], [typeof i2.NgbToastModule, typeof DfInsertIconModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfToastModule>;
+}
+
+declare class DfAlertModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfAlertModule, never, [typeof DfInsertIconModule], [typeof i2.NgbAlertModule, typeof DfInsertIconModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfAlertModule>;
+}
+
 /**
- * Public API Surface of design-factory
+ * My dfDatepickerRange directive
  */
-export * from './lib/index';
+declare class DfDatepickerRangeDirective implements OnInit, OnDestroy, DoCheck, AfterViewInit {
+    private inputsElements;
+    private isDisabled;
+    private readonly siblingsNode;
+    private readonly removeListener;
+    private focusState;
+    private direction?;
+    private readonly renderer;
+    readonly el: ElementRef<any>;
+    private readonly dfDirectionServ;
+    private readonly platformId;
+    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>;
+}
+
+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>;
+}
+
+type DfDirection = 'append' | 'prepend';
+/**
+ * dfInputIcon directive
+ * @deprecated `DfInputIconDirective` is deprecated and will be removed in DF 21, in favor of pure css.
+ * To migrate and keep the same behavior, simply add the class `df-input-withicon` to the input element this directive was used on and remove the directive.
+ */
+declare class DfInputIconDirective implements OnInit, DoCheck, OnDestroy {
+    readonly dfInputIcon: i0.InputSignal<DfDirection[]>;
+    private button;
+    private removeListener?;
+    private isDisabled;
+    private readonly siblingsNode;
+    private readonly renderer;
+    private readonly el;
+    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": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DfAdvancedInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAdvancedInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfAdvancedInputModule, never, [typeof DfTriggerClickDirective, typeof DfInputIconDirective], [typeof DfTriggerClickDirective, typeof DfInputIconDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfAdvancedInputModule>;
+}
+
+declare class DfDatePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfDatePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfDatePickerModule, never, [typeof i2.NgbDropdownModule, typeof DfDatepickerRangeDirective], [typeof i2.NgbDatepickerModule, typeof DfAdvancedInputModule, typeof DfDatepickerRangeDirective, typeof i2.NgbDropdownModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfDatePickerModule>;
+}
+
+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 | null, typed: string): NgbDate | null;
+    updateFrom(typed: string): void;
+    updateTo(typed: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfDatepickerRangeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfDatepickerRangeService>;
+}
+
+/**
+ * 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
+ */
+declare class DfIfMediaDirective implements OnDestroy {
+    private _viewInstance;
+    /**
+     * 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...).
+     */
+    readonly dfIfMedia: i0.InputSignal<string | string[]>;
+    private readonly _viewContainerRef;
+    private readonly _template;
+    private readonly _mediaService;
+    private _subscription;
+    constructor();
+    ngOnDestroy(): void;
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfIfMediaDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfIfMediaDirective, "[dfIfMedia]", never, { "dfIfMedia": { "alias": "dfIfMedia"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DfMediaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfMediaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfMediaModule, never, [typeof DfIfMediaDirective], [typeof DfIfMediaDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfMediaModule>;
+}
+
+declare class DfFooterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfFooterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfFooterModule, never, [typeof DfMediaModule, typeof i2.NgbAccordionModule], [typeof DfMediaModule, typeof i2.NgbAccordionModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfFooterModule>;
+}
+
+declare class DfAmadeusIconComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAmadeusIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfAmadeusIconComponent, "df-amadeus-icon", never, {}, {}, never, never, true, never>;
+}
+
+declare class DfIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfIconModule, never, [typeof DfAmadeusIconComponent], [typeof DfAmadeusIconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfIconModule>;
+}
+
+/**
+ * @deprecated `DfModalService` is deprecated, use `NgbModal` from ng-bootstrap instead.
+ * Please note that `NgbModal` adds 'modal-open' class to the body while DfModalService adds 'df-modal-open' class. Both classes include the same styles, but you may need to update your stylesheets if you were overriding 'df-modal-open' in your application.
+ */
+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>;
+}
+
+declare class DfPopoverModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfPopoverModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfPopoverModule, never, never, [typeof i2.NgbPopoverModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfPopoverModule>;
+}
+
+declare class DfPopoverConfig extends NgbPopoverConfig {
+    autoClose: "outside";
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfPopoverConfig, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfPopoverConfig>;
+}
+
+declare class DfProgressbarComponent implements OnInit, OnDestroy {
+    readonly PERCENTAGE_PLACEHOLDER = "%PERCENTAGE%";
+    readonly FADING_DELAY_MS = 1500;
+    readonly infiniteAnimation: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * 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'
+     */
+    readonly value: i0.InputSignalWithTransform<number, unknown>;
+    readonly maxValue: i0.InputSignalWithTransform<number, unknown>;
+    readonly innerValue: i0.WritableSignal<number>;
+    readonly percentageValue: i0.Signal<number>;
+    readonly percentageValueChange: i0.OutputEmitterRef<number>;
+    /**
+     * Observable used to trigger the start of the loading.
+     * When emitting, progressbar will start to randomly increment toward 100%.
+     */
+    readonly start$: i0.InputSignal<Observable<any> | undefined>;
+    /**
+     * Observable used to trigger the end of the loading.
+     * When emitting, it forces the progressbar to reach 100%.
+     */
+    readonly end$: i0.InputSignal<Observable<any> | undefined>;
+    /**
+     * Id of the label used to describe the progress bar.
+     * It is used in priority compared to the ariaLabel.
+     */
+    readonly ariaLabelledBy: i0.InputSignal<string | undefined>;
+    /**
+     * Aria label used to describe the progress bar if no ariaLabelledBy is specified.
+     */
+    readonly ariaLabel: i0.InputSignal<string | undefined>;
+    readonly text: i0.InputSignal<string>;
+    readonly computedText: i0.Signal<string>;
+    readonly displayProgressBar: i0.WritableSignal<boolean>;
+    private startSubscription?;
+    private endSubscription?;
+    private intervalId;
+    private animationOngoing;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * 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; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "start$": { "alias": "start$"; "required": false; "isSignal": true; }; "end$": { "alias": "end$"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "percentageValueChange": "percentageValueChange"; }, never, never, true, never>;
+}
+
+declare class DfProgressbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfProgressbarModule, never, [typeof DfProgressbarComponent], [typeof DfProgressbarComponent, typeof i2.NgbProgressbarModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfProgressbarModule>;
+}
+
+declare class DfDefaultSpinnerComponent {
+    readonly isGlobalSpinner: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly contentClass: i0.InputSignal<string>;
+    readonly ariaLabel: i0.InputSignal<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfDefaultSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfDefaultSpinnerComponent, "df-default-spinner", never, { "isGlobalSpinner": { "alias": "isGlobalSpinner"; "required": false; "isSignal": true; }; "contentClass": { "alias": "contentClass"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DfProgressIndicatorBackdropComponent {
+    readonly backdropClass: i0.InputSignal<string | undefined>;
+    readonly isGlobalBackdrop: i0.InputSignal<boolean>;
+    readonly classes: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressIndicatorBackdropComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfProgressIndicatorBackdropComponent, "df-progressindicator-backdrop", never, { "backdropClass": { "alias": "backdropClass"; "required": false; "isSignal": true; }; "isGlobalBackdrop": { "alias": "isGlobalBackdrop"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DfProgressIndicatorOptions {
+    /**
+     * If `true`, the backdrop element will be created for a given progress indicator.
+     * Default value is `true`.
+     */
+    backdrop?: boolean;
+    /**
+     * A selector specifying the progress indicator elements should be appended to.
+     * If not specified, will be `body`.
+     */
+    container?: string | HTMLElement;
+    /**
+     * A custom class to append to the progress indicator container.
+     */
+    containerClass?: string;
+    /**
+     * Specify the position of the content in the container.
+     */
+    position?: DfProgressIndicatorContentPosition;
+    /**
+     * A custom class to append to the progress indicator backdrop.
+     */
+    backdropClass?: string;
+}
+declare enum DfProgressIndicatorContentType {
+    SPINNER = "spinner",
+    PROGRESSBAR = "progressbar"
+}
+declare class DfProgressIndicatorContentSpinner {
+    readonly type = DfProgressIndicatorContentType.SPINNER;
+    spinnerInput?: {
+        contentClass?: string;
+        ariaLabel?: string;
+    };
+    constructor(spinnerInput?: {
+        contentClass?: string;
+        ariaLabel?: string;
+    });
+}
+declare class DfProgressIndicatorContentProgressBar {
+    readonly type = DfProgressIndicatorContentType.PROGRESSBAR;
+    progressBarInput?: {
+        ariaLabel: string;
+    };
+    position: DfProgressIndicatorContentPosition;
+    constructor(progressBarInput?: {
+        ariaLabel: string;
+    }, position?: DfProgressIndicatorContentPosition);
+}
+declare enum DfProgressIndicatorContentPosition {
+    TOP = "top",
+    BOTTOM = "bottom",
+    CENTERED = "centered"
+}
+
+declare class DfProgressIndicatorContainerComponent {
+    private readonly DEFAULT_CLASS_POSITION;
+    readonly containerClass: i0.InputSignal<string | undefined>;
+    readonly position: i0.InputSignal<DfProgressIndicatorContentPosition | undefined>;
+    readonly positionClass: i0.Signal<"df-progressindicator-centered" | "df-progressindicator-top" | "df-progressindicator-bottom">;
+    readonly classes: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressIndicatorContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfProgressIndicatorContainerComponent, "df-progressindicator-container", never, { "containerClass": { "alias": "containerClass"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class DfProgressIndicatorRef {
+    containerRef: ComponentRef<DfProgressIndicatorContainerComponent>;
+    contentRef: ComponentRef<unknown> | EmbeddedViewRef<unknown>;
+    backdropRef?: ComponentRef<DfProgressIndicatorBackdropComponent> | undefined;
+    constructor(containerRef: ComponentRef<DfProgressIndicatorContainerComponent>, contentRef: ComponentRef<unknown> | EmbeddedViewRef<unknown>, backdropRef?: ComponentRef<DfProgressIndicatorBackdropComponent> | undefined);
+}
+
+/** Type for the callback used to revert the scrollbar compensation. */
+type CompensationReverter = () => void;
+/**
+ * Utility to handle the scrollbar.
+ *
+ * It allows to compensate the lack of a vertical scrollbar by adding an
+ * equivalent padding on the right of the body, and to remove this compensation.
+ *
+ * It is a copy of https://github.com/ng-bootstrap/ng-bootstrap/blob/master/src/util/scrollbar.ts
+ */
+declare class ScrollBar {
+    private readonly _document;
+    constructor(_document: any);
+    /**
+     * To be called right before a potential vertical scrollbar would be removed:
+     *
+     * - if there was a scrollbar, adds some compensation padding to the body
+     * to keep the same layout as when the scrollbar is there
+     * - if there was none, there is nothing to do
+     *
+     * @return a callback used to revert the compensation (noop if there was none,
+     * otherwise a function removing the padding)
+     */
+    compensate(): CompensationReverter;
+    /**
+     * Adds a padding of the given width on the right of the body.
+     *
+     * @return a callback used to revert the padding to its previous value
+     */
+    private _adjustBody;
+    /**
+     * Tells whether a scrollbar is currently present on the body.
+     *
+     * @return true if scrollbar is present, false otherwise
+     */
+    private _isPresent;
+    /**
+     * Calculates and returns the width of a scrollbar.
+     *
+     * @return the width of a scrollbar on this page
+     */
+    private _getWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollBar, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollBar>;
+}
+
+type DfProgressIndicatorContent<T> = undefined | TemplateRef<T> | Type<T> | DfProgressIndicatorContentSpinner | DfProgressIndicatorContentProgressBar;
+declare class DfProgressIndicatorService {
+    private readonly document;
+    private readonly rendererFactory;
+    private readonly componentFactoryResolver;
+    private readonly appRef;
+    private readonly injector;
+    private readonly scrollbar;
+    private readonly renderer;
+    private readonly BODY_CLASS;
+    private readonly containerAttributes;
+    private readonly backdropAttributes;
+    private readonly defaultSpinnerAttributes;
+    private readonly defaultProgressBarAttributes;
+    private readonly activeInstances;
+    constructor(document: Document, rendererFactory: RendererFactory2, componentFactoryResolver: ComponentFactoryResolver, appRef: ApplicationRef, injector: Injector, scrollbar: ScrollBar);
+    open<T>(content: DfProgressIndicatorContent<T>, options?: DfProgressIndicatorOptions): DfProgressIndicatorRef;
+    close(progressIndicatorRef: DfProgressIndicatorRef): void;
+    /**
+     * Retrieve container according to the desired options.
+     */
+    private getContainer;
+    private getContent;
+    private createComponent;
+    private applyOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressIndicatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfProgressIndicatorService>;
+}
+
+declare class DfProgressIndicatorDirective {
+    readonly dfProgressIndicator: i0.InputSignal<boolean>;
+    readonly dfProgressIndicatorConfig: i0.InputSignal<{
+        content?: DfProgressIndicatorContent<unknown>;
+        options: DfProgressIndicatorOptions;
+    } | undefined>;
+    private readonly elementRef;
+    private readonly progressService;
+    private progressIndicatorRef;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfProgressIndicatorDirective, "[dfProgressIndicator]", never, { "dfProgressIndicator": { "alias": "dfProgressIndicator"; "required": true; "isSignal": true; }; "dfProgressIndicatorConfig": { "alias": "dfProgressIndicatorConfig"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DfProgressIndicatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressIndicatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfProgressIndicatorModule, never, [typeof DfDefaultSpinnerComponent, typeof DfProgressbarModule, typeof DfProgressIndicatorBackdropComponent, typeof DfProgressIndicatorContainerComponent, typeof DfProgressIndicatorDirective], [typeof DfProgressbarModule, typeof DfProgressIndicatorContainerComponent, typeof DfProgressIndicatorDirective, typeof DfProgressIndicatorBackdropComponent, typeof DfDefaultSpinnerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfProgressIndicatorModule>;
+}
+
+declare enum RightToLeftDirectionEnum {
+    LeftToRight = "ltr",
+    RightToLeft = "rtl",
+    Auto = "auto"
+}
+declare class DfDirectionDetectionService {
+    getPageDirection(element: ElementRef): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfDirectionDetectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfDirectionDetectionService>;
+}
+
+/** Pointer type */
+declare enum PointerType {
+    /** Low pointer */
+    Min = 0,
+    /** High pointer */
+    Max = 1
+}
+
+/** Label type */
+declare enum LabelType {
+    /** Label above low pointer */
+    Low = 0,
+    /** Label above high pointer */
+    High = 1,
+    /** Label for minimum slider value */
+    Floor = 2,
+    /** Label for maximum slider value */
+    Ceil = 3,
+    /** Label below legend tick */
+    TickValue = 4
+}
+/** Function to translate label value into text */
+type TranslateFunction = (value: number, label: LabelType) => string;
+/** Function to combind */
+type CombineLabelsFunction = (minLabel: string, maxLabel: string) => string;
+/** Function to provide legend  */
+type GetLegendFunction = (value: number) => string;
+type GetStepLegendFunction = (step: CustomStepDefinition) => string;
+/** Function converting slider value to slider position */
+type ValueToPositionFunction = (val: number, minVal: number, maxVal: number) => number;
+/** Function converting slider position to slider value */
+type PositionToValueFunction = (percent: number, minVal: number, maxVal: number) => number;
+/**
+ * Custom step definition
+ *
+ * This can be used to specify custom values and legend values for slider ticks
+ */
+interface CustomStepDefinition {
+    /** Value */
+    value: number;
+    /** Legend (label for the value) */
+    legend?: string;
+}
+/** Slider options */
+declare class Options {
+    /** Minimum value for a slider.
+      Not applicable when using stepsArray. */
+    floor?: number;
+    /** Maximum value for a slider.
+      Not applicable when using stepsArray. */
+    ceil?: number;
+    /** Step between each value.
+      Not applicable when using stepsArray. */
+    step?: number;
+    /** The minimum range authorized on the slider.
+      Applies to range slider only.
+      When using stepsArray, expressed as index into stepsArray. */
+    minRange?: number;
+    /** The maximum range authorized on the slider.
+      Applies to range slider only.
+      When using stepsArray, expressed as index into stepsArray. */
+    maxRange?: number;
+    /** Set to true to have a push behavior. When the min handle goes above the max,
+      the max is moved as well (and vice-versa). The range between min and max is
+      defined by the step option (defaults to 1) and can also be overriden by
+      the minRange option. Applies to range slider only. */
+    pushRange?: boolean;
+    /** The minimum value authorized on the slider.
+      When using stepsArray, expressed as index into stepsArray. */
+    minLimit?: number;
+    /** The maximum value authorized on the slider.
+      When using stepsArray, expressed as index into stepsArray. */
+    maxLimit?: number;
+    /** Custom translate function. Use this if you want to translate values displayed
+        on the slider. */
+    translate?: TranslateFunction;
+    /** Custom function for combining overlapping labels in range slider.
+        It takes the min and max values (already translated with translate fuction)
+        and should return how these two values should be combined.
+        If not provided, the default function will join the two values with
+        ' - ' as separator. */
+    combineLabels?: CombineLabelsFunction;
+    /** Use to display legend under ticks (thus, it needs to be used along with
+       showTicks or showTicksValues). The function will be called with each tick
+       value and returned content will be displayed under the tick as a legend.
+       If the returned value is null, then no legend is displayed under
+       the corresponding tick.You can also directly provide the legend values
+       in the stepsArray option. */
+    getLegend?: GetLegendFunction;
+    /** Use to display a custom legend of a stepItem from stepsArray.
+     It will be the same as getLegend but for stepsArray. */
+    getStepLegend?: GetStepLegendFunction;
+    /** If you want to display a slider with non linear/number steps.
+       Just pass an array with each slider value and that's it; the floor, ceil and step settings
+       of the slider will be computed automatically.
+       By default, the value model and valueHigh model values will be the value of the selected item
+       in the stepsArray.
+       They can also be bound to the index of the selected item by setting the bindIndexForStepsArray
+       option to true. */
+    stepsArray?: CustomStepDefinition[];
+    /** Set to true to bind the index of the selected item to value model and valueHigh model. */
+    bindIndexForStepsArray?: boolean;
+    /** When set to true and using a range slider, the range can be dragged by the selection bar.
+      Applies to range slider only. */
+    draggableRange?: boolean;
+    /** Same as draggableRange but the slider range can't be changed.
+      Applies to range slider only. */
+    draggableRangeOnly?: boolean;
+    /** Set to true to always show the selection bar before the slider handle. */
+    showSelectionBar?: boolean;
+    /** Set to true to always show the selection bar after the slider handle. */
+    showSelectionBarEnd?: boolean;
+    /**  Set a number to draw the selection bar between this value and the slider handle.
+      When using stepsArray, expressed as index into stepsArray. */
+    showSelectionBarFromValue?: number;
+    /**  Only for range slider. Set to true to visualize in different colour the areas
+      on the left/right (top/bottom for vertical range slider) of selection bar between the handles. */
+    showOuterSelectionBars?: boolean;
+    /** Set to true to hide pointer labels */
+    hidePointerLabels?: boolean;
+    /** Set to true to hide min / max labels  */
+    hideLimitLabels?: boolean;
+    /** Set to false to disable the auto-hiding behavior of the limit labels. */
+    autoHideLimitLabels?: boolean;
+    /** Set to true to make the slider read-only. */
+    readOnly?: boolean;
+    /** Set to true to disable the slider. */
+    disabled?: boolean;
+    /** Set to true to display a tick for each step of the slider. */
+    showTicks?: boolean;
+    /** Set to true to display a tick and the step value for each step of the slider.. */
+    showTicksValues?: boolean;
+    tickStep?: number;
+    tickValueStep?: number;
+    /** Use to display ticks at specific positions.
+      The array contains the index of the ticks that should be displayed.
+      For example, [0, 1, 5] will display a tick for the first, second and sixth values. */
+    ticksArray?: number[];
+    /** Used to display a tooltip when a tick is hovered.
+      Set to a function that returns the tooltip content for a given value. */
+    ticksTooltip?: (value: number) => string;
+    /** Same as ticksTooltip but for ticks values. */
+    ticksValuesTooltip?: (value: number) => string;
+    /** Set to true to display the slider vertically.
+      The slider will take the full height of its parent.
+      Changing this value at runtime is not currently supported. */
+    vertical?: boolean;
+    /** Function that returns the current color of the selection bar.
+      If your color won't change, don't use this option but set it through CSS.
+      If the returned color depends on a model value (either value or valueHigh),
+      you should use the argument passed to the function.
+      Indeed, when the function is called, there is no certainty that the model
+      has already been updated.*/
+    getSelectionBarColor?: (minValue: number, maxValue?: number) => string;
+    /** Function that returns the color of a tick. showTicks must be enabled. */
+    getTickColor?: (value: number) => string;
+    /** Function that returns the current color of a pointer.
+      If your color won't change, don't use this option but set it through CSS.
+      If the returned color depends on a model value (either value or valueHigh),
+      you should use the argument passed to the function.
+      Indeed, when the function is called, there is no certainty that the model has already been updated.
+      To handle range slider pointers independently, you should evaluate pointerType within the given
+      function where "min" stands for value model and "max" for valueHigh model values. */
+    getPointerColor?: (value: number, pointerType: PointerType) => string;
+    /** Handles are focusable (on click or with tab) and can be modified using the following keyboard controls:
+      Left/bottom arrows: -1
+      Right/top arrows: +1
+      Page-down: -10%
+      Page-up: +10%
+      Home: minimum value
+      End: maximum value
+     */
+    keyboardSupport?: boolean;
+    /** If you display the slider in an element that uses transform: scale(0.5), set the scale value to 2
+      so that the slider is rendered properly and the events are handled correctly. */
+    scale?: number;
+    /** If you display the slider in an element that uses transform: rotate(90deg), set the rotate value to 90
+     so that the slider is rendered properly and the events are handled correctly. Value is in degrees. */
+    rotate?: number;
+    /** Set to true to force the value(s) to be rounded to the step, even when modified from the outside.
+      When set to false, if the model values are modified from outside the slider, they are not rounded
+      and can be between two steps. */
+    enforceStep?: boolean;
+    /** Set to true to force the value(s) to be normalised to allowed range (floor to ceil), even when modified from the outside.
+      When set to false, if the model values are modified from outside the slider, and they are outside allowed range,
+      the slider may be rendered incorrectly. However, setting this to false may be useful if you want to perform custom normalisation. */
+    enforceRange?: boolean;
+    /** Set to true to force the value(s) to be rounded to the nearest step value, even when modified from the outside.
+      When set to false, if the model values are modified from outside the slider, and they are outside allowed range,
+      the slider may be rendered incorrectly. However, setting this to false may be useful if you want to perform custom normalisation. */
+    enforceStepsArray?: boolean;
+    /** Set to true to prevent to user from switching the min and max handles. Applies to range slider only. */
+    noSwitching?: boolean;
+    /** Set to true to only bind events on slider handles. */
+    onlyBindHandles?: boolean;
+    /** Set to true to show graphs right to left.
+      If vertical is true it will be from top to bottom and left / right arrow functions reversed. */
+    rightToLeft?: boolean;
+    /** Set to true to reverse keyboard navigation:
+      Right/top arrows: -1
+      Left/bottom arrows: +1
+      Page-up: -10%
+      Page-down: +10%
+      End: minimum value
+      Home: maximum value
+     */
+    reversedControls?: boolean;
+    /** Set to true to keep the slider labels inside the slider bounds. */
+    boundPointerLabels?: boolean;
+    /** Set to true to use a logarithmic scale to display the slider.  */
+    logScale?: boolean;
+    /** Function that returns the position on the slider for a given value.
+      The position must be a percentage between 0 and 1.
+      The function should be monotonically increasing or decreasing; otherwise the slider may behave incorrectly. */
+    customValueToPosition?: ValueToPositionFunction;
+    /** Function that returns the value for a given position on the slider.
+      The position is a percentage between 0 and 1.
+      The function should be monotonically increasing or decreasing; otherwise the slider may behave incorrectly. */
+    customPositionToValue?: PositionToValueFunction;
+    /** Precision limit for calculated values.
+      Values used in calculations will be rounded to this number of significant digits
+      to prevent accumulating small floating-point errors. */
+    precisionLimit?: number;
+    /** Use to display the selection bar as a gradient.
+      The given object must contain from and to properties which are colors. */
+    selectionBarGradient?: {
+        from: string;
+        to: string;
+    };
+    /** Use to add a label directly to the slider for accessibility. Adds the aria-label attribute. */
+    ariaLabel?: string;
+    /** Use instead of ariaLabel to reference the id of an element which will be used to label the slider.
+      Adds the aria-labelledby attribute. */
+    ariaLabelledBy?: string;
+    /** Use to add a label directly to the slider range for accessibility. Adds the aria-label attribute. */
+    ariaLabelHigh?: string;
+    /** Use instead of ariaLabelHigh to reference the id of an element which will be used to label the slider range.
+      Adds the aria-labelledby attribute. */
+    ariaLabelledByHigh?: string;
+    /** Use to increase rendering performance. If the value is not provided, the slider calculates the with/height of the handle */
+    handleDimension?: number;
+    /** Use to increase rendering performance. If the value is not provided, the slider calculates the with/height of the bar */
+    barDimension?: number;
+    /** Enable/disable CSS animations */
+    animate?: boolean;
+    /** Enable/disable CSS animations while moving the slider */
+    animateOnMove?: boolean;
+}
+
+declare class ChangeContext {
+    value?: number;
+    highValue?: number;
+    pointerType?: PointerType;
+}
+
+declare class Tick {
+    selected: boolean;
+    style: any;
+    tooltip?: string;
+    tooltipPlacement?: string;
+    value?: string;
+    valueTooltip?: string;
+    valueTooltipPlacement?: string;
+    legend?: string;
+}
+/**
+ * @deprecated SliderComponent is deprecated. Use {@link https://design-factory.amadeus.net/components/slider/agnosui AgnosUI Slider} instead.
+ */
+declare class SliderComponent implements OnInit, AfterViewInit, OnChanges, OnDestroy, ControlValueAccessor {
+    private renderer;
+    private elementRef;
+    private changeDetectionRef;
+    private zone;
+    class: string;
+    value?: number;
+    valueChange: EventEmitter<number>;
+    highValue?: number;
+    highValueChange: EventEmitter<number>;
+    options: Options;
+    userChangeStart: EventEmitter<ChangeContext>;
+    userChange: EventEmitter<ChangeContext>;
+    userChangeEnd: EventEmitter<ChangeContext>;
+    private manualRefreshSubscription;
+    set manualRefresh(manualRefresh: EventEmitter<void>);
+    private triggerFocusSubscription;
+    set triggerFocus(triggerFocus: EventEmitter<void>);
+    get range(): boolean;
+    private initHasRun;
+    private inputModelChangeSubject;
+    private inputModelChangeSubscription?;
+    private outputModelChangeSubject;
+    private outputModelChangeSubscription?;
+    private viewLowValue?;
+    private viewHighValue?;
+    private viewOptions;
+    private handleHalfDimension;
+    private maxHandlePosition;
+    private currentTrackingPointer?;
+    private currentFocusPointer?;
+    private firstKeyDown;
+    private touchId?;
+    private dragging;
+    private leftOuterSelectionBarElement?;
+    private rightOuterSelectionBarElement?;
+    private fullBarElement?;
+    private selectionBarElement?;
+    private minHandleElement?;
+    private maxHandleElement?;
+    private floorLabelElement?;
+    private ceilLabelElement?;
+    private minHandleLabelElement?;
+    private maxHandleLabelElement?;
+    private combinedLabelElement?;
+    private ticksElement?;
+    tooltipTemplate: TemplateRef<any>;
+    sliderElementVerticalClass: boolean;
+    sliderElementAnimateClass: boolean;
+    sliderElementWithLegendClass: boolean;
+    sliderElementDisabledAttr?: string;
+    sliderElementAriaLabel: string;
+    barStyle: any;
+    minPointerStyle: any;
+    maxPointerStyle: any;
+    fullBarTransparentClass: boolean;
+    selectionBarDraggableClass: boolean;
+    ticksUnderValuesClass: boolean;
+    get showTicks(): boolean;
+    private intermediateTicks;
+    ticks: Tick[];
+    private eventListenerHelper?;
+    private onMoveEventListener?;
+    private onEndEventListener?;
+    private moving;
+    private resizeObserver?;
+    private onTouchedCallback?;
+    private onChangeCallback?;
+    constructor(renderer: Renderer2, elementRef: ElementRef, changeDetectionRef: ChangeDetectorRef, zone: NgZone);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    writeValue(obj: any): void;
+    registerOnChange(onChangeCallback: any): void;
+    registerOnTouched(onTouchedCallback: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    setAriaLabel(ariaLabel: string): void;
+    onResize(event: any): void;
+    private subscribeInputModelChangeSubject;
+    private subscribeOutputModelChangeSubject;
+    private subscribeResizeObserver;
+    private unsubscribeResizeObserver;
+    private unsubscribeOnMove;
+    private unsubscribeOnEnd;
+    private unsubscribeInputModelChangeSubject;
+    private unsubscribeOutputModelChangeSubject;
+    private unsubscribeManualRefresh;
+    private unsubscribeTriggerFocus;
+    private getPointerElement;
+    private getCurrentTrackingValue;
+    private modelValueToViewValue;
+    private viewValueToModelValue;
+    private getStepValue;
+    private applyViewChange;
+    private applyInputModelChange;
+    private publishOutputModelChange;
+    private normaliseModelValues;
+    private renormaliseModelValues;
+    private onChangeOptions;
+    private applyOptions;
+    private applyStepsArrayOptions;
+    private applyFloorCeilOptions;
+    private resetSlider;
+    private focusPointer;
+    private refocusPointerIfNeeded;
+    private manageElementsStyle;
+    private manageEventsBindings;
+    private updateDisabledState;
+    private updateAriaLabel;
+    private updateVerticalState;
+    private updateScale;
+    private updateRotate;
+    private getAllSliderElements;
+    private initHandles;
+    private addAccessibility;
+    private updateAriaAttributes;
+    private calculateViewDimensions;
+    private calculateViewDimensionsAndDetectChanges;
+    /**
+     * If the slider reference is already destroyed
+     * @returns boolean - true if ref is destroyed
+     */
+    private isRefDestroyed;
+    private updateTicksScale;
+    private getTicksArray;
+    private isTickSelected;
+    private updateFloorLabel;
+    private updateCeilLabel;
+    private updateHandles;
+    private getHandleLabelPos;
+    private updateLowHandle;
+    private updateHighHandle;
+    private updateFloorAndCeilLabelsVisibility;
+    private isLabelBelowFloorLabel;
+    private isLabelAboveCeilLabel;
+    private updateSelectionBar;
+    private getSelectionBarColor;
+    private getPointerColor;
+    private getTickColor;
+    private updateCombinedLabel;
+    private getDisplayValue;
+    private roundStep;
+    private valueToPosition;
+    private positionToValue;
+    private getEventXY;
+    private getEventPosition;
+    private getNearestHandle;
+    private bindEvents;
+    private getOptionsInfluencingEventBindings;
+    private unbindEvents;
+    private onBarStart;
+    private onStart;
+    private onMove;
+    private onEnd;
+    private onPointerFocus;
+    private onKeyUp;
+    private onPointerBlur;
+    private getKeyActions;
+    private onKeyboardEvent;
+    private onDragStart;
+    /** Get min value depending on whether the newPos is outOfBounds above or below the bar and rightToLeft */
+    private getMinValue;
+    /** Get max value depending on whether the newPos is outOfBounds above or below the bar and rightToLeft */
+    private getMaxValue;
+    private onDragMove;
+    private positionTrackingBar;
+    private positionTrackingHandle;
+    private applyMinMaxLimit;
+    private applyMinMaxRange;
+    private applyPushRange;
+    private getChangeContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SliderComponent, "ngx-slider", never, { "value": { "alias": "value"; "required": false; }; "highValue": { "alias": "highValue"; "required": false; }; "options": { "alias": "options"; "required": false; }; "manualRefresh": { "alias": "manualRefresh"; "required": false; }; "triggerFocus": { "alias": "triggerFocus"; "required": false; }; }, { "valueChange": "valueChange"; "highValueChange": "highValueChange"; "userChangeStart": "userChangeStart"; "userChange": "userChange"; "userChangeEnd": "userChangeEnd"; }, ["tooltipTemplate"], never, true, never>;
+}
+
+/**
+ * @deprecated SliderElementDirective is deprecated. Use {@link https://design-factory.amadeus.net/components/slider/agnosui AgnosUI Slider} instead.
+ */
+declare class SliderElementDirective {
+    protected elemRef: ElementRef;
+    protected renderer: Renderer2;
+    protected changeDetectionRef: ChangeDetectorRef;
+    private _position;
+    get position(): number;
+    private _dimension;
+    get dimension(): number;
+    private _alwaysHide;
+    get alwaysHide(): boolean;
+    private _vertical;
+    get vertical(): boolean;
+    private _scale;
+    get scale(): number;
+    private _rotate;
+    get rotate(): number;
+    opacity: number;
+    visibility: string;
+    left: string;
+    bottom: string;
+    height: string;
+    width: string;
+    transform: string;
+    private eventListenerHelper;
+    private eventListeners;
+    private readonly platformId;
+    constructor(elemRef: ElementRef, renderer: Renderer2, changeDetectionRef: ChangeDetectorRef);
+    setAlwaysHide(hide: boolean): void;
+    hide(): void;
+    show(): void;
+    isVisible(): boolean;
+    setVertical(vertical: boolean): void;
+    setScale(scale: number): void;
+    setRotate(rotate: number): void;
+    getRotate(): number;
+    setPosition(pos: number): void;
+    calculateDimension(): void;
+    setDimension(dim: number): void;
+    getBoundingClientRect(): ClientRect;
+    on(eventName: string, callback: (event: any) => void, debounceInterval?: number): void;
+    onPassive(eventName: string, callback: (event: any) => void, debounceInterval?: number): void;
+    off(eventName?: string): void;
+    private isRefDestroyed;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderElementDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SliderElementDirective, "[ngxSliderElement]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated SliderHandleDirective is deprecated. Use {@link https://design-factory.amadeus.net/components/slider/agnosui AgnosUI Slider} instead.
+ */
+declare class SliderHandleDirective extends SliderElementDirective {
+    active: boolean;
+    role: string;
+    tabindex: string;
+    ariaOrientation: string;
+    ariaLabel: string;
+    ariaLabelledBy: string;
+    ariaValueNow: string;
+    ariaValueText: string;
+    ariaValueMin: string;
+    ariaValueMax: string;
+    constructor(elemRef: ElementRef, renderer: Renderer2, changeDetectionRef: ChangeDetectorRef);
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderHandleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SliderHandleDirective, "[ngxSliderHandle]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated SliderLabelDirective is deprecated. Use {@link https://design-factory.amadeus.net/components/slider/agnosui AgnosUI Slider} instead.
+ */
+declare class SliderLabelDirective extends SliderElementDirective {
+    private _value?;
+    get value(): string;
+    constructor(elemRef: ElementRef, renderer: Renderer2, changeDetectionRef: ChangeDetectorRef);
+    setValue(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SliderLabelDirective, "[ngxSliderLabel]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated TooltipWrapperComponent is deprecated. Use {@link https://design-factory.amadeus.net/components/slider/agnosui AgnosUI Slider} instead.
+ */
+declare class TooltipWrapperComponent {
+    template?: TemplateRef<any>;
+    tooltip?: string;
+    placement?: string;
+    content?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipWrapperComponent, "ngx-slider-tooltip-wrapper", never, { "template": { "alias": "template"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated DfSliderDirectionDirective is deprecated. Use {@link https://design-factory.amadeus.net/components/slider/agnosui AgnosUI Slider} instead.
+ */
+declare class DfSliderDirectionDirective implements OnInit {
+    readonly dfSliderDirection: i0.InputSignal<any>;
+    private readonly elementRef;
+    private readonly rtlDirectionService;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSliderDirectionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfSliderDirectionDirective, "[dfSliderDirection]", never, { "dfSliderDirection": { "alias": "dfSliderDirection"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated DfSliderModule is deprecated.
+ * Use {@link https://design-factory.amadeus.net/components/slider/agnosui  AgnosUI Slider} instead.
+ */
+declare class DfSliderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSliderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfSliderModule, never, [typeof SliderComponent, typeof SliderElementDirective, typeof SliderHandleDirective, typeof SliderLabelDirective, typeof TooltipWrapperComponent, typeof DfSliderDirectionDirective], [typeof DfSliderDirectionDirective, typeof SliderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfSliderModule>;
+}
+
+/**
+ * A configuration service for the [DfSideNavService](#/components/sidenav/api#DfSideNavComponent) component.
+ *
+ * You can inject this service, typically in your root component, and customize its properties
+ * to provide default values for your sidenav used in the application.
+ */
+declare class DfSideNavConfig {
+    isMinmized: boolean;
+    isCollapsed: boolean;
+    isPresent: boolean;
+    isInMenuOverlay: boolean;
+    isAppOverlay: boolean;
+    isAppOverlayMode: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavConfig, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfSideNavConfig>;
+}
+
+interface DfSideNavItem {
+    value: string;
+    title?: string;
+    icon?: string | TemplateRef<any>;
+    isExternal?: boolean;
+    isActive?: boolean;
+    isCollapsed?: boolean;
+    breakpoints?: string[];
+    subMenus?: DfSideNavItem[];
+    type?: DfNavItemType;
+    class?: string;
+}
+declare enum DfNavItemType {
+    subMenus = 0,
+    actionButton = 1,
+    routerLink = 2,
+    link = 3,
+    externalLink = 4,
+    separator = 5,
+    template = 6,
+    title = 7
+}
+/**
+ * A service for managing the sidenav panel.
+ * This service is included at root level
+ *
+ * Creating a sidenav is straightforward: use [DfSideNavComponent](#/components/sidenav/api#DfSideNavComponent) component
+ */
+declare class DfSideNavService implements OnDestroy {
+    private readonly config;
+    type: typeof DfNavItemType;
+    private readonly _sideNavItems$;
+    private readonly _isMinmized$;
+    private readonly _isCollapsed$;
+    private readonly _isPresent$;
+    private readonly _activeItem$;
+    private readonly _isInMenuOverlay$;
+    private readonly _isAppOverlay$;
+    private _isAppOverlayMode;
+    private _items;
+    private readonly subscription;
+    constructor(config: DfSideNavConfig);
+    ngOnDestroy(): void;
+    /**
+     * Use this to init the list of Elements from your sidenav
+     *
+     *
+     * Second option withRouter is to be set to false if you are not passing link string for the angular Router
+     * Here we are not deep copying the array --> the function will change it
+     */
+    initItems(items: DfSideNavItem[], withRouter?: boolean): void;
+    /**
+     * Use this to inactivate the list of Elements from your sidenav
+     * isActive properties of all items will be set to false recursively
+     *
+     */
+    inactiveItems(list: DfSideNavItem[]): void;
+    /**
+     * Use this to active the item pass as input
+     * This function inactivate all the other items of the service
+     * It will then dispatch the list of items of the sideNav to activeItem$
+     *
+     */
+    activeItem(item: DfSideNavItem): void;
+    /**
+     * Getter to know when to put/remove the overlay.
+     * `True` in case of overlay needed
+     *
+     */
+    get isAppOverlay$(): Observable<boolean>;
+    /**
+     * Getter to know if the sidenav is in an overlay panel or not
+     * `True` in case of overlay panel
+     *
+     */
+    get isInMenuOverlay$(): Observable<boolean>;
+    /**
+     * Getter to know the current activeItem a user clicked on
+     *
+     */
+    get activeItem$(): Observable<DfSideNavItem | null>;
+    /**
+     * Getter to know if the sideNav is present in the page
+     * SideNav may be collapsed here or not
+     *
+     */
+    get isPresent$(): Observable<boolean>;
+    /**
+     * Future Options
+     */
+    get isMinimized$(): Observable<boolean>;
+    /**
+     * Getter to know if the SideNav is collapsed or not
+     * If `true` the SideNav is collapsed
+     *
+     */
+    get isCollapsed$(): Observable<boolean>;
+    /**
+     * Getter of the SideNav Items after they have beens changed
+     *
+     */
+    get sideNavItems$(): Observable<DfSideNavItem[]>;
+    /**
+     * Getter to know the mode Apply for the SideNav
+     * If `true` the SideNav can be in overlay (but not necessary is).
+     *
+     */
+    get isAppOverlayMode(): boolean;
+    get items(): DfSideNavItem[];
+    /**
+     * Use this to toggle a SideNav Item (either from expand to collapse or the other way around).
+     * isCollapsed attribute of the input item is changed.
+     * All items are push again to the stream of items.
+     * This is used internally by the SideNav in case of click and Enter on an Item with subMenus
+     */
+    toggle(itemInput: DfSideNavItem): void;
+    /**
+     *
+     * @param itemInput
+     */
+    collapseItem(itemInput: DfSideNavItem): void;
+    /**
+     * Use this to collapseAll items
+     */
+    collapseAllItems(): void;
+    /**
+     * Use this to set/unset the SideNav in an Overlay Menu
+     * If input is `True` then the SideNav will be in an Overlay Menu
+     * (when not collapsed)
+     *
+     */
+    setInMenuSideNav(on: boolean): void;
+    /**
+     * Use this to collapse the SideNav
+     *
+     */
+    hideSideNav(): void;
+    /**
+     * Use this to make the SideNav visible (uncollapse)
+     *
+     */
+    showSideNav(): void;
+    /**
+     * Use this to toggle the SideNav status collapse/visible
+     *
+     */
+    toggleSideNav(): void;
+    removeSideBar(): void;
+    /**
+     * Use this to set the App Overlay Mode
+     * Input `True` if you want to set the AppOverlay
+     * An event is send to isAppOverlay$ depending on your status
+     * if Input = `True` and isCollapsed = `False` then isAppOverlay$
+     * will be `True`
+     *
+     */
+    setAppOverlayMode(on: boolean): void;
+    setSideNav(): void;
+    /**
+     *
+     * @param itemInput
+     * @param itemsList
+     */
+    private collapse;
+    /**
+     *
+     * @param itemsList
+     */
+    private collapseAll;
+    private setActiveItem;
+    private addNavItemType;
+    private dispatchSideNavItems;
+    private updateOverLay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfSideNavService>;
+}
+
+declare class DfSideNavHeaderDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfSideNavHeaderDirective, "ng-template[dfSideNavHeader]", never, {}, {}, never, never, true, never>;
+}
+declare class DfSideNavIconDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfSideNavIconDirective, "ng-template[dfSideNavIcon]", never, {}, {}, never, never, true, never>;
+}
+declare class DfSideNavItemDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfSideNavItemDirective, "ng-template[dfSideNavItem]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * SideNav is a component to provide navigation feature with a panel on the side of your page
+ *
+ * It supports several options as:
+ *  - Being in an overlay menu or not
+ *  - Being collapsed or not
+ *  - Can be used with or without Angular Router
+ *  - Can be used with media queries to adjust behavior to different breakpoints (see media section)
+ */
+declare class DfSideNavComponent implements OnDestroy {
+    readonly tplHeader: i0.Signal<DfSideNavHeaderDirective | undefined>;
+    readonly tplIcon: i0.Signal<DfSideNavIconDirective | undefined>;
+    readonly tplItem: i0.Signal<DfSideNavItemDirective | undefined>;
+    readonly overlayClass: i0.WritableSignal<boolean>;
+    readonly classes: i0.Signal<string>;
+    private readonly sideNavService;
+    readonly navItems: i0.Signal<DfSideNavItem[]>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfSideNavComponent, "df-sidenav", never, {}, {}, ["tplHeader", "tplIcon", "tplItem"], never, true, never>;
+}
+
+declare class DfManageSideNavDirective implements AfterViewChecked {
+    private readonly element;
+    private readonly renderer;
+    constructor(element: ElementRef, renderer: Renderer2);
+    ngAfterViewChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfManageSideNavDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfManageSideNavDirective, "[dfManageSideNav]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The directive to catch focusin event and put the focus at a defined position in the page
+ *
+ * @deprecated 19.1.0 use {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/inert inert} instead
+ * @since 9.1.0
+ */
+declare class DfExcludeTrapDirective implements OnDestroy, OnInit {
+    private subscription;
+    private subscriptionInput?;
+    /**
+     * The CSS selector used to get the element to put the focus when catched
+     *
+     */
+    readonly dfExcludeTrapSelector: i0.InputSignal<string>;
+    /**
+     * The Observable to enable or disable the ExcludeTrap
+     * If `True` the excludeTrap will work
+     */
+    readonly dfExcludeTrap: i0.InputSignal<Observable<boolean>>;
+    private readonly zone;
+    private readonly element;
+    init(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfExcludeTrapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfExcludeTrapDirective, "[dfExcludeTrap]", never, { "dfExcludeTrapSelector": { "alias": "dfExcludeTrapSelector"; "required": false; "isSignal": true; }; "dfExcludeTrap": { "alias": "dfExcludeTrap"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DfManageNavSelectDirective implements OnInit {
+    private readonly select;
+    private readonly element;
+    private readonly rtlDirectionService;
+    private readonly renderer;
+    private direction;
+    constructor(select: NgSelectComponent, element: ElementRef, rtlDirectionService: DfDirectionDetectionService, renderer: Renderer2);
+    ngOnInit(): void;
+    handleKeyDown(event: any): void;
+    handleKeyDownBackspace(event: any): void;
+    handleKeyDownRight(event: any): void;
+    arrowRightInnerHandler(event: any): void;
+    arrowLeftInnerHandler(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfManageNavSelectDirective, [{ host: true; }, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfManageNavSelectDirective, "[dfManageNavSelect]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DfOptionHighlightDirective implements AfterViewInit {
+    readonly dfOptionHighlight: i0.InputSignal<string>;
+    private readonly label;
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly canHighlight;
+    constructor();
+    ngAfterViewInit(): void;
+    private setInnerHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfOptionHighlightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfOptionHighlightDirective, "[dfOptionHighlight]", never, { "dfOptionHighlight": { "alias": "dfOptionHighlight"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DfManageBadgeEventsDirective implements AfterViewInit {
+    readonly dfManageBadgeEventsSelect: i0.InputSignal<[(arg: any) => void, any]>;
+    private readonly renderer;
+    private readonly element;
+    constructor();
+    ngAfterViewInit(): void;
+    handleKeyDownBackspace(event: any): void;
+    handleClick(event: any): void;
+    handleKeyDownEnter(event: any): void;
+    handleKeyDownDelete(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfManageBadgeEventsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfManageBadgeEventsDirective, "[dfManageBadgeEventsSelect]", never, { "dfManageBadgeEventsSelect": { "alias": "dfManageBadgeEventsSelect"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DfSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfSelectModule, never, [typeof DfManageNavSelectDirective, typeof DfManageBadgeEventsDirective, typeof DfOptionHighlightDirective], [typeof DfManageNavSelectDirective, typeof DfManageBadgeEventsDirective, typeof DfOptionHighlightDirective, typeof i4.NgSelectModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfSelectModule>;
+}
+
+interface DfStepperStep {
+    warning: boolean;
+    completed: boolean;
+    visited?: boolean;
+    label: string;
+    ariaControl: string;
+    warningLabel?: string;
+    optionalLabel?: string;
+}
+type DfStepType = 'warning' | 'completed' | 'future' | 'visited';
+interface DfStepperNormalizedStep extends DfStepperStep {
+    type: DfStepType;
+}
+interface DfStepperState {
+    steps: DfStepperStep[];
+    active: number;
+    isLinear: boolean;
+    isInline: boolean;
+    isVertical: boolean;
+}
+interface DfStepperNormalizedState {
+    steps: DfStepperNormalizedStep[];
+    active: number;
+    isLinear: boolean;
+    isInline: boolean;
+    isVertical: boolean;
+}
+declare class DfStepperService {
+    setFocus: boolean;
+    private readonly _stepperState$;
+    private _state;
+    get state(): DfStepperNormalizedState;
+    private _completedLabel;
+    /**
+     * Internal to get the completed label in the template
+     */
+    get completedLabel(): string;
+    /**
+     * Use this to set the completed label (i18n)
+     */
+    set completedLabel(label: string);
+    private _warningLabel;
+    /**
+     * Internal to get the waring label in the template
+     */
+    get warningLabel(): string;
+    /**
+     * Use this to set the warning label (i18n)
+     */
+    set warningLabel(label: string);
+    private _stepperAriaLabel;
+    /**
+     * Internal to get the stepper aria label in the template
+     */
+    get stepperAriaLabel(): string;
+    /**
+     * Use this to set the stepper aria label (i18n)
+     */
+    set stepperAriaLabel(label: string);
+    get stepperState$(): Observable<DfStepperNormalizedState>;
+    /**
+     * Use this to init the list of Elements from your stepper
+     *
+     * Here we are not deep copying the array --> the function will change it
+     */
+    initStepperState(state: DfStepperState): void;
+    /**
+     * Use this to normalize the state of the stepper (completed, warning, current, future)
+     * @param state
+     * @returns
+     */
+    normalizeState(state: DfStepperState): DfStepperNormalizedState;
+    /**
+     * TODO make it customizable
+     * @param index - index of the step
+     * @returns - string of the step number to display
+     */
+    getStepNumberLabel(index: number): string;
+    resetFocus(): void;
+    /**
+     *
+     * @param isLinear - true if the stepper is linear
+     */
+    setLinear(isLinear: boolean): void;
+    /**
+     * @param isInline - true if the stepper is inline
+     */
+    setInline(isInline: boolean): void;
+    /**
+     * @param isVertical - true if the stepper is vertical
+     *
+     * @since 19.1.0
+     */
+    setVertical(isVertical: boolean): void;
+    /**
+     *
+     * @param index - index of the step to select start at 0
+     */
+    selectStep(index: number): void;
+    /**
+     * Same as selectStep but with focus on the step selected
+     * @param index - index of the step to select start at 0
+     */
+    selectWithFocus(index: number): void;
+    /**
+     *
+     * @param index - index of the step to complete start at 0
+     */
+    completeStep(index: number): void;
+    /**
+     *
+     * @param index - index of the step to complete start at 0
+     */
+    completeStepAndGoNext(index: number): void;
+    /**
+     * Attention if the step was completed it will be uncompleted after.
+     * @param index - index of the step to make Warning start at 0
+     * @param warningLabel - label to display in the warning by default it will take the warningLabel if it exists or the label
+     */
+    makeWarning(index: number, warningLabel?: string): void;
+    /**
+     *
+     * @param index - index of the step to remove Warning start at 0
+     */
+    removeWarning(index: number): void;
+    private dispatchStepperState;
+    private updateStepperState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfStepperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfStepperService>;
+}
+
+declare class DfStepperStepDirective implements OnInit, OnDestroy {
+    private readonly unlistener;
+    private readonly renderer2;
+    private readonly element;
+    ngOnInit(): void;
+    handleFocusTabIndex(): void;
+    handleBlurTabIndex(event: FocusEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfStepperStepDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfStepperStepDirective, "[dfStepperStep]", ["dfStepperStep"], {}, {}, never, never, true, never>;
+}
+declare class DfStepperDirective implements OnInit, AfterViewChecked {
+    private direction;
+    stepperService: DfStepperService;
+    private readonly element;
+    private readonly rtlDirectionService;
+    ngOnInit(): void;
+    handleEnterDown(): void;
+    handleSpaceDown(): void;
+    private handleGoPrevious;
+    private handleGoNext;
+    handleKeyDownRight(event: KeyboardEvent): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    handleKeyDownUp(event: KeyboardEvent): void;
+    handleKeyDownDown(event: KeyboardEvent): void;
+    getSteps(): HTMLButtonElement[];
+    private handleSelect;
+    private arrowRightInnerHandler;
+    private arrowLeftInnerHandler;
+    ngAfterViewChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfStepperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfStepperDirective, "[dfStepperLogic]", ["dfStepperLogic"], {}, {}, never, never, true, never>;
+}
+
+declare class DfStepperStepContentDirective {
+    readonly templateRef: TemplateRef<any>;
+    /**
+     * The step index
+     * -1 means that the input index is not set
+     */
+    readonly dfStepperStepContent: i0.InputSignalWithTransform<number, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfStepperStepContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfStepperStepContentDirective, "ng-template[dfStepperStepContent]", never, { "dfStepperStepContent": { "alias": "dfStepperStepContent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Stepper component is a component to provide a step by step navigation
+ * You have two ways to navigate through the steps:
+ * - Using the linear navigation, where you can only go to the next step
+ * - Using the non-linear navigation, where you can go to any step
+ */
+declare class DfStepperComponent implements AfterContentInit {
+    readonly stepperService: DfStepperService;
+    mapStepToContent: Map<number, TemplateRef<any>>;
+    readonly tplStepsContent: i0.Signal<readonly DfStepperStepContentDirective[]>;
+    readonly state: i0.WritableSignal<DfStepperNormalizedState | undefined>;
+    constructor();
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfStepperComponent, "[dfStepper]", never, {}, {}, ["tplStepsContent"], never, true, [{ directive: typeof DfStepperDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class DfStepperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfStepperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfStepperModule, never, [typeof DfStepperDirective, typeof DfStepperStepDirective, typeof DfStepperComponent, typeof DfStepperStepContentDirective], [typeof DfStepperDirective, typeof DfStepperStepDirective, typeof DfStepperComponent, typeof DfStepperStepContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfStepperModule>;
+}
+
+/**
+ * My dfTooltipTruncate directive
+ */
+declare class DfTooltipTruncateDirective implements OnInit, DoCheck {
+    private readonly tooltip;
+    private readonly elementRef;
+    private readonly renderer;
+    /**
+     * The direction considered when detecting overflow, can be 'x', 'y' or ''.
+     * @defaultValue ''
+     */
+    readonly dfTooltipTruncate: i0.InputSignal<"" | "x" | "y">;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfTooltipTruncateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfTooltipTruncateDirective, "[dfTooltipTruncate]", ["dfTooltipTruncate"], { "dfTooltipTruncate": { "alias": "dfTooltipTruncate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DfTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfTooltipModule, never, [typeof DfTooltipTruncateDirective], [typeof DfTooltipTruncateDirective, typeof i2.NgbTooltipModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfTooltipModule>;
+}
+
+/**
+ * A directive to provide a simple way of hiding and showing the sideNav on the page.
+ */
+declare class DfSideNavCollapseDirective implements OnInit {
+    /**
+     * If `true`, will collapse the element or show it otherwise.
+     */
+    readonly dfSideNavCollapse: i0.InputSignal<boolean>;
+    private readonly collapsed;
+    readonly minimized: i0.InputSignal<boolean>;
+    readonly dfSideNavCollapseChange: i0.OutputEmitterRef<boolean>;
+    /**
+     * An event emitted when the collapse element is shown, after the transition. It has no payload.
+     *
+     * @since 9.1.0
+     */
+    readonly shown: i0.OutputEmitterRef<void>;
+    /**
+     * An event emitted when the collapse element is hidden, after the transition. It has no payload.
+     *
+     * @since 9.1.0
+     */
+    readonly hidden: i0.OutputEmitterRef<void>;
+    private readonly elementRef;
+    private readonly sideNavCollapseService;
+    private readonly zone;
+    private readonly injector;
+    private animation;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Triggers collapsing programmatically.
+     *
+     * If there is a collapsing transition running already, it will be reversed.
+     * If the animations are turned off this happens synchronously.
+     *
+     * @since 9.1.0
+     */
+    toggle(open?: boolean): void;
+    private runTransition;
+    private runTransitionWithEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavCollapseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfSideNavCollapseDirective, "[dfSideNavCollapse]", ["dfSideNavCollapse"], { "dfSideNavCollapse": { "alias": "dfSideNavCollapse"; "required": true; "isSignal": true; }; "minimized": { "alias": "minimized"; "required": false; "isSignal": true; }; }, { "dfSideNavCollapseChange": "dfSideNavCollapseChange"; "shown": "shown"; "hidden": "hidden"; }, never, never, true, never>;
+}
+
+/**
+ * A configuration service for the [DfSideNavCollapseDirective](#/components/sidenav/api#DfSideNavCollapseDirective) component.
+ *
+ * You can inject this service, typically in your root component, and customize its properties
+ * to provide default values for the sideNav used in the application.
+ */
+declare class DfSideNavCollapseConfig {
+    private readonly _ngbConfig;
+    private _animation?;
+    constructor(_ngbConfig: NgbConfig);
+    get animation(): boolean;
+    set animation(animation: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavCollapseConfig, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfSideNavCollapseConfig>;
+}
+
+declare class DfSideNavCollapseModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavCollapseModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfSideNavCollapseModule, never, [typeof DfSideNavCollapseDirective], [typeof DfSideNavCollapseDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfSideNavCollapseModule>;
+}
+
+declare class DfSideNavModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfSideNavModule, never, [typeof DfManageSideNavDirective, typeof DfSideNavComponent, typeof DfSideNavHeaderDirective, typeof DfExcludeTrapDirective, typeof DfSideNavIconDirective, typeof DfSideNavItemDirective], [typeof DfManageSideNavDirective, typeof DfSideNavComponent, typeof DfSideNavHeaderDirective, typeof DfExcludeTrapDirective, typeof DfSideNavIconDirective, typeof DfSideNavItemDirective, typeof DfSideNavCollapseModule, typeof DfMediaModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfSideNavModule>;
+}
+
+/**
+ * A service for managing the sidenav panel animation.
+ * This service is included at root level
+ *
+ * Creating a sidenav is straightforward: use [DfSideNavComponent](#/components/sidenav/api#DfSideNavComponent) component
+ */
+declare class DfSideNavCollapseService {
+    private readonly _config;
+    private readonly _sideNavAnimation$;
+    constructor(_config: DfSideNavCollapseConfig);
+    get sideNavAnimation$(): Observable<boolean>;
+    /**
+     * Use this to activate or desactivate the animation for the sideNav
+     * If input is `True` it will activate the animation.
+     * Default value for animation is set in by DfSideNavCollapseConfig
+     *
+     */
+    setAnimation(on: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavCollapseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfSideNavCollapseService>;
+}
+
+declare const DF_BREAKPOINTS_VAR_DEFAULT: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    xxl: string;
+    xxxl: string;
+};
+declare const BREAKPOINTS_VARS: InjectionToken<{
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    xxl: string;
+    xxxl: string;
+}>;
+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>;
+}
+interface MediaBreakpointsState {
+    matches: boolean;
+    breakpoints: {
+        [key: string]: boolean;
+    };
+}
+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>;
+}
+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>;
+}
+
+/**
+ * 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)
+ */
+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>;
+}
+
+declare class DfManageCardSelectionDirective implements AfterViewInit {
+    private input;
+    readonly dfManageCardSelected: i0.InputSignal<boolean>;
+    private readonly element;
+    private readonly renderer;
+    constructor();
+    ngAfterViewInit(): void;
+    click(event: Event): void;
+    keydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfManageCardSelectionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfManageCardSelectionDirective, "[dfManageCardSelected]", never, { "dfManageCardSelected": { "alias": "dfManageCardSelected"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DfAdvancedCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAdvancedCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfAdvancedCardModule, never, [typeof DfManageCardSelectionDirective], [typeof DfManageCardSelectionDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfAdvancedCardModule>;
+}
+
+/**
+ * @deprecated Import only the needed modules or use standalone components instead of DfModule
+ */
+declare class DfModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfModule, never, [typeof DfAlertModule, typeof DfDatePickerModule, typeof DfSelectModule, typeof DfProgressbarModule, typeof DfProgressIndicatorModule, typeof DfAdvancedInputModule, typeof DfAccessibilityModule, typeof DfSliderModule, typeof DfPopoverModule, typeof DfIconModule, typeof DfTooltipModule, typeof DfSideNavModule, typeof DfSideNavCollapseModule, typeof DfAdvancedCardModule, typeof DfFooterModule, typeof DfToastModule, typeof DfStepperModule], [typeof DfAlertModule, typeof DfDatePickerModule, typeof DfSelectModule, typeof DfProgressbarModule, typeof DfProgressIndicatorModule, typeof DfAdvancedInputModule, typeof DfAccessibilityModule, typeof DfSliderModule, typeof DfPopoverModule, typeof DfIconModule, typeof DfTooltipModule, typeof DfSideNavModule, typeof DfSideNavCollapseModule, typeof DfAdvancedCardModule, typeof DfFooterModule, typeof DfToastModule, typeof DfStepperModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfModule>;
+}
+
+/**
+ * DfTitleTruncate directive
+ * It adds the title attribute with the element's textContent as value
+ * when the element is truncated.
+ */
+declare class DfTitleTruncateDirective implements OnInit, DoCheck {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly overflowService;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfTitleTruncateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfTitleTruncateDirective, "[dfTitleTruncate]", ["dfTitleTruncate"], {}, {}, never, never, true, never>;
+}
+
+declare class DfWavesOfProgressDirective {
+    /**
+     * The type of waves to display. In order to display the waves, the app using the directive must include the assets of Design Factory.
+     * It is possible to do so by adding the following snippet to the `angular.json` file in the `assets` configuration:
+     * @example
+     * "assets": [
+     *  {
+     *    "glob": "** / *", //remove the spaces between the asterisks and the slash
+     *    "input": "node-modules/@design-factory/design-factory/assets/",
+     *    "output": "assets/"
+     *  },
+     *  ...]
+     */
+    readonly dfWavesOfProgress: i0.InputSignal<"arrowRight" | "circleDiagonal" | "circleUp" | "arrowUp">;
+    private readonly http;
+    elementRef: ElementRef<any>;
+    private readonly platformId;
+    private baseSvg;
+    /**
+     * Prepares the SVG string by replacing color variables and encoding it.
+     * @param bgColor - The background color.
+     * @param lineColor - The line color.
+     * @returns The prepared SVG string.
+     */
+    prepareSvg(bgColor: string, lineColor: string): string;
+    /**
+     * Updates the SVG background image based on the current element's styles.
+     */
+    updateSvg(): void;
+    constructor();
+    private getSvg;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfWavesOfProgressDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfWavesOfProgressDirective, "[dfWavesOfProgress]", ["dfWavesOfProgress"], { "dfWavesOfProgress": { "alias": "dfWavesOfProgress"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DfWavesOfProgressModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfWavesOfProgressModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfWavesOfProgressModule, never, [typeof DfWavesOfProgressDirective], [typeof DfWavesOfProgressDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfWavesOfProgressModule>;
+}
+
+declare class DfAmadeusLogoComponent {
+    /**
+     * Class to apply to the SVG element. For example, you can use `df-logo-dim` to set proper dimensions inside footer and navbar.
+     */
+    readonly svgClass: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfAmadeusLogoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfAmadeusLogoComponent, "df-amadeus-logo", never, { "svgClass": { "alias": "svgClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { BREAKPOINTS_VARS, ChangeContext, DF_BREAKPOINTS_VAR_DEFAULT, DfAccessibilityModule, DfAdvancedCardModule, DfAdvancedInputModule, DfAlertModule, DfAmadeusIconComponent, DfAmadeusLogoComponent, DfBreakpoints, DfDatePickerModule, DfDatepickerRangeDirective, DfDatepickerRangeService, DfDefaultSpinnerComponent, DfDirectionDetectionService, DfExcludeTrapDirective, DfFooterModule, DfIconModule, DfIfMediaDirective, DfInputIconDirective, DfInsertIconDirective, DfInsertIconModule, DfManageBadgeEventsDirective, DfManageCardSelectionDirective, DfManageNavSelectDirective, DfManageSideNavDirective, DfMedia, DfMediaModule, DfMediaObserver, DfMediaQuery, DfModalService, DfModule, DfNavItemType, DfOptionHighlightDirective, DfPopoverConfig, DfPopoverModule, DfProgressIndicatorBackdropComponent, DfProgressIndicatorContainerComponent, DfProgressIndicatorContentPosition, DfProgressIndicatorContentProgressBar, DfProgressIndicatorContentSpinner, DfProgressIndicatorContentType, DfProgressIndicatorDirective, DfProgressIndicatorModule, DfProgressIndicatorRef, DfProgressIndicatorService, DfProgressbarComponent, DfProgressbarModule, DfSelectModule, DfSideNavCollapseDirective, DfSideNavCollapseModule, DfSideNavCollapseService, DfSideNavComponent, DfSideNavConfig, DfSideNavHeaderDirective, DfSideNavIconDirective, DfSideNavItemDirective, DfSideNavModule, DfSideNavService, DfSliderDirectionDirective, DfSliderModule, DfStepperComponent, DfStepperDirective, DfStepperModule, DfStepperService, DfStepperStepContentDirective, DfStepperStepDirective, DfTitleTruncateDirective, DfToastModule, DfTooltipModule, DfTooltipTruncateDirective, DfTriggerClickDirective, DfWavesOfProgressDirective, DfWavesOfProgressModule, LabelType, Options, PointerType, RightToLeftDirectionEnum, SkipLinkDirective, SkipLinksContainerComponent, SliderComponent };
+export type { CombineLabelsFunction, CustomStepDefinition, DfDirection, DfProgressIndicatorContent, DfProgressIndicatorOptions, DfSideNavItem, DfStepType, DfStepperNormalizedState, DfStepperNormalizedStep, DfStepperState, DfStepperStep, GetLegendFunction, GetStepLegendFunction, PositionToValueFunction, TranslateFunction, ValueToPositionFunction };