@recursyve/nice-ui-kit.v2 17.0.0-beta.140 → 20.0.0-beta.145

package/index.d.ts

@@ -1,5 +1,3666 @@
+import * as _angular_animations from '@angular/animations';
+import { AnimationBuilder } from '@angular/animations';
+import * as _angular_common_http from '@angular/common/http';
+import { HttpErrorResponse, HttpContextToken, HttpInterceptor, HttpRequest, HttpHandler, HttpResponse, HttpContext, HttpHeaders, HttpParams, HttpClient } from '@angular/common/http';
+import * as rxjs from 'rxjs';
+import { Observable, Subject, Subscription, BehaviorSubject, MonoTypeOperatorFunction, ReplaySubject } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Type, OnChanges, OnInit, OnDestroy, EventEmitter, ChangeDetectorRef, SimpleChanges, ElementRef, QueryList, TemplateRef, ModuleWithProviders, DoCheck, NgZone, InjectionToken, PipeTransform, TrackByFunction, Renderer2, AfterViewInit, ViewContainerRef, ComponentFactoryResolver, Injector, RendererFactory2 } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i2 from '@angular/common';
+import { CurrencyPipe, Location } from '@angular/common';
+import * as i3 from '@angular/material/button';
+import * as i4 from '@angular/material/icon';
+import * as i3$1 from '@angular/forms';
+import { ControlValueAccessor, NgControl, FormControl, FormGroup, ControlContainer, AbstractControlDirective, ValidationErrors, FormArray, FormArrayName } from '@angular/forms';
+import * as i7 from '@angular/material/core';
+import { ThemePalette, MatOption, _ErrorStateTracker, DateAdapter, MatDateFormats } from '@angular/material/core';
+import * as i6 from '@angular/material/menu';
+import { MatMenu } from '@angular/material/menu';
+import * as i10 from '@ngx-translate/core';
+import { TranslateService } from '@ngx-translate/core';
+import * as i10$1 from '@angular/material/progress-spinner';
+import { ProgressSpinnerMode } from '@angular/material/progress-spinner';
+import * as i6$2 from '@angular/material/autocomplete';
+import { MatAutocompleteActivatedEvent, MatAutocompleteSelectedEvent, MatAutocomplete } from '@angular/material/autocomplete';
+import * as i6$3 from '@angular/material/form-field';
+import { MatFormFieldControl, MatFormField } from '@angular/material/form-field';
+import * as i6$1 from '@angular/material/input';
+import * as i9 from '@angular/material/progress-bar';
+import { GeneratedFormGroup, AsyncValidator } from '@recursyve/ngx-form-generator';
+import { Overlay, OverlayContainer, ScrollStrategyOptions, OverlayPositionBuilder, OverlayKeyboardDispatcher, OverlayOutsideClickDispatcher } from '@angular/cdk/overlay';
+import * as i5 from '@angular/material/card';
+import * as i5$1 from '@angular/material/datepicker';
+import { MatCalendar, MatDateRangePicker } from '@angular/material/datepicker';
+import { NgxMaskService } from 'ngx-mask';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i3$2 from '@angular/material/bottom-sheet';
+import { MatBottomSheetRef } from '@angular/material/bottom-sheet';
+import * as i4$1 from '@angular/material/list';
+import * as i5$2 from '@angular/cdk/stepper';
+import { CdkStepper, CdkStep } from '@angular/cdk/stepper';
+import { ViewportRuler } from '@angular/cdk/scrolling';
+import { BreakpointObserver, BreakpointState } from '@angular/cdk/layout';
+import { Directionality } from '@angular/cdk/bidi';
+import * as i4$2 from '@angular/material/snack-bar';
+import { MatSnackBar, MatSnackBarRef, MatSnackBarConfig } from '@angular/material/snack-bar';
+import * as i19 from '@angular/router';
+import { Router, ActivatedRoute } from '@angular/router';
+import * as i24 from '@angular/material/tooltip';
+import { TooltipPosition } from '@angular/material/tooltip';
+import { Platform } from '@angular/cdk/platform';
+import PerfectScrollbar from 'perfect-scrollbar';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import * as i21 from '@angular/material/divider';
+import * as i5$3 from '@angular/material/dialog';
+import { MatDialogRef, MatDialog, MatDialogConfig } from '@angular/material/dialog';
+import { TapObserver } from 'rxjs/internal/operators/tap';
+import * as i5$4 from '@angular/material/button-toggle';
+import { MatButtonToggleChange } from '@angular/material/button-toggle';
+import * as i2$1 from '@angular/cdk/drag-drop';
+import { CdkDropList, CdkDragDrop } from '@angular/cdk/drag-drop';
+import { LexoRank } from 'lexorank';
+
+declare const niceAnimations: _angular_animations.AnimationTriggerMetadata[];
+
+declare abstract class NiceApiException<Code> {
+    abstract code: Code;
+}
+
+declare abstract class NiceHttpExceptionFactory<Code = any> {
+    transform(error: HttpErrorResponse): NiceApiException<Code> | HttpErrorResponse;
+    protected abstract transformCodeError(code: Code, data: any): NiceApiException<Code>;
+}
+
+declare const TRANSFORM_TYPE: HttpContextToken<Type<any>>;
+declare class NiceTransformResponseInterceptor implements HttpInterceptor {
+    intercept(req: HttpRequest<any>, next: HttpHandler): rxjs.Observable<_angular_common_http.HttpProgressEvent | _angular_common_http.HttpSentEvent | _angular_common_http.HttpHeaderResponse | HttpResponse<any> | _angular_common_http.HttpUserEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceTransformResponseInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceTransformResponseInterceptor>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * From @angular/material/core/common-behaviors/constructor.ts
  */
-/// <amd-module name="@recursyve/nice-ui-kit.v2" />
-export * from './public-api';
+type Constructor<T> = new (...args: any[]) => T;
+type AbstractConstructor<T = object> = abstract new (...args: any[]) => T;
+
+interface HttpOptions {
+    type?: Type<any>;
+    context?: HttpContext;
+    headers?: HttpHeaders | {
+        [header: string]: string | string[];
+    };
+    responseType?: "text" | "json" | "arraybuffer" | "blob";
+    params?: HttpParams | {
+        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+    };
+}
+interface NiceApiDefinition {
+    url(route?: string): string;
+    delete<T>(route?: string, options?: HttpOptions): Observable<T>;
+    get<T>(route?: string, options?: HttpOptions): Observable<T>;
+    patch<T>(route?: string, body?: any, options?: HttpOptions): Observable<T>;
+    post<T>(route?: string, body?: any, options?: HttpOptions): Observable<T>;
+    put<T>(route?: string, body?: any, options?: HttpOptions): Observable<T>;
+}
+interface HasNiceApiDefinition {
+    exceptionFactory: NiceHttpExceptionFactory;
+    httpClient: HttpClient;
+    apiUrl: string;
+    path: string;
+}
+type NiceApiDefinitionCtor = Constructor<NiceApiDefinition> & AbstractConstructor<NiceApiDefinition>;
+declare function mixinNiceApi<C extends AbstractConstructor<HasNiceApiDefinition>>(base: C): NiceApiDefinitionCtor & C;
+
+declare class NiceUtilsService {
+    /**
+     * Generates a random id
+     */
+    randomId(length?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceUtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceUtilsService>;
+}
+
+declare class NiceUtilsModule {
+    private _niceUtilsService;
+    constructor(_niceUtilsService: NiceUtilsService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceUtilsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceUtilsModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceUtilsModule>;
+}
+
+declare class NiceAlertService {
+    private readonly _onDismiss;
+    private readonly _onShow;
+    /**
+     * Getter for onDismiss
+     */
+    get onDismiss(): Observable<any>;
+    /**
+     * Getter for onShow
+     */
+    get onShow(): Observable<any>;
+    /**
+     * Dismiss the alert
+     */
+    dismiss(name: string): void;
+    /**
+     * Show the dismissed alert
+     */
+    show(name: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceAlertService>;
+}
+
+type NiceAlertAppearance = "border" | "fill" | "outline" | "soft";
+type NiceAlertType = "primary" | "accent" | "warn" | "basic" | "info" | "success" | "warning" | "error";
+type NiceAlertColor = "primary" | "accent" | "warn";
+
+declare class NiceAlertComponent implements OnChanges, OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _niceAlertService;
+    private _niceUtilsService;
+    static ngAcceptInputType_dismissible: BooleanInput;
+    static ngAcceptInputType_dismissed: BooleanInput;
+    static ngAcceptInputType_disableAnimation: BooleanInput;
+    static ngAcceptInputType_showIcon: BooleanInput;
+    appearance: NiceAlertAppearance;
+    dismissed: boolean;
+    dismissible: boolean;
+    disableAnimation: boolean;
+    name: string;
+    showIcon: boolean;
+    type: NiceAlertType;
+    color?: NiceAlertColor;
+    readonly dismissedChanged: EventEmitter<boolean>;
+    private _unsubscribeAll;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceAlertService: NiceAlertService, _niceUtilsService: NiceUtilsService);
+    /**
+     * Host binding for component classes
+     */
+    get classList(): any;
+    /**
+     * On changes
+     *
+     * @param changes
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Dismiss the alert
+     */
+    dismiss(): void;
+    /**
+     * Show the dismissed alert
+     */
+    show(): void;
+    /**
+     * Dismiss/show the alert
+     *
+     * @param dismissed
+     * @private
+     */
+    private _toggleDismiss;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAlertComponent, "nice-alert", ["niceAlert"], { "appearance": { "alias": "appearance"; "required": false; }; "dismissed": { "alias": "dismissed"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; "disableAnimation": { "alias": "disableAnimation"; "required": false; }; "name": { "alias": "name"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "type": { "alias": "type"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "dismissedChanged": "dismissedChanged"; }, never, ["[niceAlertIcon]", "[niceAlertTitle]", "*"], false, never>;
+}
+
+declare class NiceAlertModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceAlertModule, [typeof NiceAlertComponent], [typeof i2.CommonModule, typeof i3.MatButtonModule, typeof i4.MatIconModule], [typeof NiceAlertComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceAlertModule>;
+}
+
+interface NiceAssets {
+    type: "image" | "video";
+    id?: number | string;
+    url?: string;
+    base64?: string;
+    file?: File;
+}
+type NiceAssetsCarouselActionIcon = {
+    matIcon: string;
+    svgIcon?: string;
+} | {
+    matIcon?: string;
+    svgIcon: string;
+};
+interface NiceAssetsCarouselActions {
+    icon: NiceAssetsCarouselActionIcon;
+    name: string;
+    action: (active: number) => void;
+}
+interface NiceAssetsCarouselOptions {
+    actionButtons?: {
+        moreOptions?: NiceAssetsCarouselActionIcon;
+        addPhoto?: NiceAssetsCarouselActionIcon;
+        remove?: NiceAssetsCarouselActionIcon;
+    };
+    addPhoto?: NiceAssetsCarouselActionIcon;
+    leftArrow?: NiceAssetsCarouselActionIcon;
+    rightArrow?: NiceAssetsCarouselActionIcon;
+    upload?: NiceAssetsCarouselActionIcon;
+}
+declare class NiceAssetsCarouselComponent implements OnInit, OnChanges, ControlValueAccessor {
+    readonly options: NiceAssetsCarouselOptions;
+    _activeTranslationPosition: number;
+    _active: number;
+    _assets: NiceAssets[];
+    _activeAsset: NiceAssets;
+    _lastAsset: boolean;
+    _shouldTransform: boolean;
+    _activeVideoElement: ElementRef<HTMLVideoElement>;
+    _assetsElement: QueryList<ElementRef<HTMLDivElement>>;
+    defaultColor: ThemePalette;
+    inputElement: ElementRef<HTMLInputElement>;
+    color: ThemePalette;
+    edit: boolean;
+    loading: boolean;
+    accept: string[];
+    customActions: NiceAssetsCarouselActions[];
+    imagesProcessor: (files: File[]) => Promise<File[]>;
+    multipleUpload: boolean;
+    visiblePreviewAsset: number;
+    showAddAssetContainer: boolean;
+    activeContent: TemplateRef<any>;
+    activeChange: EventEmitter<number>;
+    removedAsset: EventEmitter<NiceAssets>;
+    listStyle: {
+        transform: string;
+    };
+    showOverlay: boolean;
+    private _imagesMimeTypes;
+    private propagate;
+    set activeVideoElement(activeVideoElement: ElementRef<HTMLVideoElement>);
+    set assetsElement(assetsElement: QueryList<ElementRef<HTMLDivElement>>);
+    set assets(assets: NiceAssets[]);
+    private set activeTranslationPosition(value);
+    private set activeAsset(value);
+    constructor(options: NiceAssetsCarouselOptions);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(assets: NiceAssets[]): void;
+    registerOnChange(fn: (assets: NiceAssets[]) => void): void;
+    registerOnTouched(fn: (assets: NiceAssets[]) => void): void;
+    clickLeft(): void;
+    clickRight(): void;
+    clickAsset(index: number): void;
+    onFilesChange(event: Event): Promise<void>;
+    onFilesDrop(fileList: FileList): Promise<void>;
+    clickRemove(): void;
+    clickCustom(action: NiceAssetsCarouselActions): void;
+    startSyncVideo(): Promise<void>;
+    private filterOutUnsupportedFiles;
+    private getProcessedFiles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAssetsCarouselComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAssetsCarouselComponent, "nice-assets-carousel", never, { "color": { "alias": "color"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "customActions": { "alias": "customActions"; "required": false; }; "imagesProcessor": { "alias": "imagesProcessor"; "required": false; }; "multipleUpload": { "alias": "multipleUpload"; "required": false; }; "visiblePreviewAsset": { "alias": "visiblePreviewAsset"; "required": false; }; "showAddAssetContainer": { "alias": "showAddAssetContainer"; "required": false; }; "assets": { "alias": "assets"; "required": false; }; }, { "activeChange": "activeChange"; "removedAsset": "removedAsset"; }, ["activeContent"], never, false, never>;
+}
+
+declare class NiceAssetsCarouselActiveContentDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAssetsCarouselActiveContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceAssetsCarouselActiveContentDirective, "[niceAssetsCarouselActiveContent]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceDropzoneDirective {
+    fileOver: boolean;
+    filesDropped: EventEmitter<FileList>;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    ondrop(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceDropzoneDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceDropzoneDirective, "[niceDropzone]", never, {}, { "filesDropped": "filesDropped"; }, never, never, false, never>;
+}
+
+declare class NiceDropzoneModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceDropzoneModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceDropzoneModule, [typeof NiceDropzoneDirective], never, [typeof NiceDropzoneDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceDropzoneModule>;
+}
+
+declare class NiceAssetsCarouselModule {
+    static forRoot(options?: NiceAssetsCarouselOptions): ModuleWithProviders<NiceAssetsCarouselModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAssetsCarouselModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceAssetsCarouselModule, [typeof NiceAssetsCarouselComponent, typeof NiceAssetsCarouselActiveContentDirective], [typeof i2.CommonModule, typeof i4.MatIconModule, typeof i3.MatButtonModule, typeof i6.MatMenuModule, typeof i7.MatRippleModule, typeof NiceDropzoneModule, typeof i10.TranslateModule, typeof i10$1.MatProgressSpinnerModule], [typeof NiceAssetsCarouselComponent, typeof NiceAssetsCarouselActiveContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceAssetsCarouselModule>;
+}
+
+interface NiceAsyncTypeaheadSearchResult<T> {
+    items: T[];
+    nextPage: number | null;
+}
+declare abstract class NiceAsyncTypeaheadProvider<T, ID = number, Options = any> {
+    abstract resource: string;
+    abstract search(searchQuery: string, page: number, options?: Options): Observable<NiceAsyncTypeaheadSearchResult<T>> | Promise<NiceAsyncTypeaheadSearchResult<T>>;
+    abstract getById(id: ID, options?: Options): Promise<T>;
+    format(item: T): string;
+}
+
+type AsyncTypeaheadRequests = {
+    resource: string;
+    page: number;
+    searchQuery?: string;
+    searchOptions?: any;
+};
+declare class NiceAsyncTypeaheadService {
+    private readonly apis;
+    private state$;
+    loading$: Observable<boolean>;
+    loadingPage$: Observable<boolean>;
+    active$: Observable<any>;
+    items$: Observable<any[]>;
+    filteredItems$: Observable<any[]>;
+    private requests$;
+    private requestsSubscription$;
+    constructor(apis: NiceAsyncTypeaheadProvider<any>[]);
+    listenForRequest(): void;
+    closeRequestSubscription(): void;
+    initialize(resource: string): Promise<void>;
+    sendRequest(request: AsyncTypeaheadRequests): Observable<void>;
+    search(resource: string, searchQuery: string): void;
+    loadMore(resource: string): void;
+    getActive(): any;
+    getInitialized(): boolean;
+    getSearchOptions(): object | undefined;
+    setSearchOptions(searchOptions: object | undefined): void;
+    setActive(entity: any | undefined): void;
+    setActiveId(resource: string, id: any): Promise<void>;
+    reloadActive(resource: string): Promise<void>;
+    reloadFilteredItems(): void;
+    setFilterFn(filterFn: (value: any) => boolean | Promise<boolean> | Observable<boolean>): void;
+    format(resource: string, item: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAsyncTypeaheadService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceAsyncTypeaheadService>;
+}
+
+declare class NiceAsyncTypeaheadComponent implements OnInit, OnDestroy, OnChanges, ControlValueAccessor, MatFormFieldControl<any>, DoCheck {
+    readonly ngControl: NgControl;
+    private ngZone;
+    private changeDetectorRef;
+    service: NiceAsyncTypeaheadService;
+    stateChanges: Subject<void>;
+    controlType: string;
+    focused: boolean;
+    searchControl: FormControl<any>;
+    valueChangesSub$: Subscription;
+    open: boolean;
+    panelWidth: number;
+    activeOption: MatOption;
+    protected _errorStateTracker?: _ErrorStateTracker;
+    active$: Observable<any>;
+    input: ElementRef<HTMLInputElement>;
+    options: MatOption[];
+    entityRemoved: EventEmitter<void>;
+    resource: string;
+    searchOptions: any;
+    autoReload: boolean;
+    preloadResource: boolean;
+    allowNotFoundItems: boolean;
+    panelClass: string | string[];
+    bindValue: string;
+    bindLabel: string;
+    placeholder: string;
+    emptyPlaceholder: string;
+    optionTemplate: TemplateRef<HTMLElement>;
+    filterFn: (value: any) => boolean | Promise<boolean> | Observable<boolean>;
+    selected: EventEmitter<any>;
+    isOpened$: Subject<boolean>;
+    set labelFormatFn(labelFormatFn: (item: any) => string);
+    private _labelFormatFn;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    set disabled(value: BooleanInput);
+    get disabled(): boolean;
+    protected _disabled: boolean;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    set value(value: any);
+    get value(): string;
+    private _value;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    set required(value: BooleanInput);
+    get required(): boolean;
+    protected _required: boolean | undefined;
+    get shouldLabelFloat(): boolean;
+    get errorState(): boolean;
+    set errorState(value: boolean);
+    id: string;
+    describedBy: string;
+    private componentInitialized;
+    private initialWriteValue?;
+    get empty(): boolean;
+    get initialized(): boolean;
+    propagate: (value: string) => void;
+    constructor(ngControl: NgControl, ngZone: NgZone, changeDetectorRef: ChangeDetectorRef, service: NiceAsyncTypeaheadService);
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngDoCheck(): void;
+    writeValue(value: any): Promise<void>;
+    registerOnChange(propagate: (value: string) => void): void;
+    registerOnTouched(fn: any): void;
+    onContainerClick(event: MouseEvent): void;
+    setDescribedByIds(ids: string[]): void;
+    updateErrorState(): void;
+    getActive<T = any>(): T;
+    onOptionActivated(event: MatAutocompleteActivatedEvent): void;
+    onOptionSelected(event: MatAutocompleteSelectedEvent): void;
+    updateState(open: boolean): void;
+    onRemove(event?: Event, reload?: boolean): void;
+    formatLabel(item: any): string;
+    onEndScroll(): void;
+    focusChanged(isFocused: boolean): void;
+    reload(): void;
+    reloadActive(): Promise<void>;
+    setSearchOptions(options: any): void;
+    private updateLabel;
+    private getObjectItem;
+    private updateSearchInput;
+    private checkIfValueStillExist;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAsyncTypeaheadComponent, [{ optional: true; self: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAsyncTypeaheadComponent, "nice-async-typeahead", never, { "resource": { "alias": "resource"; "required": false; }; "searchOptions": { "alias": "searchOptions"; "required": false; }; "autoReload": { "alias": "autoReload"; "required": false; }; "preloadResource": { "alias": "preloadResource"; "required": false; }; "allowNotFoundItems": { "alias": "allowNotFoundItems"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "bindValue": { "alias": "bindValue"; "required": false; }; "bindLabel": { "alias": "bindLabel"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "emptyPlaceholder": { "alias": "emptyPlaceholder"; "required": false; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; }; "filterFn": { "alias": "filterFn"; "required": false; }; "labelFormatFn": { "alias": "labelFormatFn"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "entityRemoved": "entityRemoved"; "selected": "selected"; }, never, never, false, never>;
+}
+
+declare const NICE_ASYNC_TYPEAHEAD_PROVIDER: InjectionToken<unknown>;
+
+interface IAutoCompleteScrollEvent {
+    autoComplete: MatAutocomplete;
+    scrollEvent: Event;
+}
+declare class OptionsScrollDirective implements OnDestroy {
+    autoComplete: MatAutocomplete;
+    private _onDestroy$;
+    thresholdPercent: number;
+    optionsScroll: EventEmitter<IAutoCompleteScrollEvent>;
+    constructor(autoComplete: MatAutocomplete);
+    ngOnDestroy(): void;
+    onScroll(event: Event): void;
+    private removeScrollEventListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionsScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OptionsScrollDirective, "mat-autocomplete[optionsScroll]", never, { "thresholdPercent": { "alias": "thresholdPercent"; "required": false; }; }, { "optionsScroll": "optionsScroll"; }, never, never, false, never>;
+}
+
+declare class OptionScrollModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionScrollModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OptionScrollModule, [typeof OptionsScrollDirective], never, [typeof OptionsScrollDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OptionScrollModule>;
+}
+
+declare class NiceAsyncTypeaheadModule {
+    static register(providers: Type<NiceAsyncTypeaheadProvider<any, any>>[]): ModuleWithProviders<NiceAsyncTypeaheadModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAsyncTypeaheadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceAsyncTypeaheadModule, [typeof NiceAsyncTypeaheadComponent], [typeof i2.CommonModule, typeof i3$1.ReactiveFormsModule, typeof OptionScrollModule, typeof i6$1.MatInputModule, typeof i6$2.MatAutocompleteModule, typeof i4.MatIconModule, typeof i10$1.MatProgressSpinnerModule, typeof i9.MatProgressBarModule, typeof i10.TranslateModule], [typeof NiceAsyncTypeaheadComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceAsyncTypeaheadModule>;
+}
+
+declare abstract class NiceBaseFormComponent<Form extends {
+    [key: string]: any;
+}> implements OnInit, OnDestroy, ControlValueAccessor {
+    formGroup: GeneratedFormGroup<Form>;
+    private stepper;
+    loading: boolean;
+    submit: EventEmitter<Form>;
+    protected unsubscribeAll$: Subject<void>;
+    private propagate;
+    constructor(formGroup: GeneratedFormGroup<Form>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    registerOnChange(fn: (form: Form) => void): void;
+    registerOnTouched(fn: (form: Form) => void): void;
+    writeValue(form: Form): void;
+    clickSubmit(): void;
+    clickNext(index: number): void;
+    clickPrevious(): void;
+    protected onValueChange(value: Form): void;
+    validate(): boolean;
+    protected validateStep(index: number): boolean;
+    protected getCurrentStepGroup(index: number): FormGroup | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseFormComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceBaseFormComponent<any>, "ng-component", never, { "loading": { "alias": "loading"; "required": false; }; }, { "submit": "submit"; }, never, never, false, never>;
+}
+
+declare class NiceFormSubmitDirective {
+    form: NiceBaseFormComponent<any>;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFormSubmitDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceFormSubmitDirective, "[niceFormSubmit]", never, { "form": { "alias": "form"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceBaseFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceBaseFormModule, [typeof NiceFormSubmitDirective], never, [typeof NiceFormSubmitDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceBaseFormModule>;
+}
+
+declare class NiceBaseForm<T, Dto> {
+    constructor(value?: Partial<T>);
+    toDto(): Dto;
+}
+
+type NiceCardFace = "front" | "back";
+
+declare class NiceCardComponent implements OnChanges {
+    static ngAcceptInputType_expanded: BooleanInput;
+    static ngAcceptInputType_flippable: BooleanInput;
+    expanded: boolean;
+    face: NiceCardFace;
+    flippable: boolean;
+    /**
+     * Host binding for component classes
+     */
+    get classList(): any;
+    /**
+     * On changes
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceCardComponent, "nice-card", ["niceCard"], { "expanded": { "alias": "expanded"; "required": false; }; "face": { "alias": "face"; "required": false; }; "flippable": { "alias": "flippable"; "required": false; }; }, {}, never, ["[niceCardFront]", "[niceCardBack]", "*", "[niceCardExpansion]"], false, never>;
+}
+
+declare class NiceCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceCardModule, [typeof NiceCardComponent], [typeof i2.CommonModule], [typeof NiceCardComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceCardModule>;
+}
+
+interface PictureModalConfig {
+    picture?: string;
+}
+declare class PictureModalService {
+    private overlay;
+    constructor(overlay: Overlay);
+    open(config: PictureModalConfig): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PictureModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PictureModalService>;
+}
+
+type NiceCarouselIcons = {
+    svgIcon: string;
+};
+interface NiceCarouselIconOptions {
+    remove?: NiceCarouselIcons;
+}
+interface NiceCarouselOptions {
+    icons?: NiceCarouselIconOptions;
+}
+
+interface Picture {
+    id: number;
+    url: string;
+}
+declare class CarouselComponent {
+    private pictureModalService;
+    icons?: NiceCarouselIconOptions;
+    currentImages: Picture[];
+    set images(urls: Picture[]);
+    direction: "ltr" | "rtl" | "utd" | "dtu";
+    layout: "row" | "column";
+    editable: boolean;
+    delete: EventEmitter<Picture>;
+    constructor(pictureModalService: PictureModalService, icons?: NiceCarouselIconOptions);
+    clickView(picture: Picture): void;
+    clickDelete(picture: Picture): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselComponent, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CarouselComponent, "nice-carousel", never, { "images": { "alias": "images"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; }, { "delete": "delete"; }, never, never, false, never>;
+}
+
+declare class PictureModalComponent {
+    picture: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PictureModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PictureModalComponent, "nice-picture-modal", never, {}, {}, never, never, false, never>;
+}
+
+declare class CarouselLayoutPipe implements PipeTransform {
+    transform(value: "row" | "column", direction: "ltr" | "rtl" | "utd" | "dtu"): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselLayoutPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CarouselLayoutPipe, "carouselLayout", false>;
+}
+
+declare class NiceCarouselModule {
+    static forRoot(options?: NiceCarouselOptions): ModuleWithProviders<NiceCarouselModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceCarouselModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceCarouselModule, [typeof CarouselComponent, typeof PictureModalComponent, typeof CarouselLayoutPipe], [typeof i2.CommonModule, typeof i5.MatCardModule, typeof i3.MatButtonModule, typeof i10.TranslateModule, typeof i4.MatIconModule], [typeof CarouselComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceCarouselModule>;
+}
+
+declare class NiceCollapsableComponent implements OnInit, OnChanges, OnDestroy {
+    open: boolean;
+    openChange: EventEmitter<boolean>;
+    unsubscribeAll$: Subject<void>;
+    control: FormControl<boolean>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceCollapsableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceCollapsableComponent, "nice-collapsable", never, { "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, ["[niceCollapsableTitle]", "[niceCollapsableContent]"], false, never>;
+}
+
+declare class NiceCollapsableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceCollapsableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceCollapsableModule, [typeof NiceCollapsableComponent], [typeof i2.CommonModule, typeof i3$1.ReactiveFormsModule], [typeof NiceCollapsableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceCollapsableModule>;
+}
+
+declare class HeaderComponent<D> implements OnDestroy {
+    private calendar;
+    private dateAdapter;
+    private dateFormats;
+    private readonly destroy$;
+    toggled: boolean;
+    constructor(calendar: MatCalendar<D>, dateAdapter: DateAdapter<D>, dateFormats: MatDateFormats, cdr: ChangeDetectorRef);
+    get periodLabel(): string;
+    previousClicked(mode: "month" | "year"): void;
+    nextClicked(mode: "month" | "year"): void;
+    private changeDate;
+    clickOptions(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent<any>, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+interface NiceDateRangePickerValue {
+    from: Date;
+    to: Date;
+}
+declare class NiceDateRangePickerComponent implements OnInit, ControlValueAccessor {
+    readonly HeaderComponent: typeof HeaderComponent;
+    min: Date;
+    max: Date;
+    nowIsMax: boolean;
+    allowClear: boolean;
+    formGroup: FormGroup<{
+        from: FormControl<any>;
+        to: FormControl<any>;
+    }>;
+    now: Date;
+    value: NiceDateRangePickerValue;
+    private propagate;
+    ngOnInit(): void;
+    writeValue(value: NiceDateRangePickerValue): void;
+    registerOnChange(fn: (value: NiceDateRangePickerValue) => void): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceDateRangePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceDateRangePickerComponent, "nice-date-range-picker", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "nowIsMax": { "alias": "nowIsMax"; "required": false; }; "allowClear": { "alias": "allowClear"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceDateRangePickerServiceService {
+    allowClear$: BehaviorSubject<boolean>;
+    setAllowClear(allowClear: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceDateRangePickerServiceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceDateRangePickerServiceService>;
+}
+
+declare const customPresets: string[];
+type CustomPreset = typeof customPresets[number];
+declare class RangePresetComponent<D> {
+    private dateAdapter;
+    private picker;
+    private service;
+    readonly customPresets: string[];
+    readonly allowClear$: rxjs.BehaviorSubject<boolean>;
+    constructor(dateAdapter: DateAdapter<D>, picker: MatDateRangePicker<D>, service: NiceDateRangePickerServiceService);
+    clearRange(): void;
+    selectRange(rangeName: CustomPreset): void;
+    private calculateDateRange;
+    private calculateMonth;
+    private calculateWeek;
+    private get today();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangePresetComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RangePresetComponent<any>, "nice-range-preset", never, {}, {}, never, never, false, never>;
+}
+
+declare class BooleanPipe implements PipeTransform {
+    private readonly translateService;
+    constructor(translateService: TranslateService);
+    transform(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BooleanPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BooleanPipe, "boolean", false>;
+}
+
+declare class CapitalizeFirstLetterPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CapitalizeFirstLetterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CapitalizeFirstLetterPipe, "capitalizeFirstLetter", false>;
+}
+
+declare class CeilPipe implements PipeTransform {
+    transform(input: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CeilPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CeilPipe, "ceil", false>;
+}
+
+declare class FindByKeyPipe implements PipeTransform {
+    transform<ArrayType, ValueType>(array: ArrayType[], value: ValueType, key?: string): ArrayType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FindByKeyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FindByKeyPipe, "findByKey", false>;
+}
+
+declare class FirstLetterPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FirstLetterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FirstLetterPipe, "firstLetter", false>;
+}
+
+declare class FloorPipe implements PipeTransform {
+    transform(input: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FloorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FloorPipe, "floor", false>;
+}
+
+declare class JoinPipe implements PipeTransform {
+    transform(array: any[], separator?: string, prop?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JoinPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<JoinPipe, "join", false>;
+}
+
+declare class EntriesPipe implements PipeTransform {
+    transform<Value>(value: Value): {
+        key: keyof Value;
+        value: any;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntriesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EntriesPipe, "entries", false>;
+}
+
+declare class LinkPipe implements PipeTransform {
+    transform(value: string, type: "mailto"): string;
+    transform(value: {
+        phoneNumber: string;
+        extension?: string;
+    }, type: "tel"): string;
+    transform(value: {
+        address: string;
+        postalCode: string;
+    }, type: "direction"): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LinkPipe, "link", false>;
+}
+
+declare class LocalizedBooleanPipe implements PipeTransform {
+    private readonly translateService;
+    constructor(translateService: TranslateService);
+    transform(value: boolean): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedBooleanPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizedBooleanPipe, "localizedBoolean", false>;
+}
+
+declare class LocalizedCurrencyPipe extends CurrencyPipe implements PipeTransform {
+    private readonly translateService;
+    constructor(translateService: TranslateService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedCurrencyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizedCurrencyPipe, "localizedCurrency", false>;
+}
+
+declare class LocalizedDatePipe implements PipeTransform {
+    private readonly translateService;
+    constructor(translateService: TranslateService);
+    transform(value: any, pattern?: string, fallbackWithNull?: boolean, timeZone?: string): string;
+    private getMediumDateWithoutYearPattern;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizedDatePipe, "localizedDate", false>;
+}
+
+declare class LocalizedDateOnlyPipe implements PipeTransform {
+    private readonly translateService;
+    constructor(translateService: TranslateService);
+    transform(value: any, pattern?: string, fallbackWithNull?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedDateOnlyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizedDateOnlyPipe, "localizedDateOnly", false>;
+}
+
+declare class MinutesToTimePipe implements PipeTransform {
+    transform(totalMinutes: number, separator?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinutesToTimePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MinutesToTimePipe, "minutesToTime", false>;
+}
+
+declare class NumberToOrdinalIndicatorPipe implements PipeTransform {
+    transform(value: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberToOrdinalIndicatorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NumberToOrdinalIndicatorPipe, "numberToOrdinalIndicator", false>;
+}
+
+declare class PadPipe implements PipeTransform {
+    transform(value: number | string, length: number, direction?: "start" | "end", maxLength?: number, fillString?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PadPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PadPipe, "pad", false>;
+}
+
+declare class PhonePipe implements PipeTransform {
+    private maskService;
+    constructor(maskService: NgxMaskService);
+    transform(rawPhoneNumber: string, extension?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhonePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PhonePipe, "phone", false>;
+}
+
+declare class PostalCodePipe implements PipeTransform {
+    private maskService;
+    constructor(maskService: NgxMaskService);
+    transform(postalCode: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PostalCodePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PostalCodePipe, "postalCode", false>;
+}
+
+declare class RangePipe implements PipeTransform {
+    transform(value: number): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangePipe, "range", false>;
+}
+
+declare class RoundPipe implements PipeTransform {
+    transform(input: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoundPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RoundPipe, "round", false>;
+}
+
+declare class SanitizeBypassPipe implements PipeTransform {
+    private readonly sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(value: any, bypass: "html" | "style"): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SanitizeBypassPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SanitizeBypassPipe, "sanitizeBypass", false>;
+}
+
+declare class SecondsToTimePipe implements PipeTransform {
+    transform(value: number, separator?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecondsToTimePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SecondsToTimePipe, "secondsToTime", false>;
+}
+
+declare class TrackByPropPipe<T> implements PipeTransform {
+    transform(prop: keyof T & string): TrackByFunction<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrackByPropPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TrackByPropPipe<any>, "trackByProp", false>;
+}
+
+declare class NicePipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NicePipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NicePipesModule, [typeof BooleanPipe, typeof CapitalizeFirstLetterPipe, typeof CeilPipe, typeof FindByKeyPipe, typeof FirstLetterPipe, typeof FloorPipe, typeof JoinPipe, typeof EntriesPipe, typeof LinkPipe, typeof LocalizedBooleanPipe, typeof LocalizedCurrencyPipe, typeof LocalizedDatePipe, typeof LocalizedDateOnlyPipe, typeof MinutesToTimePipe, typeof NumberToOrdinalIndicatorPipe, typeof PadPipe, typeof PhonePipe, typeof PostalCodePipe, typeof RangePipe, typeof RoundPipe, typeof SanitizeBypassPipe, typeof SecondsToTimePipe, typeof TrackByPropPipe], never, [typeof BooleanPipe, typeof CapitalizeFirstLetterPipe, typeof CeilPipe, typeof FindByKeyPipe, typeof FirstLetterPipe, typeof FloorPipe, typeof JoinPipe, typeof EntriesPipe, typeof LinkPipe, typeof LocalizedBooleanPipe, typeof LocalizedCurrencyPipe, typeof LocalizedDatePipe, typeof LocalizedDateOnlyPipe, typeof MinutesToTimePipe, typeof NumberToOrdinalIndicatorPipe, typeof PadPipe, typeof PhonePipe, typeof PostalCodePipe, typeof RangePipe, typeof RoundPipe, typeof SanitizeBypassPipe, typeof SecondsToTimePipe, typeof TrackByPropPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NicePipesModule>;
+}
+
+declare class NiceDateRangePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceDateRangePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceDateRangePickerModule, [typeof NiceDateRangePickerComponent, typeof RangePresetComponent, typeof HeaderComponent], [typeof i2.CommonModule, typeof i5$1.MatDatepickerModule, typeof i6$3.MatFormFieldModule, typeof i5.MatCardModule, typeof i3.MatButtonModule, typeof i4.MatIconModule, typeof i10.TranslateModule, typeof i3$1.ReactiveFormsModule, typeof NicePipesModule], [typeof NiceDateRangePickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceDateRangePickerModule>;
+}
+
+type Scheme = "auto" | "dark" | "light";
+type Theme = "default" | string;
+type Screens = {
+    [key: string]: string;
+};
+/**
+ * NiceConfig interface. Update this interface to strictly type your config
+ * object.
+ */
+interface NiceConfig {
+    scheme: Scheme;
+    theme: Theme;
+    screens?: Screens;
+}
+
+declare class NiceConfigService {
+    private _config;
+    /**
+     * Constructor
+     */
+    constructor(config: NiceConfig);
+    /**
+     * Setter & getter for config
+     */
+    set config(value: NiceConfig);
+    get config$(): Observable<NiceConfig>;
+    /**
+     * Resets the config to the default
+     */
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceConfigService>;
+}
+
+declare class NiceConfigModule {
+    private _niceConfigService;
+    /**
+     * Constructor
+     */
+    constructor(_niceConfigService: NiceConfigService);
+    /**
+     * forRoot method for setting user configuration
+     */
+    static forRoot(config: NiceConfig): ModuleWithProviders<NiceConfigModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceConfigModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceConfigModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceConfigModule>;
+}
+
+declare class NiceMediaWatcherService {
+    private _breakpointObserver;
+    private _onMediaChange;
+    private _currentBreakpoints;
+    private _breakpoint$;
+    xsBreakpointActive$: Observable<boolean>;
+    smBreakpointActive$: Observable<boolean>;
+    mdBreakpointActive$: Observable<boolean>;
+    lgBreakpointActive$: Observable<boolean>;
+    xlBreakpointActive$: Observable<boolean>;
+    /**
+     * Constructor
+     */
+    constructor(_breakpointObserver: BreakpointObserver);
+    /**
+     * On media query change
+     */
+    onMediaQueryChange$(query: string | string[]): Observable<BreakpointState>;
+    asObservable(): Observable<BreakpointState>;
+    isActive(query: string | string[]): boolean;
+    private isBreakpointActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceMediaWatcherService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceMediaWatcherService>;
+}
+
+declare class NiceMediaWatcherModule {
+    private _niceMediaWatcherService;
+    /**
+     * Constructor
+     */
+    constructor(_niceMediaWatcherService: NiceMediaWatcherService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceMediaWatcherModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceMediaWatcherModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceMediaWatcherModule>;
+}
+
+declare class NiceSplashScreenService {
+    private _document;
+    private _router;
+    /**
+     * Constructor
+     */
+    constructor(_document: any, _router: Router);
+    /**
+     * Show the splash screen
+     */
+    show(): void;
+    /**
+     * Hide the splash screen
+     */
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSplashScreenService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceSplashScreenService>;
+}
+
+declare class NiceSplashScreenModule {
+    private _niceSplashScreenService;
+    /**
+     * Constructor
+     */
+    constructor(_niceSplashScreenService: NiceSplashScreenService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSplashScreenModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceSplashScreenModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceSplashScreenModule>;
+}
+
+declare class NiceDrawerService {
+    private _componentRegistry;
+    /**
+     * Constructor
+     */
+    constructor();
+    /**
+     * Register drawer component
+     */
+    registerComponent(name: string, component: NiceDrawerComponent): void;
+    /**
+     * Deregister drawer component
+     */
+    deregisterComponent(name: string): void;
+    /**
+     * Get drawer component from the registry
+     */
+    getComponent(name: string): NiceDrawerComponent | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceDrawerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceDrawerService>;
+}
+
+type NiceDrawerMode = "over" | "side";
+type NiceDrawerPosition = "left" | "right";
+
+declare class NiceDrawerComponent implements OnChanges, OnInit, OnDestroy {
+    private _animationBuilder;
+    private _elementRef;
+    private _renderer2;
+    private _niceDrawerService;
+    private _niceUtilsService;
+    static ngAcceptInputType_fixed: BooleanInput;
+    static ngAcceptInputType_opened: BooleanInput;
+    static ngAcceptInputType_transparentOverlay: BooleanInput;
+    fixed: boolean;
+    mode: NiceDrawerMode;
+    width: string | number;
+    name: string;
+    opened: boolean;
+    position: NiceDrawerPosition;
+    transparentOverlay: boolean;
+    private readonly fixedChanged;
+    private readonly modeChanged;
+    private readonly openedChanged;
+    private readonly positionChanged;
+    private _animationsEnabled;
+    private _hovered;
+    private _overlay;
+    private _player;
+    /**
+     * Constructor
+     */
+    constructor(_animationBuilder: AnimationBuilder, _elementRef: ElementRef, _renderer2: Renderer2, _niceDrawerService: NiceDrawerService, _niceUtilsService: NiceUtilsService);
+    /**
+     * Host binding for component classes
+     */
+    get classList(): any;
+    /**
+     * Host binding for component inline styles
+     */
+    get styleList(): any;
+    /**
+     * On mouseenter
+     *
+     * @private
+     */
+    private _onMouseenter;
+    /**
+     * On mouseleave
+     *
+     * @private
+     */
+    private _onMouseleave;
+    /**
+     * On changes
+     *
+     * @param changes
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Open the drawer
+     */
+    open(): void;
+    /**
+     * Close the drawer
+     */
+    close(): void;
+    /**
+     * Toggle the drawer
+     */
+    toggle(): void;
+    /**
+     * Enable the animations
+     *
+     * @private
+     */
+    private _enableAnimations;
+    /**
+     * Disable the animations
+     *
+     * @private
+     */
+    private _disableAnimations;
+    /**
+     * Show the backdrop
+     *
+     * @private
+     */
+    private _showOverlay;
+    /**
+     * Hide the backdrop
+     *
+     * @private
+     */
+    private _hideOverlay;
+    /**
+     * Open/close the drawer
+     *
+     * @param open
+     * @private
+     */
+    private _toggleOpened;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceDrawerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceDrawerComponent, "nice-drawer", ["niceDrawer"], { "fixed": { "alias": "fixed"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "width": { "alias": "width"; "required": false; }; "name": { "alias": "name"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "position": { "alias": "position"; "required": false; }; "transparentOverlay": { "alias": "transparentOverlay"; "required": false; }; }, { "fixedChanged": "fixedChanged"; "modeChanged": "modeChanged"; "openedChanged": "openedChanged"; "positionChanged": "positionChanged"; }, never, ["[niceDrawerToggle]", "*"], false, never>;
+}
+
+declare class NiceDrawerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceDrawerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceDrawerModule, [typeof NiceDrawerComponent], [typeof i2.CommonModule, typeof i4.MatIconModule], [typeof NiceDrawerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceDrawerModule>;
+}
+
+type DefaultStrategyType = "xlsx" | "csv" | "pdf";
+interface ExportStrategy {
+    type: DefaultStrategyType | string;
+    onClickExport: () => void;
+}
+
+declare abstract class ExportBottomSheetService {
+    abstract getStrategyIcon(strategy: ExportStrategy): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportBottomSheetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportBottomSheetService>;
+}
+declare class DefaultExportBottomSheetService extends ExportBottomSheetService {
+    getStrategyIcon(strategy: ExportStrategy): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultExportBottomSheetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultExportBottomSheetService>;
+}
+
+interface ExportBottomSheetConfig {
+    exportStrategies: ExportStrategy[];
+}
+declare class ExportBottomSheetComponent {
+    exportBottomSheetConfig: ExportBottomSheetConfig;
+    private bottomSheetRef;
+    private service;
+    constructor(exportBottomSheetConfig: ExportBottomSheetConfig, bottomSheetRef: MatBottomSheetRef<ExportBottomSheetComponent>, service: ExportBottomSheetService);
+    getStrategyIcon(strategy: ExportStrategy): string;
+    clickExport(strategy: ExportStrategy): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportBottomSheetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExportBottomSheetComponent, "nice-export-bottom-sheet", never, {}, {}, never, never, false, never>;
+}
+
+interface ExportBottomSheetOptions {
+    service: Type<ExportBottomSheetService>;
+}
+declare class NiceExportBottomSheetModule {
+    static forFeature(options: ExportBottomSheetOptions): ModuleWithProviders<NiceExportBottomSheetModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceExportBottomSheetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceExportBottomSheetModule, [typeof ExportBottomSheetComponent], [typeof i2.CommonModule, typeof i3$2.MatBottomSheetModule, typeof i4$1.MatListModule, typeof i4.MatIconModule, typeof i10.TranslateModule], [typeof ExportBottomSheetComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceExportBottomSheetModule>;
+}
+
+declare class NiceControlStatusDirective implements AfterViewInit, OnDestroy {
+    private el;
+    private vcr;
+    private formField;
+    private translateService;
+    private ref;
+    private control;
+    private unsubscribeAll$;
+    onChange: () => void;
+    constructor(el: ElementRef<HTMLElement>, vcr: ViewContainerRef, formField: MatFormField, translateService: TranslateService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    setError(text: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceControlStatusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceControlStatusDirective, "[niceControlStatus]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceFormErrorComponent {
+    message: string;
+    increment: number;
+    set error(value: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFormErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceFormErrorComponent, "[form-error]", never, { "error": { "alias": "error"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceFormErrorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFormErrorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceFormErrorModule, [typeof NiceFormErrorComponent, typeof NiceControlStatusDirective], [typeof i2.CommonModule, typeof i6$3.MatFormFieldModule], [typeof NiceFormErrorComponent, typeof NiceControlStatusDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceFormErrorModule>;
+}
+
+declare class NiceHorizontalStepperComponent extends CdkStepper {
+    private onStepperClick;
+    onClick(step: CdkStep, index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceHorizontalStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceHorizontalStepperComponent, "nice-horizontal-stepper", never, {}, { "onStepperClick": "onStepperClick"; }, never, never, false, never>;
+}
+
+declare class NiceStepComponent extends CdkStep {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceStepComponent, "nice-step", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class NiceHorizontalStepperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceHorizontalStepperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceHorizontalStepperModule, [typeof NiceStepComponent, typeof NiceHorizontalStepperComponent], [typeof i2.CommonModule, typeof i3.MatButtonModule, typeof i5$2.CdkStepperModule], [typeof NiceStepComponent, typeof NiceHorizontalStepperComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceHorizontalStepperModule>;
+}
+
+/** Image Cropper Config */
+declare class ImgCropperConfig {
+    /** Cropper area width */
+    width: number;
+    /** Cropper area height */
+    height: number;
+    minWidth: number;
+    minHeight: number;
+    /** If this is not defined, the new image will be automatically defined. */
+    type?: string;
+    /** Background color( default: null), if is null in png is transparent but not in jpg. */
+    fill?: string | null;
+    /**
+     * Set anti-aliased (default: true)
+     * @deprecated this is not necessary as the cropper will automatically resize the image
+     * to the best quality
+     */
+    antiAliased: boolean;
+    autoCrop?: boolean;
+    output?: ImgOutput | ImgResolution;
+    /**
+     * Zoom out until the entire image fits into the cropping area.
+     * default: false
+     */
+    extraZoomOut?: boolean;
+    /**
+     * Emit event `error` if the file size in bytes for the limit.
+     * Note: It only works when the image is received from the `<input>` event.
+     */
+    maxFileSize?: number | null;
+    /**
+     * Whether the cropper area will be round.
+     * This implies that the cropper area will maintain its aspect ratio.
+     * default: false
+     */
+    round?: boolean;
+    /**
+     * Whether the cropper area is resizable.
+     * default: false
+     */
+    resizableArea?: boolean;
+    /**
+     * Keep the width and height of the growing area the same according
+     * to `ImgCropperConfig.width` and `ImgCropperConfig.height`
+     * default: false
+     */
+    keepAspectRatio?: boolean;
+    /**
+     * Whether the cropper area is responsive.
+     * By default, the width and height of the cropper area is fixed,
+     * so can use when the cropper area is larger than its container,
+     * otherwise this will bring problems when cropping.
+     */
+    responsiveArea?: boolean;
+}
+/**
+ * The output image
+ * With this option you can resize the output image.
+ * If `width` or `height` are 0, this will be set automatically.
+ * Both cannot be 0.
+ */
+interface ImgOutput {
+    /**
+     * The cropped image will be resized to this `width`.
+     */
+    width: number;
+    /**
+     * Cropped image will be resized to this `height`.
+     */
+    height: number;
+}
+/** Image output */
+declare enum ImgResolution {
+    /**
+     * The output image will be equal to the initial size of the cropper area.
+     */
+    Default = 0,
+    /** Just crop the image without resizing */
+    OriginalImage = 1
+}
+/** Image output */
+declare enum ImgCropperError {
+    /** The loaded image exceeds the size limit set. */
+    Size = 0,
+    /** The file loaded is not image. */
+    Type = 1,
+    /** When the image has not been loaded. */
+    Other = 2
+}
+interface ImgCropperEvent {
+    /** Cropped image data URL */
+    dataURL?: string;
+    name: string | null;
+    /** Filetype */
+    type?: string;
+    /** Cropped area width */
+    areaWidth: number;
+    /** Cropped area height */
+    areaHeight: number;
+    /** Cropped image width */
+    width: number;
+    /** Cropped image height */
+    height: number;
+    /** Original Image data URL */
+    originalDataURL?: string;
+    scale: number;
+    /** Current rotation in degrees */
+    rotation: number;
+    /** Size of the image in bytes */
+    size: number;
+    /** Scaled offset from the left edge of the image */
+    left: number;
+    /** Scaled offset from the top edge of the image */
+    top: number;
+    /**
+     * Scaled offset from the left edge of the image to center of area
+     * Can be used to set image position
+     */
+    xOrigin: number;
+    /**
+     * Scaled offset from the top edge of the image to center of area
+     * Can be used to set image position
+     */
+    yOrigin: number;
+    /** @deprecated Use `xOrigin & yOrigin` instead. */
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+interface ImgCropperErrorEvent {
+    name?: string;
+    /** Size of the image in bytes */
+    size: number;
+    /** Filetype */
+    type: string;
+    /** Type of error */
+    error: ImgCropperError;
+    errorMsg?: string;
+}
+interface ImgCropperLoaderConfig {
+    name?: string | null;
+    /** Filetype */
+    type?: string;
+    /** Cropped area width */
+    areaWidth?: number;
+    /** Cropped area height */
+    areaHeight?: number;
+    /** Cropped image width */
+    width?: number;
+    /** Cropped image height */
+    height?: number;
+    /** Original Image data URL */
+    originalDataURL: string;
+    scale?: number;
+    /** Current rotation in degrees */
+    rotation?: number;
+    /** Size of the image in bytes */
+    size?: number;
+    /** Offset from the left edge of the image to center of area */
+    xOrigin?: number;
+    /** Offset from the top edge of the image to center of area */
+    yOrigin?: number;
+}
+declare class NiceImageCropperComponent implements OnInit, OnDestroy {
+    private _renderer;
+    readonly _elementRef: ElementRef<HTMLElement>;
+    private cd;
+    private _ngZone;
+    static readonly и = "NiceImageCropper";
+    private _currentLoadConfig?;
+    /** Original image */
+    private _img;
+    private offset?;
+    private _scale?;
+    private _scal3Fix?;
+    private _minScale?;
+    private _maxScale?;
+    /** Initial config */
+    private _configPrimary;
+    private _config;
+    private _imgRect;
+    private _rotation;
+    private _isSliding;
+    /** Keeps track of the last pointer event that was captured by the crop area. */
+    private _lastPointerEvent;
+    private _startPointerEvent;
+    _primaryAreaWidth: number;
+    _primaryAreaHeight: number;
+    _absoluteScale: number;
+    /**
+     * When is loaded image
+     * @internal
+     */
+    _isLoadedImg: boolean;
+    /** When is loaded image & ready for crop */
+    isLoaded: boolean;
+    /** When the cropper is ready to be interacted  */
+    isReady: boolean;
+    isCropped: boolean;
+    private _imgContainer;
+    private _areaRef;
+    private _imgCanvas;
+    set config(val: ImgCropperConfig);
+    get config(): ImgCropperConfig;
+    /** Set scale */
+    set scale(val: number | undefined);
+    get scale(): number | undefined;
+    /**
+     * Emit event `error` if the file size for the limit.
+     * Note: It only works when the image is received from the `<input>` event.
+     */
+    maxFileSize: number;
+    /** Get min scale */
+    get minScale(): number | undefined;
+    private readonly scaleChange;
+    /** Emits minimum supported image scale */
+    private readonly minScaleChange;
+    /** Emits maximum supported image scale */
+    private readonly maxScaleChange;
+    /** Emits when the image is loaded */
+    private readonly imageLoaded;
+    /** Emits when the cropper is ready to be interacted */
+    private readonly ready;
+    /** On crop new image */
+    private readonly cropped;
+    /** Emits when the cropper is cleaned */
+    private readonly cleaned;
+    /** Emit an error when the loaded image is not valid */
+    private readonly error;
+    private _currentInputElement?;
+    /** Emits whenever the component is destroyed. */
+    private readonly _destroy;
+    /** Used to subscribe to global move and end events */
+    protected _document: Document;
+    constructor(_renderer: Renderer2, _elementRef: ElementRef<HTMLElement>, cd: ChangeDetectorRef, _ngZone: NgZone, _document: any, viewPortRuler: ViewportRuler);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Load image with canvas */
+    private _imgLoaded;
+    private _setStylesForContImg;
+    /**
+     * Update area and image position only if needed,
+     * this is used when window resize
+     */
+    updateCropperPosition(): void;
+    /** Load Image from input event */
+    selectInputEvent(img: Event): void;
+    /** Set the size of the image, the values can be 0 between 1, where 1 is the original size */
+    setScale(size?: number, noAutoCrop?: boolean): void;
+    private _getCenterPoints;
+    /**
+     * Fit to screen
+     */
+    fitToScreen(): void;
+    fit(): void;
+    private _pointerDown;
+    /**
+     * Simulate pointerMove with clientX = 0 and clientY = 0,
+     * this is used by `setScale` and `rotate`
+     */
+    private _simulatePointerMove;
+    _markForCheck(): void;
+    /**
+     * Called when the user has moved their pointer after
+     * starting to drag.
+     */
+    private _pointerMove;
+    updatePosition(): void;
+    updatePosition(xOrigin: number, yOrigin: number): void;
+    _slideEnd(): void;
+    private _cropIfAutoCrop;
+    /** + */
+    zoomIn(): void;
+    /** Clean the img cropper */
+    clean(): void;
+    /** - */
+    zoomOut(): void;
+    center(): void;
+    /**
+     * load an image from a given configuration,
+     * or from the result of a cropped image
+     */
+    loadImage(config: ImgCropperLoaderConfig | string, fn?: () => void): void;
+    private _updateAreaIfNeeded;
+    private _updateAbsoluteScale;
+    /**
+     * Load Image from URL
+     * @deprecated Use `loadImage` instead of `setImageUrl`
+     * @param src URL
+     * @param fn function that will be called before emit the event loaded
+     */
+    setImageUrl(src: string, fn?: () => void): void;
+    private _positionImg;
+    rotate(degrees: number): void;
+    _updateMinScale(canvas?: HTMLCanvasElement): void;
+    private _updateMaxScale;
+    /**
+     * Resize & crop image
+     */
+    crop(config?: ImgCropperConfig): ImgCropperEvent;
+    /**
+     * @docs-private
+     */
+    private _imgCrop;
+    _rootRect(): DOMRect;
+    _areaCropperRect(): DOMRect;
+    _canvasRect(): DOMRect;
+    /** Called when the user has lifted their pointer. */
+    private _pointerUp;
+    /** Called when the window has lost focus. */
+    private _windowBlur;
+    private _bindGlobalEvents;
+    /** Removes any global event listeners that we may have added. */
+    private _removeGlobalEvents;
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    private _getWindow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceImageCropperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceImageCropperComponent, "nice-img-cropper, nice-image-cropper", never, { "config": { "alias": "config"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; }; }, { "scaleChange": "scaleChange"; "minScaleChange": "minScale"; "maxScaleChange": "maxScale"; "imageLoaded": "imageLoaded"; "ready": "ready"; "cropped": "cropped"; "cleaned": "cleaned"; "error": "error"; }, never, never, false, never>;
+}
+/**
+ * Normalize degrees for cropper rotation
+ * @docs-private
+ */
+declare function _normalizeDegrees(n: number): number;
+declare function round(n: number): number;
+declare function mergeDeep<T, U>(target: T, source: U): T & U;
+declare function mergeDeep<T, U, V>(target: T, source1: U, source2: V): T & U & V;
+declare function mergeDeep<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+declare function mergeDeep(target: object, ...sources: any[]): any;
+/**
+ * We have the cropper area in the same file to fix the build
+ */
+declare class NiceCropperAreaComponent implements OnDestroy {
+    private readonly _elementRef;
+    private readonly _cropper;
+    private readonly _ngZone;
+    private readonly _resizer?;
+    keepAspectRatio: boolean;
+    round: boolean;
+    /** Used to subscribe to global move and end events */
+    protected _document: Document;
+    private _isSliding;
+    /** Keeps track of the last pointer event that was captured by the crop area. */
+    private _lastPointerEvent;
+    private _startPointerEvent;
+    private _currentWidth;
+    private _currentHeight;
+    private _startAreaRect;
+    private _startImgRect;
+    constructor(_document: any, _elementRef: ElementRef, _cropper: NiceImageCropperComponent, _ngZone: NgZone);
+    private _resizableArea;
+    set resizableArea(val: boolean);
+    get resizableArea(): boolean;
+    ngOnDestroy(): void;
+    private _addResizableArea;
+    private _removeResizableArea;
+    private _pointerDown;
+    private _pointerMove;
+    /** Called when the user has lifted their pointer. */
+    private _pointerUp;
+    /** Called when the window has lost focus. */
+    private _windowBlur;
+    private _bindGlobalEvents;
+    /** Removes any global event listeners that we may have added. */
+    private _removeGlobalEvents;
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    private _getWindow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceCropperAreaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceCropperAreaComponent, "nice-cropper-area", never, { "keepAspectRatio": { "alias": "keepAspectRatio"; "required": false; }; "round": { "alias": "round"; "required": false; }; "resizableArea": { "alias": "resizableArea"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceImageCropperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceImageCropperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceImageCropperModule, [typeof NiceImageCropperComponent, typeof NiceCropperAreaComponent], [typeof i2.CommonModule, typeof i3.MatButtonModule, typeof i4.MatIconModule], [typeof NiceImageCropperComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceImageCropperModule>;
+}
+
+declare class NiceLayoutComponent implements OnInit, OnDestroy {
+    private _document;
+    private _renderer2;
+    private _niceConfigService;
+    private _niceMediaWatcherService;
+    private config;
+    private scheme;
+    private theme;
+    private _unsubscribeAll;
+    /**
+     * Constructor
+     */
+    constructor(_document: any, _renderer2: Renderer2, _niceConfigService: NiceConfigService, _niceMediaWatcherService: NiceMediaWatcherService);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Update the selected scheme
+     *
+     * @private
+     */
+    private _updateScheme;
+    /**
+     * Update the selected theme
+     *
+     * @private
+     */
+    private _updateTheme;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceLayoutComponent, "nice-layout", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class NiceLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceLayoutModule, [typeof NiceLayoutComponent], never, [typeof NiceLayoutComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceLayoutModule>;
+}
+
+declare class NiceLoadingSpinnerComponent {
+    loading: boolean;
+    mode: ProgressSpinnerMode;
+    diameter: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLoadingSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceLoadingSpinnerComponent, "nice-loading-spinner", never, { "loading": { "alias": "loading"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DynamicOverlayContainer extends OverlayContainer {
+    setContainerElement(containerElement: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicOverlayContainer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicOverlayContainer>;
+}
+
+declare class DynamicOverlay extends Overlay {
+    private readonly _dynamicOverlayContainer;
+    private renderer;
+    constructor(_document: any, scrollStrategies: ScrollStrategyOptions, _overlayContainer: DynamicOverlayContainer, _componentFactoryResolver: ComponentFactoryResolver, _positionBuilder: OverlayPositionBuilder, _keyboardDispatcher: OverlayKeyboardDispatcher, _injector: Injector, _ngZone: NgZone, _directionality: Directionality, rendererFactory: RendererFactory2, _location: Location, _outsideClickDispatcher: OverlayOutsideClickDispatcher);
+    setContainerElement(containerElement: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicOverlay, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicOverlay>;
+}
+
+interface NiceLoadingOptions {
+    customLoading?: Type<any>;
+}
+declare class NiceLoadingDirective {
+    private options;
+    private elRef;
+    private overlay;
+    private overlayRef;
+    private _loading;
+    set loading(loading: boolean | null);
+    constructor(options: NiceLoadingOptions, elRef: ElementRef, overlay: DynamicOverlay);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLoadingDirective, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceLoadingDirective, "[niceLoadingOverlay]", never, { "loading": { "alias": "niceLoadingOverlay"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceLoadingSpinnerModule {
+    static forRoot(options?: NiceLoadingOptions): ModuleWithProviders<NiceLoadingSpinnerModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLoadingSpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceLoadingSpinnerModule, [typeof NiceLoadingSpinnerComponent, typeof NiceLoadingDirective], [typeof i2.CommonModule, typeof i10$1.MatProgressSpinnerModule], [typeof NiceLoadingSpinnerComponent, typeof NiceLoadingDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceLoadingSpinnerModule>;
+}
+
+interface NiceLoadingToastOptions {
+    appearance?: NiceAlertAppearance;
+    showIcon?: boolean;
+    type?: NiceAlertType;
+    color?: NiceAlertColor;
+}
+declare class NiceLoadingToastService {
+    private options;
+    private snackbar;
+    private translateService;
+    constructor(options: NiceLoadingToastOptions, snackbar: MatSnackBar, translateService: TranslateService);
+    showLoadingToast(messageKey: string, params?: object): MatSnackBarRef<any>;
+    private getTranslations;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLoadingToastService, [{ optional: true; }, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceLoadingToastService>;
+}
+
+interface NiceLoadingToastData {
+    message: string;
+    options?: NiceLoadingToastOptions;
+}
+declare class NiceLoadingToastComponent {
+    data?: NiceLoadingToastData;
+    message: string;
+    options: NiceLoadingToastOptions;
+    get appearance(): NiceAlertAppearance;
+    get color(): NiceAlertColor;
+    get showIcon(): boolean;
+    get type(): NiceAlertType;
+    constructor(data?: NiceLoadingToastData);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLoadingToastComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceLoadingToastComponent, "nice-loading-toast", never, { "message": { "alias": "message"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceLoadingToastDirective {
+    private options;
+    private overlay;
+    static ngAcceptInputType_niceLoadingDisableUserInteraction: BooleanInput;
+    private overlayRef;
+    private _loading;
+    private _niceLoadingDisableUserInteraction;
+    niceLoadingMessage: string;
+    set niceLoadingDisableUserInteraction(disableUserInteraction: boolean);
+    set loading(loading: boolean | null);
+    constructor(options: NiceLoadingToastOptions, overlay: Overlay);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLoadingToastDirective, [{ optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceLoadingToastDirective, "[niceLoadingToast]", never, { "niceLoadingMessage": { "alias": "niceLoadingMessage"; "required": false; }; "niceLoadingDisableUserInteraction": { "alias": "niceLoadingDisableUserInteraction"; "required": false; }; "loading": { "alias": "niceLoadingToast"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceLoadingToastModule {
+    static forRoot(options?: NiceLoadingToastOptions): ModuleWithProviders<NiceLoadingToastModule>;
+    static forFeature(options: NiceLoadingToastOptions): ModuleWithProviders<NiceLoadingToastModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLoadingToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceLoadingToastModule, [typeof NiceLoadingToastComponent, typeof NiceLoadingToastDirective], [typeof i2.CommonModule, typeof i4$2.MatSnackBarModule, typeof i10$1.MatProgressSpinnerModule, typeof NiceAlertModule], [typeof NiceLoadingToastDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceLoadingToastModule>;
+}
+
+interface ShowLoadingToastOperatorOptions {
+    minDuration?: number;
+}
+declare function showLoadingToast<T>(loadingToastService: NiceLoadingToastService, key: string, options?: ShowLoadingToastOperatorOptions): MonoTypeOperatorFunction<T>;
+
+declare class NiceLottieComponent implements OnInit, AfterViewInit {
+    private platformId;
+    private _options;
+    private _lottie;
+    options: any;
+    width: number;
+    height: number;
+    animCreated: EventEmitter<any>;
+    animationContainer: ElementRef;
+    viewWidth: string;
+    viewHeight: string;
+    constructor(platformId: string);
+    ngOnInit(): void;
+    ngAfterViewInit(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLottieComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceLottieComponent, "nice-lottie", never, { "options": { "alias": "options"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, { "animCreated": "animCreated"; }, never, never, false, never>;
+}
+
+declare class NiceLottieModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceLottieModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceLottieModule, [typeof NiceLottieComponent], [typeof i2.CommonModule], [typeof NiceLottieComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceLottieModule>;
+}
+
+declare abstract class _HintComponentBase implements OnDestroy {
+    private _changeDetectorRef;
+    /** The timeout ID of any current timer set to show the tooltip */
+    private _showTimeoutId;
+    /** The timeout ID of any current timer set to hide the tooltip */
+    private _hideTimeoutId;
+    /** Element that caused the tooltip to open. */
+    _triggerElement: HTMLElement;
+    /** Amount of milliseconds to delay the closing sequence. */
+    _mouseLeaveHideDelay: number;
+    /** Reference to the internal tooltip element. */
+    abstract _hint: ElementRef<HTMLElement>;
+    /** Whether interactions on the page should close the tooltip */
+    private _closeOnInteraction;
+    /** Whether the tooltip is currently visible. */
+    private _isVisible;
+    /** Subject for notifying that the tooltip has been hidden from the view */
+    private readonly _onHide;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    /**
+     * Shows the tooltip with an animation originating from the provided origin
+     * @param delay Amount of milliseconds to the delay showing the tooltip.
+     */
+    show(delay: number): void;
+    /**
+     * Begins the animation to hide the tooltip after the provided delay in ms.
+     * @param delay Amount of milliseconds to delay showing the tooltip.
+     */
+    hide(delay: number): void;
+    /** Returns an observable that notifies when the tooltip has been hidden from view. */
+    afterHidden(): Observable<void>;
+    /** Whether the tooltip is being displayed. */
+    isVisible(): boolean;
+    ngOnDestroy(): void;
+    /**
+     * Interactions on the HTML body should close the tooltip immediately as defined in the
+     * material design spec.
+     * https://material.io/design/components/tooltips.html#behavior
+     */
+    _handleBodyInteraction(): void;
+    /**
+     * Marks that the tooltip needs to be checked in the next change detection run.
+     * Mainly used for rendering the initial text before positioning a tooltip, which
+     * can be problematic in components with OnPush change detection.
+     */
+    _markForCheck(): void;
+    _handleMouseLeave({ relatedTarget }: MouseEvent): void;
+    /**
+     * Callback for when the timeout in this.show() gets completed.
+     * This method is only needed by the mdc-tooltip, and so it is only implemented
+     * in the mdc-tooltip, not here.
+     */
+    protected _onShow(): void;
+    /** Cancels any pending animation sequences. */
+    _cancelPendingAnimations(): void;
+    /** Handles the cleanup after an animation has finished. */
+    private _finalizeAnimation;
+    /** Toggles the visibility of the tooltip element. */
+    private _toggleVisibility;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_HintComponentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_HintComponentBase, never, never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class NavigationHideItemResolver {
+    abstract shouldHide(item: NiceNavigationItem): Observable<boolean>;
+}
+
+declare abstract class NavigationHintResolver {
+    abstract shouldShowHint(): Observable<boolean>;
+}
+
+type IconType = "fontawesome" | "material" | "svg";
+interface NiceNavigationItem {
+    id?: string;
+    title?: string;
+    subtitle?: string;
+    type: "aside" | "basic" | "collapsable" | "divider" | "group" | "spacer";
+    hidden?: Type<NavigationHideItemResolver> | ((item: NiceNavigationItem) => boolean) | boolean;
+    active?: boolean;
+    disabled?: boolean;
+    link?: string;
+    externalLink?: boolean;
+    exactMatch?: boolean;
+    queryParams?: any;
+    state?: any;
+    function?: (item: NiceNavigationItem) => void;
+    classes?: {
+        title?: string;
+        subtitle?: string;
+        icon?: string;
+        wrapper?: string;
+    };
+    icon?: string;
+    activeIcon?: string;
+    iconType?: IconType;
+    badge?: {
+        title?: string;
+        classes?: string;
+    };
+    children?: NiceNavigationItem[];
+    meta?: any;
+    hint?: {
+        resolver: Type<NavigationHintResolver>;
+        component: Type<any>;
+    };
+    tooltip?: string;
+}
+type NiceVerticalNavigationAppearance = "default" | "compact" | "dense" | "thin";
+type NiceVerticalNavigationMode = "over" | "side";
+type NiceVerticalNavigationPosition = "left" | "right";
+
+declare class NiceNavigationService implements OnDestroy {
+    private router;
+    private _onNavigationChanged;
+    private _onNavigationRegistered;
+    private _onNavigationUnregistered;
+    private _defaultNavigationKey;
+    private _currentNavigationKey;
+    private _componentRegistry;
+    private _navigationStore;
+    protected _unsubscribeAll: Subject<any>;
+    /**
+     * Constructor
+     */
+    constructor(router: Router);
+    get onNavigationChanged(): Observable<any>;
+    get onNavigationRegistered(): Observable<any>;
+    get onNavigationUnregistered(): Observable<any>;
+    ngOnDestroy(): void;
+    /**
+     * Register navigation component
+     */
+    registerComponent(name: string, component: any): void;
+    /**
+     * Deregister navigation component
+     */
+    deregisterComponent(name: string): void;
+    /**
+     * Get navigation component from the registry
+     */
+    getComponent(name: string): any;
+    /**
+     * Store the given navigation with the given key
+     */
+    storeNavigation(key: string, navigation: NiceNavigationItem[], isDefault?: boolean): void;
+    /**
+     * Get navigation from storage by key
+     */
+    getNavigation(key: string): NiceNavigationItem[];
+    /**
+     * Delete the navigation from the storage
+     */
+    deleteNavigation(key: string): void;
+    /**
+     * Utility function that returns a flattened
+     * version of the given navigation array
+     */
+    getFlatNavigation(navigation: NiceNavigationItem[], flatNavigation?: NiceNavigationItem[]): NiceNavigationItem[];
+    /**
+     * Utility function that returns the item
+     * with the given id from given navigation
+     */
+    getItem(id: string, navigation: NiceNavigationItem[]): NiceNavigationItem | null;
+    /**
+     * Utility function that returns the item's parent
+     * with the given id from given navigation
+     */
+    getItemParent(id: string, navigation: NiceNavigationItem[], parent: NiceNavigationItem[] | NiceNavigationItem): NiceNavigationItem[] | NiceNavigationItem | null;
+    getCurrentNavigation(): NiceNavigationItem[];
+    setCurrentNavigation(key: string): void;
+    private listenOnRouteChange;
+    private lastChild;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceNavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceNavigationService>;
+}
+
+declare class NiceTranslationContextService {
+    private _context;
+    get context(): Record<string, any>;
+    set context(context: Record<string, any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceTranslationContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceTranslationContextService>;
+}
+
+declare class NiceNavigationComponent implements OnInit, OnDestroy, OnChanges {
+    protected _changeDetectorRef: ChangeDetectorRef;
+    protected _niceNavigationService: NiceNavigationService;
+    protected _niceUtilsService: NiceUtilsService;
+    protected _translationContext: NiceTranslationContextService;
+    protected _navigation: NiceNavigationItem[];
+    protected _unsubscribeAll: Subject<any>;
+    animateNextNavChange: boolean;
+    onRefreshed: ReplaySubject<boolean>;
+    name: string;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService, _niceUtilsService: NiceUtilsService, _translationContext: NiceTranslationContextService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Refresh the component to apply the changes
+     */
+    refresh(): void;
+    /**
+     * Track by function for ngFor loops
+     */
+    trackByFn(index: number, item: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceNavigationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceNavigationComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceHorizontalNavigationComponent extends NiceNavigationComponent {
+    name: string;
+    showTooltips: boolean;
+    tooltipPosition: TooltipPosition;
+    translationContext: Record<string, any>;
+    set navigation(navigation: NiceNavigationItem[]);
+    get navigation(): NiceNavigationItem[];
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService, _niceUtilsService: NiceUtilsService, _translationContextService: NiceTranslationContextService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceHorizontalNavigationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceHorizontalNavigationComponent, "nice-horizontal-navigation", ["niceHorizontalNavigation"], { "name": { "alias": "name"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "translationContext": { "alias": "translationContext"; "required": false; }; "navigation": { "alias": "navigation"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceHorizontalNavigationBasicItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _niceNavigationService;
+    private _niceHorizontalNavigationComponent;
+    private _unsubscribeAll;
+    item: NiceNavigationItem;
+    name: string;
+    showTooltips: boolean;
+    tooltipPosition: TooltipPosition;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceHorizontalNavigationBasicItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceHorizontalNavigationBasicItemComponent, "nice-horizontal-navigation-basic-item", never, { "item": { "alias": "item"; "required": false; }; "name": { "alias": "name"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceHorizontalNavigationBranchItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _niceNavigationService;
+    static ngAcceptInputType_child: BooleanInput;
+    private _niceHorizontalNavigationComponent;
+    private _unsubscribeAll;
+    child: boolean;
+    item: NiceNavigationItem;
+    name: string;
+    matMenu: MatMenu;
+    showTooltips: boolean;
+    tooltipPosition: TooltipPosition;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Trigger the change detection
+     */
+    triggerChangeDetection(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceHorizontalNavigationBranchItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceHorizontalNavigationBranchItemComponent, "nice-horizontal-navigation-branch-item", never, { "child": { "alias": "child"; "required": false; }; "item": { "alias": "item"; "required": false; }; "name": { "alias": "name"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceHorizontalNavigationDividerItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _niceNavigationService;
+    private _niceHorizontalNavigationComponent;
+    private _unsubscribeAll;
+    item: NiceNavigationItem;
+    name: string;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceHorizontalNavigationDividerItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceHorizontalNavigationDividerItemComponent, "nice-horizontal-navigation-divider-item", never, { "item": { "alias": "item"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceHorizontalNavigationSpacerItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _niceNavigationService;
+    private _niceHorizontalNavigationComponent;
+    private _unsubscribeAll;
+    item: NiceNavigationItem;
+    name: string;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceHorizontalNavigationSpacerItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceHorizontalNavigationSpacerItemComponent, "nice-horizontal-navigation-spacer-item", never, { "item": { "alias": "item"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ScrollbarGeometry {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    constructor(x: number, y: number, w: number, h: number);
+}
+declare class ScrollbarPosition {
+    x: number | "start" | "end";
+    y: number | "start" | "end";
+    constructor(x: number | "start" | "end", y: number | "start" | "end");
+}
+
+/**
+ * Wrapper directive for the Perfect Scrollbar: https://github.com/mdbootstrap/perfect-scrollbar
+ */
+declare class NiceScrollbarDirective implements OnChanges, OnInit, OnDestroy {
+    private _elementRef;
+    private _platform;
+    private _router;
+    static ngAcceptInputType_niceScrollbar: BooleanInput;
+    private _animation;
+    private _options;
+    private _ps;
+    private _unsubscribeAll;
+    niceScrollbar: boolean;
+    niceScrollbarOptions: PerfectScrollbar.Options;
+    /**
+     * Constructor
+     */
+    constructor(_elementRef: ElementRef, _platform: Platform, _router: Router);
+    /**
+     * Getter for _elementRef
+     */
+    get elementRef(): ElementRef;
+    /**
+     * Getter for _ps
+     */
+    get ps(): PerfectScrollbar | null;
+    /**
+     * On changes
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Update the scrollbar
+     */
+    update(): void;
+    /**
+     * Destroy the scrollbar
+     */
+    destroy(): void;
+    /**
+     * Returns the geometry of the scrollable element
+     */
+    geometry(prefix?: string): ScrollbarGeometry;
+    /**
+     * Returns the position of the scrollable element
+     */
+    position(absolute?: boolean): ScrollbarPosition;
+    /**
+     * Scroll to
+     */
+    scrollTo(x: number, y?: number, speed?: number): void;
+    /**
+     * Scroll to X
+     */
+    scrollToX(x: number, speed?: number): void;
+    /**
+     * Scroll to Y
+     */
+    scrollToY(y: number, speed?: number): void;
+    /**
+     * Scroll to top
+     */
+    scrollToTop(offset?: number, speed?: number): void;
+    /**
+     * Scroll to bottom
+     */
+    scrollToBottom(offset?: number, speed?: number): void;
+    /**
+     * Scroll to left
+     */
+    scrollToLeft(offset?: number, speed?: number): void;
+    /**
+     * Scroll to right
+     */
+    scrollToRight(offset?: number, speed?: number): void;
+    /**
+     * Scroll to element
+     */
+    scrollToElement(qs: string, offset?: number, ignoreVisible?: boolean, speed?: number): void;
+    /**
+     * Animate scrolling
+     */
+    animateScrolling(target: string, value: number, speed?: number): void;
+    /**
+     * Initialize
+     */
+    private _init;
+    /**
+     * Destroy
+     */
+    private _destroy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceScrollbarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceScrollbarDirective, "[niceScrollbar]", ["niceScrollbar"], { "niceScrollbar": { "alias": "niceScrollbar"; "required": false; }; "niceScrollbarOptions": { "alias": "niceScrollbarOptions"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceScrollbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceScrollbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceScrollbarModule, [typeof NiceScrollbarDirective], never, [typeof NiceScrollbarDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceScrollbarModule>;
+}
+
+declare class NiceNavigationHintService {
+    hasActiveHint$: BehaviorSubject<boolean>;
+    get hasActiveHint(): boolean;
+    setActiveHint(isActive: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceNavigationHintService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceNavigationHintService>;
+}
+
+declare class NiceVerticalNavigationComponent extends NiceNavigationComponent implements OnChanges, OnInit, AfterViewInit {
+    private _animationBuilder;
+    private _elementRef;
+    private _renderer2;
+    private _router;
+    private _scrollStrategyOptions;
+    private _hintService;
+    static ngAcceptInputType_inner: BooleanInput;
+    static ngAcceptInputType_opened: BooleanInput;
+    static ngAcceptInputType_transparentOverlay: BooleanInput;
+    private _forceHovered;
+    private _animationsEnabled;
+    private _asideOverlay;
+    private readonly _handleAsideOverlayClick;
+    private readonly _handleOverlayClick;
+    private _overlay;
+    private _player;
+    private _scrollStrategy;
+    private _niceScrollbarDirectives;
+    private _niceScrollbarDirectivesSubscription;
+    name: string;
+    appearance: NiceVerticalNavigationAppearance;
+    autoCollapse: boolean;
+    inner: boolean;
+    mode: NiceVerticalNavigationMode;
+    opened: boolean;
+    hovered: boolean;
+    hasHint: boolean;
+    position: NiceVerticalNavigationPosition;
+    showTooltips: boolean;
+    transparentOverlay: boolean;
+    tooltipPosition: TooltipPosition;
+    translationContext: Record<string, any>;
+    readonly appearanceChanged: EventEmitter<NiceVerticalNavigationAppearance>;
+    readonly modeChanged: EventEmitter<NiceVerticalNavigationMode>;
+    readonly openedChanged: EventEmitter<boolean>;
+    readonly hoveredChanged: EventEmitter<boolean>;
+    readonly positionChanged: EventEmitter<NiceVerticalNavigationPosition>;
+    private _navigationContentEl;
+    set navigation(navigation: NiceNavigationItem[]);
+    get navigation(): NiceNavigationItem[];
+    set forceHovered(forceHovered: boolean);
+    activeAsideItemId: string | null;
+    onCollapsableItemCollapsed: ReplaySubject<NiceNavigationItem>;
+    onCollapsableItemExpanded: ReplaySubject<NiceNavigationItem>;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService, _niceUtilsService: NiceUtilsService, _translationContextService: NiceTranslationContextService, _animationBuilder: AnimationBuilder, _elementRef: ElementRef, _renderer2: Renderer2, _router: Router, _scrollStrategyOptions: ScrollStrategyOptions, _hintService: NiceNavigationHintService);
+    /**
+     * Host binding for component classes
+     */
+    get classList(): any;
+    /**
+     * Host binding for component inline styles
+     */
+    get styleList(): any;
+    /**
+     * Setter for niceScrollbarDirectives
+     */
+    set niceScrollbarDirectives(niceScrollbarDirectives: QueryList<NiceScrollbarDirective>);
+    /**
+     * On changes
+     *
+     * @param changes
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * After view init
+     */
+    ngAfterViewInit(): void;
+    /**
+     * Open the navigation
+     */
+    open(): void;
+    /**
+     * Close the navigation
+     */
+    close(): void;
+    /**
+     * Toggle the navigation
+     */
+    toggle(): void;
+    /**
+     * Open the aside
+     */
+    openAside(item: NiceNavigationItem): void;
+    /**
+     * Close the aside
+     */
+    closeAside(): void;
+    /**
+     * Toggle the aside
+     */
+    toggleAside(item: NiceNavigationItem): void;
+    /**
+     * Enable the animations
+     *
+     * @private
+     */
+    private _enableAnimations;
+    /**
+     * Disable the animations
+     *
+     * @private
+     */
+    private _disableAnimations;
+    /**
+     * Show the overlay
+     *
+     * @private
+     */
+    private _showOverlay;
+    /**
+     * Hide the overlay
+     *
+     * @private
+     */
+    private _hideOverlay;
+    /**
+     * Show the aside overlay
+     *
+     * @private
+     */
+    private _showAsideOverlay;
+    /**
+     * Hide the aside overlay
+     *
+     * @private
+     */
+    private _hideAsideOverlay;
+    /**
+     * On mouseenter
+     */
+    _onMouseenter(): void;
+    /**
+     * On mouseleave
+     */
+    _onMouseleave(): void;
+    /**
+     * Open/close the navigation
+     *
+     * @param open
+     * @private
+     */
+    private _toggleOpened;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceVerticalNavigationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceVerticalNavigationComponent, "nice-vertical-navigation", ["niceVerticalNavigation"], { "name": { "alias": "name"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "inner": { "alias": "inner"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "hovered": { "alias": "hovered"; "required": false; }; "hasHint": { "alias": "hasHint"; "required": false; }; "position": { "alias": "position"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "transparentOverlay": { "alias": "transparentOverlay"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "translationContext": { "alias": "translationContext"; "required": false; }; "navigation": { "alias": "navigation"; "required": false; }; }, { "appearanceChanged": "appearanceChanged"; "modeChanged": "modeChanged"; "openedChanged": "openedChanged"; "hoveredChanged": "hoveredChanged"; "positionChanged": "positionChanged"; }, never, ["[niceVerticalNavigationHeader]", "[niceVerticalNavigationContentHeader]", "[niceVerticalNavigationContentFooter]", "[niceVerticalNavigationFooter]"], false, never>;
+}
+
+declare class NiceVerticalNavigationAsideItemComponent implements OnChanges, OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _router;
+    private _niceNavigationService;
+    static ngAcceptInputType_autoCollapse: BooleanInput;
+    static ngAcceptInputType_skipChildren: BooleanInput;
+    private _niceVerticalNavigationComponent;
+    private _unsubscribeAll;
+    activeItemId: string;
+    autoCollapse: boolean;
+    item: NiceNavigationItem;
+    name: string;
+    showTooltips: boolean;
+    skipChildren: boolean;
+    tooltipPosition: TooltipPosition;
+    active: boolean;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _router: Router, _niceNavigationService: NiceNavigationService);
+    /**
+     * On changes
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Check if the given item has the given url
+     * in one of its children
+     */
+    private _hasActiveChild;
+    /**
+     * Decide and mark if the item is active
+     */
+    private _markIfActive;
+    /**
+     * Track by function for ngFor loops
+     */
+    trackByFn(index: number, item: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceVerticalNavigationAsideItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceVerticalNavigationAsideItemComponent, "nice-vertical-navigation-aside-item", never, { "activeItemId": { "alias": "activeItemId"; "required": false; }; "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "item": { "alias": "item"; "required": false; }; "name": { "alias": "name"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "skipChildren": { "alias": "skipChildren"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceVerticalNavigationBasicItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _niceNavigationService;
+    private _niceUtilsService;
+    private _route;
+    private _router;
+    private _niceVerticalNavigationComponent;
+    private _unsubscribeAll;
+    item: NiceNavigationItem;
+    name: string;
+    showTooltips: boolean;
+    tooltipPosition: TooltipPosition;
+    itemActive$: rxjs.Observable<boolean>;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService, _niceUtilsService: NiceUtilsService, _route: ActivatedRoute, _router: Router);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceVerticalNavigationBasicItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceVerticalNavigationBasicItemComponent, "nice-vertical-navigation-basic-item", never, { "item": { "alias": "item"; "required": false; }; "name": { "alias": "name"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceVerticalNavigationCollapsableItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _router;
+    private _niceNavigationService;
+    static ngAcceptInputType_autoCollapse: BooleanInput;
+    private _niceVerticalNavigationComponent;
+    private _unsubscribeAll;
+    autoCollapse: boolean;
+    item: NiceNavigationItem;
+    name: string;
+    showTooltips: boolean;
+    tooltipPosition: TooltipPosition;
+    isCollapsed: boolean;
+    isExpanded: boolean;
+    hasChildActivated$: BehaviorSubject<boolean>;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _router: Router, _niceNavigationService: NiceNavigationService);
+    /**
+     * Host binding for component classes
+     */
+    get classList(): any;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Check if the given item has the given url
+     * in one of its children
+     */
+    private _hasActiveChild;
+    /**
+     * Check if this is a children
+     * of the given item
+     */
+    private _isChildrenOf;
+    /**
+     * Collapse
+     */
+    collapse(): void;
+    /**
+     * Expand
+     */
+    expand(): void;
+    /**
+     * Toggle collapsable
+     */
+    toggleCollapsable(): void;
+    /**
+     * Track by function for ngFor loops
+     */
+    trackByFn(index: number, item: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceVerticalNavigationCollapsableItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceVerticalNavigationCollapsableItemComponent, "nice-vertical-navigation-collapsable-item", never, { "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "item": { "alias": "item"; "required": false; }; "name": { "alias": "name"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceVerticalNavigationDividerItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _niceNavigationService;
+    private _niceVerticalNavigationComponent;
+    private _unsubscribeAll;
+    item: NiceNavigationItem;
+    name: string;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceVerticalNavigationDividerItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceVerticalNavigationDividerItemComponent, "nice-vertical-navigation-divider-item", never, { "item": { "alias": "item"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceVerticalNavigationGroupItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _niceNavigationService;
+    static ngAcceptInputType_autoCollapse: BooleanInput;
+    private _niceVerticalNavigationComponent;
+    private _unsubscribeAll;
+    autoCollapse: boolean;
+    item: NiceNavigationItem;
+    name: string;
+    showTooltips: boolean;
+    tooltipPosition: TooltipPosition;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Track by function for ngFor loops
+     */
+    trackByFn(index: number, item: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceVerticalNavigationGroupItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceVerticalNavigationGroupItemComponent, "nice-vertical-navigation-group-item", never, { "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "item": { "alias": "item"; "required": false; }; "name": { "alias": "name"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceVerticalNavigationSpacerItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _niceNavigationService;
+    private _niceVerticalNavigationComponent;
+    private _unsubscribeAll;
+    item: NiceNavigationItem;
+    name: string;
+    /**
+     * Constructor
+     */
+    constructor(_changeDetectorRef: ChangeDetectorRef, _niceNavigationService: NiceNavigationService);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceVerticalNavigationSpacerItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceVerticalNavigationSpacerItemComponent, "nice-vertical-navigation-spacer-item", never, { "item": { "alias": "item"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceShouldHidePipe implements PipeTransform {
+    private injector;
+    constructor(injector: Injector);
+    transform(value: NiceNavigationItem): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceShouldHidePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NiceShouldHidePipe, "niceShouldHide", false>;
+}
+
+declare class NiceShouldShowHintPipe implements PipeTransform {
+    private injector;
+    constructor(injector: Injector);
+    transform(value: NiceNavigationItem | NiceNavigationItem[]): Observable<boolean>;
+    private transformHint;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceShouldShowHintPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NiceShouldShowHintPipe, "niceShouldShowHint", false>;
+}
+
+declare class NiceTranslateWithContextPipe implements PipeTransform {
+    private translate;
+    private context;
+    constructor(translate: TranslateService, context: NiceTranslationContextService);
+    transform(value: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceTranslateWithContextPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NiceTranslateWithContextPipe, "niceTranslateWithContext", false>;
+}
+
+declare class NiceShowHintDirective<T extends _HintComponentBase> implements AfterViewInit, OnDestroy {
+    private _overlay;
+    private _elementRef;
+    private _viewContainerRef;
+    private _ngZone;
+    private _platform;
+    private _focusMonitor;
+    private _hintService;
+    shouldShow: boolean;
+    item: NiceNavigationItem;
+    private _pointerExitEventsInitialized;
+    private _portal;
+    private _hintInstance;
+    private _overlayRef;
+    private readonly _passiveListeners;
+    private readonly unsubscribeAll$;
+    constructor(_overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _ngZone: NgZone, _platform: Platform, _focusMonitor: FocusMonitor, _hintService: NiceNavigationHintService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    show(): void;
+    hide(): void;
+    private _createOverlay;
+    private _detach;
+    private _isHintVisible;
+    private _setupPointerEnterEventsIfNeeded;
+    private _setupPointerExitEventsIfNeeded;
+    private _platformSupportsMouseEvents;
+    private _addListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceShowHintDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceShowHintDirective<any>, "[niceShowHint]", never, { "shouldShow": { "alias": "shouldShow"; "required": false; }; "item": { "alias": "item"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceNavigationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceNavigationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceNavigationModule, [typeof NiceNavigationComponent, typeof NiceHorizontalNavigationBasicItemComponent, typeof NiceHorizontalNavigationBranchItemComponent, typeof NiceHorizontalNavigationDividerItemComponent, typeof NiceHorizontalNavigationSpacerItemComponent, typeof NiceHorizontalNavigationComponent, typeof NiceVerticalNavigationAsideItemComponent, typeof NiceVerticalNavigationBasicItemComponent, typeof NiceVerticalNavigationCollapsableItemComponent, typeof NiceVerticalNavigationDividerItemComponent, typeof NiceVerticalNavigationGroupItemComponent, typeof NiceVerticalNavigationSpacerItemComponent, typeof NiceVerticalNavigationComponent, typeof NiceShouldHidePipe, typeof NiceShouldShowHintPipe, typeof NiceTranslateWithContextPipe, typeof NiceShowHintDirective], [typeof i2.CommonModule, typeof i19.RouterModule, typeof i3.MatButtonModule, typeof i21.MatDividerModule, typeof i4.MatIconModule, typeof i6.MatMenuModule, typeof i24.MatTooltipModule, typeof NiceScrollbarModule, typeof i10.TranslateModule], [typeof NiceHorizontalNavigationComponent, typeof NiceVerticalNavigationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceNavigationModule>;
+}
+
+declare class NiceSearchBarComponent implements ControlValueAccessor {
+    collapsed: boolean;
+    collapse: EventEmitter<boolean>;
+    searchValue: string;
+    opened: boolean;
+    private propagateChanges;
+    get classList(): any;
+    toggleCollapsed(): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: string): void;
+    onSearchChange(value: string): void;
+    open(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSearchBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceSearchBarComponent, "nice-search-bar", never, { "collapsed": { "alias": "collapsed"; "required": false; }; }, { "collapse": "collapse"; }, never, never, false, never>;
+}
+
+declare class NiceSearchBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSearchBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceSearchBarModule, [typeof NiceSearchBarComponent], [typeof i2.CommonModule, typeof i19.RouterModule, typeof i3.MatButtonModule, typeof i4.MatIconModule, typeof i3$1.FormsModule], [typeof NiceSearchBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceSearchBarModule>;
+}
+
+interface NiceAlertConfig {
+    type: "success" | "warning" | "info";
+    title?: string;
+    message?: string;
+    buttons: string[];
+}
+declare class NiceSweetAlertComponent implements OnInit {
+    alertConfig: NiceAlertConfig;
+    private dialogRef;
+    lottieConfig: {
+        path: string;
+        autoplay: boolean;
+        loop: boolean;
+    };
+    constructor(alertConfig: NiceAlertConfig, dialogRef: MatDialogRef<NiceSweetAlertComponent>);
+    ngOnInit(): void;
+    handleAnimation(animation: any): void;
+    confirm(): void;
+    close(): void;
+    getAnimationPath(): string;
+    getConfirmButtonClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSweetAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceSweetAlertComponent, "nice-alert", never, {}, {}, never, never, false, never>;
+}
+
+interface NiceSweetAlertOptions {
+    customModal?: Type<any>;
+}
+interface NiceSweetAlertParams {
+    translationPath?: string;
+    titleKey: string;
+    messageKey?: string;
+    buttonsKey: string[];
+    params?: object;
+}
+declare class NiceSweetAlertService {
+    private options;
+    private matDialog;
+    private translateService;
+    private readonly modal;
+    constructor(options: NiceSweetAlertOptions, matDialog: MatDialog, translateService: TranslateService);
+    success(params: NiceSweetAlertParams): Observable<boolean>;
+    success(titleKey: string, messageKey: string, buttonsKey: string[], params?: object): Observable<boolean>;
+    warning(params: NiceSweetAlertParams): Observable<boolean>;
+    warning(titleKey: string, messageKey: string, buttonsKey: string[], params?: object): Observable<boolean>;
+    info(params: NiceSweetAlertParams): Observable<boolean>;
+    info(titleKey: string, messageKey: string, buttonsKey: string[], params?: object): Observable<boolean>;
+    private getTranslations;
+    private transformArgs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSweetAlertService, [{ optional: true; }, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceSweetAlertService>;
+}
+
+declare class NiceSweetAlertDirective {
+    private service;
+    sweetAlertType: "success" | "warning" | "info";
+    sweetAlertOptions: NiceSweetAlertParams;
+    sweetAlertAfterClosed: EventEmitter<boolean>;
+    constructor(service: NiceSweetAlertService);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSweetAlertDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceSweetAlertDirective, "[niceSweetAlert]", never, { "sweetAlertType": { "alias": "sweetAlertType"; "required": false; }; "sweetAlertOptions": { "alias": "sweetAlertOptions"; "required": false; }; }, { "sweetAlertAfterClosed": "sweetAlertAfterClosed"; }, never, never, false, never>;
+}
+
+declare class NiceSweetAlertModule {
+    static forRoot(options?: NiceSweetAlertOptions): ModuleWithProviders<NiceSweetAlertModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSweetAlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceSweetAlertModule, [typeof NiceSweetAlertComponent, typeof NiceSweetAlertDirective], [typeof i2.CommonModule, typeof i10.TranslateModule, typeof i5$3.MatDialogModule, typeof i3.MatButtonModule, typeof NiceLottieModule], [typeof NiceSweetAlertDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceSweetAlertModule>;
+}
+
+interface NiceToastData {
+    title?: string;
+    message?: string;
+    appearance?: NiceAlertAppearance;
+    type: "info" | "success" | "warning" | "error";
+}
+declare class NiceToastComponent {
+    data: NiceToastData;
+    private snackbarRef;
+    constructor(data: NiceToastData, snackbarRef: MatSnackBarRef<NiceToastComponent>);
+    dismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceToastComponent, "nice-toast", never, {}, {}, never, never, false, never>;
+}
+
+interface NiceToastOptions extends MatSnackBarConfig {
+    appearance?: NiceAlertAppearance;
+    successDuration?: number;
+    warningDuration?: number;
+    errorDuration?: number;
+    infoDuration?: number;
+}
+declare class NiceToastService {
+    private options;
+    private snackbar;
+    private translateService;
+    constructor(options: NiceToastOptions, snackbar: MatSnackBar, translateService: TranslateService);
+    success(messageKey: string, titleKey?: string, params?: object): void;
+    error(messageKey: string, titleKey?: string, params?: object): void;
+    warning(messageKey: string, titleKey?: string, params?: object): void;
+    info(messageKey: string, titleKey?: string, params?: object): void;
+    private showToast;
+    private getTranslations;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceToastService>;
+}
+
+declare class NiceToastModule {
+    static forRoot(options?: NiceToastOptions): ModuleWithProviders<NiceToastModule>;
+    static forFeature(options: NiceToastOptions): ModuleWithProviders<NiceToastModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceToastModule, [typeof NiceToastComponent], [typeof i2.CommonModule, typeof i4$2.MatSnackBarModule, typeof i10.TranslateModule, typeof NiceAlertModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceToastModule>;
+}
+
+interface ShowToastOperatorOptionsWithoutTitle$1 {
+    messageKey: string;
+    titleKey?: string;
+    params?: object;
+    useObserver?: keyof TapObserver<any>;
+}
+interface ShowToastOperatorOptionsWithoutMessage$1 {
+    titleKey: string;
+    messageKey?: string;
+    params?: object;
+    useObserver?: keyof TapObserver<any>;
+}
+type ShowToastOperatorOptions = ShowToastOperatorOptionsWithoutTitle$1 | ShowToastOperatorOptionsWithoutMessage$1;
+declare function showSuccessToast<T>(loadingToastService: NiceToastService, options: ShowToastOperatorOptions): MonoTypeOperatorFunction<T>;
+declare function showErrorToast<T>(loadingToastService: NiceToastService, options: ShowToastOperatorOptions): MonoTypeOperatorFunction<T>;
+declare function showInfoToast<T>(loadingToastService: NiceToastService, options: ShowToastOperatorOptions): MonoTypeOperatorFunction<T>;
+declare function showWarningToast<T>(loadingToastService: NiceToastService, options: ShowToastOperatorOptions): MonoTypeOperatorFunction<T>;
+
+interface ShowToastOperatorCommonKeysOptionsWithoutTitle {
+    messageKey: string;
+    titleKey?: string;
+    params?: object;
+}
+interface ShowToastOperatorCommonKeysOptionsWithoutMessage {
+    titleKey: string;
+    messageKey?: string;
+    params?: object;
+}
+interface ShowToastOperatorOptionsWithoutMessage {
+    title: {
+        success: string;
+        error: string;
+    };
+    message?: {
+        success: string;
+        error: string;
+    };
+    params?: object;
+}
+interface ShowToastOperatorOptionsWithoutTitle {
+    message: {
+        success: string;
+        error: string;
+    };
+    title?: {
+        success: string;
+        error: string;
+    };
+    params?: object;
+}
+type ShowSuccessOrErrorToastOperatorOptions = ShowToastOperatorCommonKeysOptionsWithoutTitle | ShowToastOperatorCommonKeysOptionsWithoutMessage | ShowToastOperatorOptionsWithoutMessage | ShowToastOperatorOptionsWithoutTitle;
+declare function showSuccessOrErrorToast<T>(loadingToastService: NiceToastService, options: ShowSuccessOrErrorToastOperatorOptions): MonoTypeOperatorFunction<T>;
+
+declare class ToggleButtonComponent {
+    content: TemplateRef<any>;
+    value: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleButtonComponent, "nice-toggle-button", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+type ToggleButtonGroupDataType = any | any[];
+declare class ToggleButtonGroupComponent {
+    private _multiple;
+    toggleButtons: QueryList<ToggleButtonComponent>;
+    selected: ToggleButtonGroupDataType;
+    color: ThemePalette;
+    selectedChange: EventEmitter<any>;
+    defaultColor: ThemePalette;
+    set multiple(multiple: boolean);
+    private onTouched;
+    private onChange;
+    onBlur(): void;
+    writeValue(value: ToggleButtonGroupDataType): void;
+    registerOnChange(fn: (color: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    onSelect(value: any): void;
+    conditionalColorObj(value: any): any;
+    private isLeftValueSelected;
+    private isRightValueSelected;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleButtonGroupComponent, "nice-toggle-button-group", never, { "selected": { "alias": "selected"; "required": false; }; "color": { "alias": "color"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; }, { "selectedChange": "selectedChange"; }, ["toggleButtons"], never, false, never>;
+}
+
+declare class NiceToggleButtonGroupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceToggleButtonGroupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceToggleButtonGroupModule, [typeof ToggleButtonComponent, typeof ToggleButtonGroupComponent], [typeof i2.CommonModule, typeof i7.MatRippleModule], [typeof ToggleButtonComponent, typeof ToggleButtonGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceToggleButtonGroupModule>;
+}
+
+declare class NiceTranslationFormService {
+    private _languages$;
+    private _requiredLanguages$;
+    get languages$(): Observable<string[]>;
+    get languages(): string[];
+    get requiredLanguages$(): Observable<string[]>;
+    get requiredLanguages(): string[];
+    get hasLanguages$(): Observable<boolean>;
+    get hasLanguages(): boolean;
+    setLanguages(languages?: string[]): void;
+    setRequiredLanguages(languages?: string[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceTranslationFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceTranslationFormService>;
+}
+
+declare class TranslationContextDirective implements OnInit, OnDestroy {
+    private translationFormService;
+    activeLanguageChange: EventEmitter<string>;
+    activeLanguage$: BehaviorSubject<string>;
+    private _unsubscribeAll$;
+    constructor(translationFormService: NiceTranslationFormService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    updateLanguage(language: string): void;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationContextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TranslationContextDirective, "[niceTranslationContext]", never, {}, { "activeLanguageChange": "activeLanguageChange"; }, never, never, false, never>;
+}
+
+declare abstract class TranslationFormComponent implements OnInit, OnDestroy, MatFormFieldControl<string>, ControlValueAccessor {
+    private container;
+    private context;
+    private service;
+    private changeDetectorRef;
+    get classList(): any;
+    get shouldLabelFloat(): boolean;
+    set required(req: boolean);
+    get required(): boolean;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    set placeholder(placeholder: string);
+    get placeholder(): string;
+    set value(value: any);
+    get value(): any;
+    get empty(): boolean;
+    get errorState(): boolean;
+    constructor(container: ControlContainer, context: TranslationContextDirective, service: NiceTranslationFormService, changeDetectorRef: ChangeDetectorRef);
+    floating: boolean;
+    maxLength: number;
+    id: string;
+    describedBy: string;
+    formGroup: FormGroup;
+    currentControl?: FormControl;
+    stateChanges: Subject<void>;
+    ngControl: AbstractControlDirective | NgControl;
+    focused: boolean;
+    controlType: string;
+    private _unsubscribeAll$;
+    private _required;
+    private _disabled;
+    private _placeholder;
+    private _value;
+    readonly autofilled: boolean;
+    readonly userAriaDescribedBy: string;
+    propagate: (value: string) => void;
+    onContainerClick(event: MouseEvent): void;
+    setDescribedByIds(ids: string[]): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: any): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    setLanguage(language: string): void;
+    private setupFormControls;
+    private handleDisabledState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TranslationFormComponent, "ng-component", never, { "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "floating": { "alias": "floating"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TranslationFormTextfieldComponent extends TranslationFormComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationFormTextfieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TranslationFormTextfieldComponent, "nice-translation-form-textfield", never, {}, {}, never, never, false, never>;
+}
+
+declare class TranslationFormTextareaComponent extends TranslationFormComponent {
+    resizable: boolean;
+    rows: number;
+    cols: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationFormTextareaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TranslationFormTextareaComponent, "nice-translation-form-textarea", never, { "resizable": { "alias": "resizable"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TranslationToggleComponent {
+    private context;
+    private translationFormService;
+    languages$: rxjs.Observable<string[]>;
+    activeLanguage$: rxjs.BehaviorSubject<string>;
+    constructor(context: TranslationContextDirective, translationFormService: NiceTranslationFormService);
+    onChange($event: MatButtonToggleChange): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TranslationToggleComponent, "nice-translation-toggle", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceTranslationFormModule {
+    static forRoot(): ModuleWithProviders<NiceTranslationFormModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceTranslationFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceTranslationFormModule, [typeof TranslationFormTextfieldComponent, typeof TranslationFormTextareaComponent, typeof TranslationToggleComponent, typeof TranslationContextDirective], [typeof i5$4.MatButtonToggleModule, typeof i6$1.MatInputModule, typeof i3$1.ReactiveFormsModule, typeof i2.NgForOf, typeof i2.NgIf, typeof i2.AsyncPipe, typeof i2.UpperCasePipe], [typeof TranslationFormTextfieldComponent, typeof TranslationFormTextareaComponent, typeof TranslationToggleComponent, typeof TranslationContextDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceTranslationFormModule>;
+}
+
+declare const TranslationFormGroup: () => PropertyDecorator;
+
+declare function RequireForLanguages(): PropertyDecorator;
+declare class RequireForLanguagesValidator extends AsyncValidator {
+    private service;
+    name: string;
+    constructor(service: NiceTranslationFormService);
+    validate(formGroup: FormGroup): Observable<ValidationErrors | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequireForLanguagesValidator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RequireForLanguagesValidator>;
+}
+
+declare class TranslationForm {
+    constructor(values?: {
+        [language: string]: string;
+    });
+}
+
+declare class NiceTypeaheadNewValue {
+    $new: string;
+    constructor($new: string);
+}
+declare class NiceTypeaheadComponent implements OnInit, OnDestroy, ControlValueAccessor, MatFormFieldControl<string> {
+    ngControl: NgControl;
+    private fm;
+    private zone;
+    elRef: ElementRef<HTMLElement>;
+    set items(items: any[] | null | undefined);
+    set labelFormatFn(labelFormatFn: (item: any) => string);
+    set required(req: boolean);
+    get required(): boolean;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    set placeholder(placeholder: string);
+    get placeholder(): string;
+    set emptyPlaceholder(emptyPlaceholder: string);
+    get emptyPlaceholder(): string;
+    set value(value: any);
+    get value(): any;
+    get empty(): boolean;
+    get errorState(): boolean;
+    get shouldLabelFloat(): boolean;
+    constructor(ngControl: NgControl, fm: FocusMonitor, zone: NgZone, elRef: ElementRef<HTMLElement>);
+    private _items;
+    private _labelFormatFn;
+    private _page;
+    allowNotFoundItems: boolean;
+    panelClass: string | string[];
+    bindValue: string;
+    bindLabel: string;
+    /** @deprecated: Use NiceRemoteTypeahead instead */
+    typeahead: Subject<string>;
+    /** @deprecated: Use NiceRemoteTypeahead instead */
+    page$: Subject<number>;
+    loading: boolean;
+    loadingPage: boolean;
+    searchFn: (search: string, option: any) => boolean;
+    change: EventEmitter<any>;
+    input: ElementRef<HTMLInputElement>;
+    options: MatOption[];
+    search$: Subject<string>;
+    searchControl: FormControl<any>;
+    values: unknown[];
+    valueChangesSub$: Subscription;
+    searchSub$: Subscription;
+    open: boolean;
+    panelWidth: number;
+    activeOption: MatOption;
+    private updatingItem;
+    private waitForItems;
+    private ignoreNextFocus;
+    private observer;
+    /** MatFormField */
+    private _required;
+    private _disabled;
+    private _placeholder;
+    private _value;
+    private _emptyPlaceholder;
+    stateChanges: Subject<void>;
+    controlType: string;
+    focused: boolean;
+    id: string;
+    describedBy: string;
+    optionTemplate: TemplateRef<HTMLElement>;
+    propagate: (value: string) => void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onContainerClick(event: MouseEvent): void;
+    setDescribedByIds(ids: string[]): void;
+    registerOnChange(propagate: (value: string) => void): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: string): void;
+    onOptionActivated(event: MatAutocompleteActivatedEvent): void;
+    onOptionSelected(event: MatAutocompleteSelectedEvent): void;
+    updateState(open: boolean): void;
+    onRemove(event?: Event): void;
+    formatLabel(item: any): string;
+    private _filter;
+    private defaultSearch;
+    private updateSearchInput;
+    private filterString;
+    private updateLabel;
+    onEndScroll(): void;
+    private getObjectItem;
+    private getValueItem;
+    private setLoading;
+    private setLoadingPage;
+    private checkIfValueStillExist;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceTypeaheadComponent, [{ optional: true; self: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceTypeaheadComponent, "nice-typeahead", never, { "items": { "alias": "items"; "required": false; }; "labelFormatFn": { "alias": "labelFormatFn"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "emptyPlaceholder": { "alias": "emptyPlaceholder"; "required": false; }; "allowNotFoundItems": { "alias": "allowNotFoundItems"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "bindValue": { "alias": "bindValue"; "required": false; }; "bindLabel": { "alias": "bindLabel"; "required": false; }; "typeahead": { "alias": "typeahead"; "required": false; }; "page$": { "alias": "page$"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "loadingPage": { "alias": "loadingPage"; "required": false; }; "searchFn": { "alias": "searchFn"; "required": false; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; }; }, { "change": "change"; }, never, never, false, never>;
+}
+
+declare class NiceTypeaheadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceTypeaheadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceTypeaheadModule, [typeof NiceTypeaheadComponent], [typeof i2.CommonModule, typeof i3$1.ReactiveFormsModule, typeof OptionScrollModule, typeof i6$2.MatAutocompleteModule, typeof i3$1.FormsModule, typeof i6$1.MatInputModule, typeof i10$1.MatProgressSpinnerModule, typeof i9.MatProgressBarModule, typeof i4.MatIconModule, typeof i3.MatButtonModule, typeof i10.TranslateModule], [typeof NiceTypeaheadComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceTypeaheadModule>;
+}
+
+declare class NiceAutofocusDirective implements OnInit {
+    private elem;
+    constructor(elem: ElementRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAutofocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceAutofocusDirective, "[niceAutofocus]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceAutofocusDirectiveModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAutofocusDirectiveModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceAutofocusDirectiveModule, [typeof NiceAutofocusDirective], never, [typeof NiceAutofocusDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceAutofocusDirectiveModule>;
+}
+
+declare class NiceAutogrowDirective implements OnChanges, OnInit, OnDestroy {
+    private _elementRef;
+    private _changeDetectorRef;
+    private _ngZone;
+    private _height;
+    private _unsubscribeAll;
+    padding: number;
+    private _rows;
+    /**
+     * Constructor
+     */
+    constructor(_elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef, _ngZone: NgZone);
+    /**
+     * Host binding for component inline styles
+     */
+    get styleList(): any;
+    /**
+     * On changes
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Resize on 'input' and 'ngModelChange' events
+     */
+    private _resize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAutogrowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceAutogrowDirective, "textarea[niceAutogrow]", ["niceAutogrow"], { "padding": { "alias": "niceAutogrowVerticalPadding"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceAutogrowModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAutogrowModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceAutogrowModule, [typeof NiceAutogrowDirective], never, [typeof NiceAutogrowDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceAutogrowModule>;
+}
+
+declare class NiceChipAsyncTypeaheadDirective implements OnInit, OnDestroy {
+    private typeahead;
+    private elementRef;
+    niceChipAsyncTypeaheadTokenEnd: EventEmitter<any>;
+    private unsubscribeAll$;
+    constructor(typeahead: NiceAsyncTypeaheadComponent, elementRef: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceChipAsyncTypeaheadDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceChipAsyncTypeaheadDirective, "[niceChipAsyncTypeahead]", ["niceChipAsyncTypeahead"], {}, { "niceChipAsyncTypeaheadTokenEnd": "niceChipAsyncTypeaheadTokenEnd"; }, never, never, false, never>;
+}
+
+declare class NiceChipAsyncTypeaheadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceChipAsyncTypeaheadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceChipAsyncTypeaheadModule, [typeof NiceChipAsyncTypeaheadDirective], never, [typeof NiceChipAsyncTypeaheadDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceChipAsyncTypeaheadModule>;
+}
+
+declare class ChipListItemLabelDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChipListItemLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ChipListItemLabelDirective, "[niceChipListItemLabel]", never, {}, {}, never, never, false, never>;
+}
+
+type NiceChipListActionIcon = {
+    matIcon: string;
+    svgIcon?: string;
+} | {
+    matIcon?: string;
+    svgIcon: string;
+};
+interface NiceChipListOptions {
+    closeButtonIcon: NiceChipListActionIcon;
+}
+declare class NiceChipListItemsComponent {
+    readonly options: NiceChipListOptions;
+    itemLabel: TemplateRef<any>;
+    color: ThemePalette;
+    removeChip: EventEmitter<number>;
+    items$: Observable<any[]>;
+    defaultColor: ThemePalette;
+    constructor(options: NiceChipListOptions);
+    remove(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceChipListItemsComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceChipListItemsComponent, "nice-chip-list-items", never, { "color": { "alias": "color"; "required": false; }; "items$": { "alias": "items$"; "required": false; }; }, { "removeChip": "removeChip"; }, ["itemLabel"], never, false, never>;
+}
+
+declare class ArrayUtils {
+    static joinIfDefined(array: any[], join?: string): string;
+    static uniqueObjects<Item>(array: Item[], keySelector: (item: Item) => unknown): Item[];
+    static unique<T>(array: T[], comparator?: (value1: T, value2: T) => boolean): T[];
+    static equals(arr1: any[], arr2: any[], options?: {
+        shallow: boolean;
+        ordered: boolean;
+    }): boolean;
+    private static unorderedShallowEquals;
+    static sortByKey(array: any[], key: string): any[];
+    static sortByKeyFn(key: string): (a: any, b: any) => 0 | 1 | -1;
+    static groupBy<Item, Key, Value>(array: Item[], keySelector: (item: Item) => Key, valueSelector: (item: Item) => Value[] | Value): Map<Key, Value[]>;
+}
+declare global {
+    interface Array<T> {
+        distinct<T>(): Array<T>;
+        groupBy<T>(value: T): T[];
+        includesWithCallback(callbackfn: (value: T, index: number, array: T[]) => boolean): boolean;
+        pushOrRemove<T>(value: T): void;
+        replace<T>(item: T, ...newItems: T[]): Array<T>;
+        skipNullValues(): T[];
+        difference<T>(...not: T[]): T[];
+    }
+}
+
+declare class CaseUtils {
+    static toCamelFromKebab(data: string): string;
+    static toSnakeCaseFromPascalCase(str: string): string;
+    static toSnakeCaseFromCamelCase(str: string): string;
+    static toCamelCaseFromSnakeCase(stringToConvert: string): string;
+    static toKebabCasePascalCase(str: string): string;
+    static toPascalCaseFromSnakeCase(str: string): string;
+    static capitalizeFirstLetter(str: string): string;
+}
+
+declare class ColorsUtils {
+    /**
+     * https://codepen.io/cferdinandi/pen/Yomroj
+     *
+     * (c) 2019 Chris Ferdinandi, MIT License, https://gomakethings.com
+     * Derived from work by Brian Suda, https://24ways.org/2010/calculating-color-contrast/
+     */
+    static contrastFromHex(hex: string): string;
+}
+
+declare class DateUtils {
+    static currentYear(): number;
+    static extractTimeAsString(date: Date): string;
+    static setTimeFromString(date: Date, time: string): Date;
+}
+declare global {
+    export interface Date {
+        getSeason(): string;
+        getYear(): number;
+    }
+}
+
+declare class FileUtils {
+    static getFileFromUrl(url?: string, name?: string): Promise<File | undefined>;
+    static selectFile(accept: string, multiple?: boolean): Promise<File | File[]>;
+    static downloadFile(fileName: string, content: Blob, downloadLink?: HTMLAnchorElement): void;
+    static openFile(file: Blob, options?: {
+        openInNewTab: boolean;
+    }): void;
+    static downloadUrl(url: string): void;
+    static openPrintableWindow(content: string): void;
+    static filenameToExtension(filename: string): string;
+    static getDataUrl(file: File): Promise<string>;
+    static getFileFromDataUrl(data: string, name: string): Promise<File>;
+}
+
+declare class FontAwesomeUtils {
+    static fileExtensionToIcon(extension: string): string;
+}
+
+declare class FormDataUtils {
+    static appendFormDataWithDto(form: FormData, value: object): void;
+    static appendFormDataWithValue(form: FormData, value: any, name: any): void;
+}
+
+declare enum HttpStatusCodes {
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    PROCESSING = 102,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    AMBIGUOUS = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    UNPROCESSABLE_ENTITY = 422,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}
+
+declare enum KeyboardCodes {
+    ArrowUp = "ArrowUp",
+    ArrowDown = "ArrowDown",
+    Enter = "Enter",
+    Shift = "Shift",
+    Comma = "Comma"
+}
+
+declare class LexoRankUtils {
+    static compareStringFn(previousRank?: string, nextRank?: string): number;
+    static compareFn(previousRank: LexoRank, nextRank: LexoRank): number;
+    static getNewRank(afterRank?: string, beforeRank?: string): string;
+}
+
+interface ModalData {
+    mode: ModalMode;
+}
+declare enum ModalMode {
+    Create = 0,
+    Edit = 1
+}
+
+declare class NumberUtils {
+}
+declare global {
+    interface Number {
+        inRange(a: number, b: number): boolean;
+    }
+}
+
+declare class ObjectUtils {
+    static transformStringProperties(obj: any): object;
+    static stringPropertiesToNumber(obj: any, property: string): object;
+    static assignDefined(target: any, source: any): object;
+    static areObjectsEqual(obj1: any, obj2: any): boolean;
+    static deepCopy(obj: any): any;
+    static immutableDeepAssign<Source, Target>(key: string, deepObj: Source, obj: Target): Target;
+    static deepAssign<Source, Target>(key: string, deepObj: Source, obj: Target): void;
+    private static internalDeepAssign;
+}
+
+declare class PromiseUtils {
+}
+declare global {
+    export interface PromiseConstructor {
+        delay(ms: number): Promise<void>;
+    }
+}
+
+declare class QueryParamsUtils {
+    static fromObject(obj: any): string;
+}
+
+declare class RegexUtils {
+    static email: RegExp;
+    static password: {
+        lowerUpperDigit8: RegExp;
+    };
+    static canadianPostalCode: RegExp;
+}
+
+declare const isNullOrUndefined: (value: unknown) => boolean;
+declare const isNotNullOrUndefined: (value: unknown) => boolean;
+declare class TypeUtils {
+    static isNullOrUndefined(value: unknown): boolean;
+    static isNotNullOrUndefined(value: unknown): boolean;
+}
+
+declare class UrlUtils {
+    static emailUrl(email: string): string;
+    static directionUrl(address: string, postalCode: string): string;
+    static phoneCallUrl(phone: string, ext?: string): string;
+    static getCurrentUrlFragments(): string[];
+}
+
+declare class NiceChipListDirective implements ControlValueAccessor, OnInit, OnDestroy, OnChanges {
+    private asyncTypeahead;
+    private ngControl;
+    private elementRef;
+    withItemList: NiceChipListItemsComponent;
+    reloadOnSelected: boolean;
+    separatorKeyboardCodes: KeyboardCodes[];
+    private unsubscribeAll$;
+    private values$;
+    private _values;
+    private propagateChanges;
+    get values(): any[];
+    constructor(asyncTypeahead: NiceAsyncTypeaheadComponent, ngControl: NgControl, elementRef: ElementRef<HTMLInputElement>);
+    onKeyDown(event: KeyboardEvent): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    writeValue(obj: any[]): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    private setupAsyncTypeahead;
+    private addValue;
+    private updateTypeaheadSearchOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceChipListDirective, [{ optional: true; }, { optional: true; self: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceChipListDirective, "input[niceChipList], nice-async-typeahead[niceChipList]", never, { "withItemList": { "alias": "withItemList"; "required": false; }; "reloadOnSelected": { "alias": "reloadOnSelected"; "required": false; }; "separatorKeyboardCodes": { "alias": "separatorKeyboardCodes"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceChipListDirectiveModule {
+    static forRoot(options?: NiceChipListOptions): ModuleWithProviders<NiceChipListDirectiveModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceChipListDirectiveModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceChipListDirectiveModule, [typeof NiceChipListDirective, typeof NiceChipListItemsComponent, typeof ChipListItemLabelDirective], [typeof i2.CommonModule, typeof i4.MatIconModule], [typeof NiceChipListDirective, typeof NiceChipListItemsComponent, typeof ChipListItemLabelDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceChipListDirectiveModule>;
+}
+
+declare class NiceDraggableListDirective<T> implements OnInit, OnDestroy, OnChanges {
+    private formArrayName;
+    private cdkDropList;
+    items: T[];
+    rankProperty: string;
+    itemsUpdated: EventEmitter<T[]>;
+    itemRankUpdated: EventEmitter<T>;
+    sortedItems: T[];
+    formArray: FormArray;
+    private unsubscribeAll$;
+    constructor(formArrayName: FormArrayName, cdkDropList: CdkDropList);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    drop(event: CdkDragDrop<any, any>): void;
+    private sortItems;
+    private getNextRank;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceDraggableListDirective<any>, [{ optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceDraggableListDirective<any>, "[cdkDropList][niceDraggableList]", never, { "items": { "alias": "items"; "required": false; }; "rankProperty": { "alias": "rankProperty"; "required": false; }; }, { "itemsUpdated": "itemsUpdated"; "itemRankUpdated": "itemRankUpdated"; }, never, never, false, never>;
+}
+
+declare class NiceDraggableListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceDraggableListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceDraggableListModule, [typeof NiceDraggableListDirective], [typeof i2$1.DragDropModule], [typeof NiceDraggableListDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceDraggableListModule>;
+}
+
+declare class NiceImageErrorPlaceholderDirective {
+    private elementRef;
+    private viewContainerRef;
+    fallback?: TemplateRef<any>;
+    constructor(elementRef: ElementRef, viewContainerRef: ViewContainerRef);
+    onError(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceImageErrorPlaceholderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceImageErrorPlaceholderDirective, "img[niceImageErrorPlaceholder]", never, { "fallback": { "alias": "fallback"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceImageErrorPlaceholderDirectiveModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceImageErrorPlaceholderDirectiveModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceImageErrorPlaceholderDirectiveModule, [typeof NiceImageErrorPlaceholderDirective], never, [typeof NiceImageErrorPlaceholderDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceImageErrorPlaceholderDirectiveModule>;
+}
+
+declare class NiceMaterialStyleDirective implements OnInit {
+    private element;
+    constructor(element: ElementRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceMaterialStyleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceMaterialStyleDirective, "[keep-material-style]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceRoundedStyleDirective implements OnInit {
+    private element;
+    constructor(element: ElementRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceRoundedStyleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceRoundedStyleDirective, "[nice-rounded-style]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceMaterialModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceMaterialModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceMaterialModule, [typeof NiceMaterialStyleDirective, typeof NiceRoundedStyleDirective], never, [typeof NiceMaterialStyleDirective, typeof NiceRoundedStyleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceMaterialModule>;
+}
+
+declare class NiceModalOpenerDirective<T, Return, Data> {
+    protected dialog: MatDialog;
+    private modal;
+    private options;
+    modalData: Data;
+    modalAfterClosed: EventEmitter<Return>;
+    constructor(dialog: MatDialog, modal: Type<T>, options: MatDialogConfig<Data>);
+    open(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceModalOpenerDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceModalOpenerDirective<any, any, any>, never, never, { "modalData": { "alias": "modalData"; "required": false; }; }, { "modalAfterClosed": "modalAfterClosed"; }, never, never, true, never>;
+}
+
+declare class NiceModalOnClickDirective<T, Return, Data = any> extends NiceModalOpenerDirective<T, Return, Data> {
+    constructor(dialog: MatDialog, modal: Type<T>, options: MatDialogConfig<Data>);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceModalOnClickDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceModalOnClickDirective<any, any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class NiceScrollResetDirective implements OnInit, OnDestroy {
+    private _elementRef;
+    private _router;
+    private _unsubscribeAll;
+    /**
+     * Constructor
+     */
+    constructor(_elementRef: ElementRef, _router: Router);
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceScrollResetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceScrollResetDirective, "[niceScrollReset]", ["niceScrollReset"], {}, {}, never, never, false, never>;
+}
+
+declare class NiceScrollResetModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceScrollResetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceScrollResetModule, [typeof NiceScrollResetDirective], never, [typeof NiceScrollResetDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceScrollResetModule>;
+}
+
+declare class NiceClickStopPropagationDirective {
+    stopClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceClickStopPropagationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceClickStopPropagationDirective, "[niceClickStopPropagation]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceStopPropagationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceStopPropagationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceStopPropagationModule, [typeof NiceClickStopPropagationDirective], never, [typeof NiceClickStopPropagationDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceStopPropagationModule>;
+}
+
+declare class NicePreventCloseWindowDirective {
+    handleClose($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NicePreventCloseWindowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NicePreventCloseWindowDirective, "[nicePreventCloseWindow]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceWindowDirectiveModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceWindowDirectiveModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceWindowDirectiveModule, [typeof NicePreventCloseWindowDirective], never, [typeof NicePreventCloseWindowDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceWindowDirectiveModule>;
+}
+
+declare class RerenderDirective {
+    private templateRef;
+    private viewContainerRef;
+    set rerender(_: any);
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RerenderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RerenderDirective, "[rerender]", never, { "rerender": { "alias": "rerender"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ResolveDirectiveContext<T> {
+    $implicit: T;
+    resolve: T;
+}
+declare class ResolveDirective<T> {
+    private templateRef;
+    private viewContainerRef;
+    private context;
+    private embeddedViewRef;
+    set resolve(value: T);
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    static ngTemplateContextGuard<T>(directive: ResolveDirective<T>, ctx: any): ctx is ResolveDirectiveContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResolveDirective<any>, "[resolve]", never, { "resolve": { "alias": "resolve"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NiceModule {
+    /**
+     * Constructor
+     */
+    constructor(parentModule?: NiceModule);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceModule, [{ optional: true; skipSelf: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceModule, never, [typeof NiceMediaWatcherModule, typeof NiceSplashScreenModule, typeof NiceUtilsModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceModule>;
+}
+
+export { ArrayUtils, BooleanPipe, CapitalizeFirstLetterPipe, CarouselComponent, CaseUtils, CeilPipe, ChipListItemLabelDirective, ColorsUtils, DateUtils, DefaultExportBottomSheetService, EntriesPipe, ExportBottomSheetComponent, ExportBottomSheetService, FileUtils, FindByKeyPipe, FirstLetterPipe, FloorPipe, FontAwesomeUtils, FormDataUtils, HttpStatusCodes, ImgCropperConfig, ImgCropperError, ImgResolution, JoinPipe, KeyboardCodes, LexoRankUtils, LinkPipe, LocalizedBooleanPipe, LocalizedCurrencyPipe, LocalizedDateOnlyPipe, LocalizedDatePipe, MinutesToTimePipe, ModalMode, NICE_ASYNC_TYPEAHEAD_PROVIDER, NavigationHideItemResolver, NavigationHintResolver, NiceAlertComponent, NiceAlertModule, NiceAlertService, NiceApiException, NiceAssetsCarouselActiveContentDirective, NiceAssetsCarouselComponent, NiceAssetsCarouselModule, NiceAsyncTypeaheadComponent, NiceAsyncTypeaheadModule, NiceAsyncTypeaheadProvider, NiceAutofocusDirective, NiceAutofocusDirectiveModule, NiceAutogrowDirective, NiceAutogrowModule, NiceBaseForm, NiceBaseFormComponent, NiceBaseFormModule, NiceCardComponent, NiceCardModule, NiceCarouselModule, NiceChipAsyncTypeaheadDirective, NiceChipAsyncTypeaheadModule, NiceChipListDirective, NiceChipListDirectiveModule, NiceChipListItemsComponent, NiceClickStopPropagationDirective, NiceCollapsableComponent, NiceCollapsableModule, NiceConfigModule, NiceConfigService, NiceControlStatusDirective, NiceCropperAreaComponent, NiceDateRangePickerComponent, NiceDateRangePickerModule, NiceDraggableListDirective, NiceDraggableListModule, NiceDrawerComponent, NiceDrawerModule, NiceDrawerService, NiceDropzoneDirective, NiceDropzoneModule, NiceExportBottomSheetModule, NiceFormErrorComponent, NiceFormErrorModule, NiceFormSubmitDirective, NiceHorizontalNavigationBasicItemComponent, NiceHorizontalNavigationBranchItemComponent, NiceHorizontalNavigationComponent, NiceHorizontalNavigationDividerItemComponent, NiceHorizontalNavigationSpacerItemComponent, NiceHorizontalStepperComponent, NiceHorizontalStepperModule, NiceHttpExceptionFactory, NiceImageCropperComponent, NiceImageCropperModule, NiceImageErrorPlaceholderDirective, NiceImageErrorPlaceholderDirectiveModule, NiceLayoutComponent, NiceLayoutModule, NiceLoadingDirective, NiceLoadingSpinnerComponent, NiceLoadingSpinnerModule, NiceLoadingToastComponent, NiceLoadingToastDirective, NiceLoadingToastModule, NiceLoadingToastService, NiceLottieComponent, NiceLottieModule, NiceMaterialModule, NiceMaterialStyleDirective, NiceMediaWatcherModule, NiceMediaWatcherService, NiceModalOnClickDirective, NiceModalOpenerDirective, NiceModule, NiceNavigationComponent, NiceNavigationModule, NiceNavigationService, NicePipesModule, NicePreventCloseWindowDirective, NiceRoundedStyleDirective, NiceScrollResetDirective, NiceScrollResetModule, NiceScrollbarDirective, NiceScrollbarModule, NiceSearchBarComponent, NiceSearchBarModule, NiceSplashScreenModule, NiceSplashScreenService, NiceStepComponent, NiceStopPropagationModule, NiceSweetAlertComponent, NiceSweetAlertDirective, NiceSweetAlertModule, NiceSweetAlertService, NiceToastComponent, NiceToastModule, NiceToastService, NiceToggleButtonGroupModule, NiceTransformResponseInterceptor, NiceTranslationFormModule, NiceTranslationFormService, NiceTypeaheadComponent, NiceTypeaheadModule, NiceTypeaheadNewValue, NiceUtilsModule, NiceUtilsService, NiceVerticalNavigationAsideItemComponent, NiceVerticalNavigationBasicItemComponent, NiceVerticalNavigationCollapsableItemComponent, NiceVerticalNavigationComponent, NiceVerticalNavigationDividerItemComponent, NiceVerticalNavigationGroupItemComponent, NiceVerticalNavigationSpacerItemComponent, NiceWindowDirectiveModule, NumberToOrdinalIndicatorPipe, NumberUtils, ObjectUtils, OptionsScrollDirective, PadPipe, PhonePipe, PictureModalComponent, PictureModalService, PostalCodePipe, PromiseUtils, QueryParamsUtils, RangePipe, RegexUtils, RequireForLanguages, RequireForLanguagesValidator, RerenderDirective, ResolveDirective, RoundPipe, SanitizeBypassPipe, SecondsToTimePipe, TRANSFORM_TYPE, ToggleButtonComponent, ToggleButtonGroupComponent, TrackByPropPipe, TranslationContextDirective, TranslationForm, TranslationFormComponent, TranslationFormGroup, TranslationFormTextareaComponent, TranslationFormTextfieldComponent, TranslationToggleComponent, TypeUtils, UrlUtils, _HintComponentBase, _normalizeDegrees, isNotNullOrUndefined, isNullOrUndefined, mergeDeep, mixinNiceApi, niceAnimations, round, showErrorToast, showInfoToast, showLoadingToast, showSuccessOrErrorToast, showSuccessToast, showWarningToast };
+export type { AbstractConstructor, Constructor, DefaultStrategyType, ExportBottomSheetConfig, ExportBottomSheetOptions, ExportStrategy, HasNiceApiDefinition, HttpOptions, IAutoCompleteScrollEvent, IconType, ImgCropperErrorEvent, ImgCropperEvent, ImgCropperLoaderConfig, ImgOutput, ModalData, NiceAlertAppearance, NiceAlertColor, NiceAlertConfig, NiceAlertType, NiceApiDefinition, NiceAssets, NiceAssetsCarouselActionIcon, NiceAssetsCarouselActions, NiceAssetsCarouselOptions, NiceAsyncTypeaheadSearchResult, NiceChipListActionIcon, NiceChipListOptions, NiceDateRangePickerValue, NiceDrawerMode, NiceDrawerPosition, NiceLoadingOptions, NiceLoadingToastData, NiceLoadingToastOptions, NiceNavigationItem, NiceSweetAlertOptions, NiceSweetAlertParams, NiceToastData, NiceToastOptions, NiceVerticalNavigationAppearance, NiceVerticalNavigationMode, NiceVerticalNavigationPosition, Picture, PictureModalConfig, ShowLoadingToastOperatorOptions, ShowSuccessOrErrorToastOperatorOptions, ShowToastOperatorOptions, ShowToastOperatorOptionsWithoutMessage$1 as ShowToastOperatorOptionsWithoutMessage, ShowToastOperatorOptionsWithoutTitle$1 as ShowToastOperatorOptionsWithoutTitle, ToggleButtonGroupDataType };