@design-factory/design-factory 15.2.0

package/lib/angular/progressindicator/progressindicator-config.d.ts

@@ -0,0 +1,54 @@
+export 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;
+}
+export declare enum DfProgressIndicatorContentType {
+    SPINNER = "spinner",
+    PROGRESSBAR = "progressbar"
+}
+export declare class DfProgressIndicatorContentSpinner {
+    readonly type = DfProgressIndicatorContentType.SPINNER;
+    spinnerInput?: {
+        contentClass?: string;
+        ariaLabel?: string;
+    };
+    constructor(spinnerInput?: {
+        contentClass?: string;
+        ariaLabel?: string;
+    });
+}
+export declare class DfProgressIndicatorContentProgressBar {
+    readonly type = DfProgressIndicatorContentType.PROGRESSBAR;
+    progressBarInput?: {
+        ariaLabel: string;
+    };
+    position: DfProgressIndicatorContentPosition;
+    constructor(progressBarInput?: {
+        ariaLabel: string;
+    }, position?: DfProgressIndicatorContentPosition);
+}
+export declare enum DfProgressIndicatorContentPosition {
+    TOP = "top",
+    BOTTOM = "bottom",
+    CENTERED = "centered"
+}

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

@@ -0,0 +1,13 @@
+import { DfProgressIndicatorContentPosition } from './progressindicator-config';
+import * as i0 from "@angular/core";
+export declare class DfProgressIndicatorContainerComponent {
+    private readonly DEFAULT_CLASS_POSITION;
+    get classes(): string;
+    containerClass?: string;
+    set position(newPosition: DfProgressIndicatorContentPosition | undefined);
+    get position(): DfProgressIndicatorContentPosition | undefined;
+    private _position?;
+    positionClass: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressIndicatorContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfProgressIndicatorContainerComponent, "df-progressindicator-container", never, { "containerClass": { "alias": "containerClass"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/lib/angular/progressindicator/progressindicator-ref.d.ts

@@ -0,0 +1,9 @@
+import { ComponentRef, EmbeddedViewRef } from '@angular/core';
+import { DfProgressIndicatorBackdropComponent } from './progressindicator-backdrop.component';
+import { DfProgressIndicatorContainerComponent } from './progressindicator-container.component';
+export 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);
+}

package/lib/angular/progressindicator/progressindicator.directive.d.ts

@@ -0,0 +1,18 @@
+import { ElementRef, OnChanges, SimpleChanges } from '@angular/core';
+import { DfProgressIndicatorService, DfProgressIndicatorContent } from './progressindicator.service';
+import { DfProgressIndicatorOptions } from './progressindicator-config';
+import * as i0 from "@angular/core";
+export declare class DfProgressIndicatorDirective implements OnChanges {
+    private readonly elementRef;
+    private readonly progressService;
+    dfProgressIndicator: boolean;
+    dfProgressIndicatorConfig?: {
+        content?: DfProgressIndicatorContent<unknown>;
+        options: DfProgressIndicatorOptions;
+    };
+    private progressIndicatorRef;
+    constructor(elementRef: ElementRef, progressService: DfProgressIndicatorService);
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfProgressIndicatorDirective, "[dfProgressIndicator]", never, { "dfProgressIndicator": { "alias": "dfProgressIndicator"; "required": false; }; "dfProgressIndicatorConfig": { "alias": "dfProgressIndicatorConfig"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./default/default-spinner.component";
+import * as i2 from "../progressbar/progressbar.module";
+import * as i3 from "./progressindicator-backdrop.component";
+import * as i4 from "./progressindicator-container.component";
+import * as i5 from "./progressindicator.directive";
+export { DfProgressIndicatorContainerComponent } from './progressindicator-container.component';
+export { DfDefaultSpinnerComponent } from './default/default-spinner.component';
+export { DfProgressIndicatorBackdropComponent } from './progressindicator-backdrop.component';
+export { DfProgressIndicatorDirective } from './progressindicator.directive';
+export declare class DfProgressIndicatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfProgressIndicatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfProgressIndicatorModule, never, [typeof i1.DfDefaultSpinnerComponent, typeof i2.DfProgressbarModule, typeof i3.DfProgressIndicatorBackdropComponent, typeof i4.DfProgressIndicatorContainerComponent, typeof i5.DfProgressIndicatorDirective], [typeof i2.DfProgressbarModule, typeof i4.DfProgressIndicatorContainerComponent, typeof i5.DfProgressIndicatorDirective, typeof i3.DfProgressIndicatorBackdropComponent, typeof i1.DfDefaultSpinnerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfProgressIndicatorModule>;
+}

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

@@ -0,0 +1,33 @@
+import { ComponentFactoryResolver, RendererFactory2, ApplicationRef, Injector, Type, TemplateRef } from '@angular/core';
+import { DfProgressIndicatorOptions, DfProgressIndicatorContentSpinner, DfProgressIndicatorContentProgressBar } from './progressindicator-config';
+import { DfProgressIndicatorRef } from './progressindicator-ref';
+import { ScrollBar } from '../utils/scrollbar.service';
+import * as i0 from "@angular/core";
+export type DfProgressIndicatorContent<T> = undefined | TemplateRef<T> | Type<T> | DfProgressIndicatorContentSpinner | DfProgressIndicatorContentProgressBar;
+export 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>;
+}

package/lib/angular/right-to-left/directionDetection.service.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare enum RightToLeftDirectionEnum {
+    LeftToRight = "ltr",
+    RightToLeft = "rtl",
+    Auto = "auto"
+}
+export declare class DfDirectionDetectionService {
+    getPageDirection(element: ElementRef): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfDirectionDetectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DfDirectionDetectionService>;
+}

package/lib/angular/selects/events/manage-badge-events.directive.d.ts

@@ -0,0 +1,16 @@
+import { ElementRef, Renderer2, AfterViewInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DfManageBadgeEventsDirective implements AfterViewInit {
+    private readonly renderer;
+    private readonly element;
+    dfManageBadgeEventsSelect: [(arg: any) => void, any];
+    tabindex: string;
+    constructor(renderer: Renderer2, element: ElementRef);
+    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": false; }; }, {}, never, never, true, never>;
+}

package/lib/angular/selects/nav/manage-nav-select.directive.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef, OnInit, Renderer2 } from '@angular/core';
+import { NgSelectComponent } from '@ng-select/ng-select';
+import { DfDirectionDetectionService } from '../../right-to-left/directionDetection.service';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/lib/angular/selects/option-highlight.directive.d.ts

@@ -0,0 +1,19 @@
+import { AfterViewInit, ElementRef, OnChanges, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DfOptionHighlightDirective implements OnChanges, AfterViewInit {
+    private readonly elementRef;
+    private readonly renderer;
+    term: string;
+    private element;
+    private label;
+    constructor(elementRef: ElementRef, renderer: Renderer2);
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    private escapeRegExp;
+    private highlightLabel;
+    private get canHighlight();
+    private setInnerHtml;
+    private isDefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfOptionHighlightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfOptionHighlightDirective, "[dfOptionHighlight]", never, { "term": { "alias": "dfOptionHighlight"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/angular/selects/select.model.d.ts

@@ -0,0 +1 @@
+export declare const DF_SELECT_CLASS = "df-ym";

package/lib/angular/selects/select.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./nav/manage-nav-select.directive";
+import * as i2 from "./events/manage-badge-events.directive";
+import * as i3 from "./option-highlight.directive";
+import * as i4 from "@ng-select/ng-select";
+export { DfManageNavSelectDirective } from './nav/manage-nav-select.directive';
+export { DfManageBadgeEventsDirective } from './events/manage-badge-events.directive';
+export { DfOptionHighlightDirective } from './option-highlight.directive';
+export declare class DfSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfSelectModule, never, [typeof i1.DfManageNavSelectDirective, typeof i2.DfManageBadgeEventsDirective, typeof i3.DfOptionHighlightDirective], [typeof i1.DfManageNavSelectDirective, typeof i2.DfManageBadgeEventsDirective, typeof i3.DfOptionHighlightDirective, typeof i4.NgSelectModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfSelectModule>;
+}

package/lib/angular/sidenav/dfSideNavAnimation.d.ts

@@ -0,0 +1,7 @@
+import { NgbTransitionStartFn } from '../animation/ngbTransition';
+export interface DfSideNavCollapseCtx {
+    direction: 'show' | 'hide';
+    maxWidth?: string;
+    minimized?: boolean;
+}
+export declare const DfCollapsingTransition: NgbTransitionStartFn<DfSideNavCollapseCtx>;

package/lib/angular/sidenav/dfSideNavCollapse.d.ts

@@ -0,0 +1,48 @@
+import { ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { DfSideNavCollapseService } from './dfSideNavCollapse.service';
+import * as i0 from "@angular/core";
+/**
+ * A directive to provide a simple way of hiding and showing the sideNav on the page.
+ */
+export declare class DfSideNavCollapseDirective implements OnInit, OnChanges, OnDestroy {
+    private readonly _element;
+    private readonly _sideNavCollapseService;
+    private readonly _zone;
+    /**
+     * If `true`, will collapse the element or show it otherwise.
+     */
+    collapsed: boolean;
+    dfSideNavCollapseChange: EventEmitter<boolean>;
+    /**
+     * An event emitted when the collapse element is shown, after the transition. It has no payload.
+     *
+     * @since 9.1.0
+     */
+    shown: EventEmitter<void>;
+    /**
+     * An event emitted when the collapse element is hidden, after the transition. It has no payload.
+     *
+     * @since 9.1.0
+     */
+    hidden: EventEmitter<void>;
+    minimized: boolean;
+    private animation;
+    private readonly subscription;
+    constructor(_element: ElementRef, _sideNavCollapseService: DfSideNavCollapseService, _zone: NgZone);
+    ngOnInit(): void;
+    ngOnChanges(simpleChanges: SimpleChanges): void;
+    ngOnDestroy(): 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"], { "collapsed": { "alias": "dfSideNavCollapse"; "required": false; }; "minimized": { "alias": "minimized"; "required": false; }; }, { "dfSideNavCollapseChange": "dfSideNavCollapseChange"; "shown": "shown"; "hidden": "hidden"; }, never, never, true, never>;
+}

package/lib/angular/sidenav/dfSideNavCollapse.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./dfSideNavCollapse";
+export { DfSideNavCollapseDirective } from './dfSideNavCollapse';
+export { DfSideNavCollapseConfig } from './dfSideNavCollapseConfig';
+export declare class DfSideNavCollapseModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavCollapseModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfSideNavCollapseModule, never, [typeof i1.DfSideNavCollapseDirective], [typeof i1.DfSideNavCollapseDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfSideNavCollapseModule>;
+}

package/lib/angular/sidenav/dfSideNavCollapse.service.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from 'rxjs';
+import { DfSideNavCollapseConfig } from './dfSideNavCollapseConfig';
+import * as i0 from "@angular/core";
+/**
+ * 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
+ */
+export 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>;
+}

package/lib/angular/sidenav/dfSideNavCollapseConfig.d.ts

@@ -0,0 +1,17 @@
+import { NgbConfig } from '@ng-bootstrap/ng-bootstrap';
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
+export 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>;
+}

package/lib/angular/sidenav/excludeTrap.directive.d.ts

@@ -0,0 +1,30 @@
+import { ElementRef, NgZone, OnDestroy, OnInit } from '@angular/core';
+import { Observable, Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * The directive to catch focusin event and put the focus at a defined position in the page
+ *
+ * @since 9.1.0
+ */
+export declare class DfExcludeTrapDirective implements OnDestroy, OnInit {
+    private readonly zone;
+    private readonly element;
+    subscription: Subscription;
+    subscriptionInput?: Subscription;
+    /**
+     * The CSS selector used to get the element to put the focus when catched
+     *
+     */
+    dfExcludeTrapSelector: string;
+    /**
+     * The Observable to enable or disable the ExcludeTrap
+     * If `True` the excludeTrap will work
+     */
+    dfExcludeTrap: Observable<boolean>;
+    constructor(zone: NgZone, element: ElementRef);
+    init(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfExcludeTrapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DfExcludeTrapDirective, "[dfExcludeTrap]", never, { "dfExcludeTrapSelector": { "alias": "dfExcludeTrapSelector"; "required": false; }; "dfExcludeTrap": { "alias": "dfExcludeTrap"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/angular/sidenav/manage-sidenav.directive.d.ts

@@ -0,0 +1,10 @@
+import { AfterViewChecked, ElementRef, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/lib/angular/sidenav/sidenav-config.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
+export 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>;
+}

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

@@ -0,0 +1,43 @@
+import { OnDestroy, TemplateRef } from '@angular/core';
+import { DfSideNavService } from './sidenav.service';
+import * as i0 from "@angular/core";
+export 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>;
+}
+export 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>;
+}
+export 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)
+ */
+export declare class DfSideNavComponent implements OnDestroy {
+    tplHeader: DfSideNavHeaderDirective;
+    tplIcon: DfSideNavIconDirective;
+    tplItem: DfSideNavItemDirective;
+    overlayClass?: boolean;
+    elements: string;
+    private readonly subscription;
+    sideNavService: DfSideNavService;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DfSideNavComponent, "df-sidenav", never, {}, {}, ["tplHeader", "tplIcon", "tplItem"], never, true, never>;
+}

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

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./manage-sidenav.directive";
+import * as i2 from "./sidenav.component";
+import * as i3 from "./excludeTrap.directive";
+import * as i4 from "./dfSideNavCollapse.module";
+import * as i5 from "../mediaqueries/media.module";
+export { DfSideNavComponent, DfSideNavHeaderDirective, DfSideNavIconDirective, DfSideNavItemDirective } from './sidenav.component';
+export { DfManageSideNavDirective } from './manage-sidenav.directive';
+export { DfExcludeTrapDirective } from '../sidenav/excludeTrap.directive';
+export declare class DfSideNavModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DfSideNavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DfSideNavModule, never, [typeof i1.DfManageSideNavDirective, typeof i2.DfSideNavComponent, typeof i2.DfSideNavHeaderDirective, typeof i3.DfExcludeTrapDirective, typeof i2.DfSideNavIconDirective, typeof i2.DfSideNavItemDirective], [typeof i1.DfManageSideNavDirective, typeof i2.DfSideNavComponent, typeof i2.DfSideNavHeaderDirective, typeof i3.DfExcludeTrapDirective, typeof i2.DfSideNavIconDirective, typeof i2.DfSideNavItemDirective, typeof i4.DfSideNavCollapseModule, typeof i5.DfMediaModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DfSideNavModule>;
+}

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

@@ -0,0 +1,178 @@
+import { OnDestroy, TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DfSideNavConfig } from './sidenav-config';
+import * as i0 from "@angular/core";
+export interface DfSideNavItem {
+    value: string;
+    title?: string;
+    icon?: string | TemplateRef<any>;
+    isExternal?: boolean;
+    isActive?: boolean;
+    isCollapsed?: boolean;
+    breakpoints?: string[];
+    subMenus?: DfSideNavItem[];
+    type?: DfNavItemType;
+}
+export 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
+ */
+export declare class DfSideNavService implements OnDestroy {
+    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>;
+}