@newheap/platform-common 0.20.6

package/index.d.ts

@@ -0,0 +1,2454 @@
+import { BrowserOptions } from '@sentry/browser/build/npm/types/client';
+import * as Sentry from '@sentry/angular';
+import { ErrorHandlerOptions } from '@sentry/angular';
+import * as i20 from '@angular/common';
+import { KeyValue } from '@angular/common';
+import { HttpHeaders, HttpParams, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpClient, HttpResponse } from '@angular/common/http';
+import * as i21 from '@ngx-translate/core';
+import { TranslateService, TranslateLoader } from '@ngx-translate/core';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject, Subject, Subscription } from 'rxjs';
+import * as i0 from '@angular/core';
+import { OnDestroy, NgZone, InjectionToken, ErrorHandler, Injector, ApplicationRef, TransferState, Type, RendererFactory2, ViewContainerRef, OnInit, AfterViewInit, ElementRef, ComponentRef, OnChanges, AfterContentInit, EventEmitter, PipeTransform, Renderer2, ChangeDetectorRef, ModuleWithProviders } from '@angular/core';
+import { CookieService, CookieOptions, SameSite } from 'ngx-cookie-service';
+import * as i23 from '@angular/forms';
+import { ControlValueAccessor, UntypedFormGroup, UntypedFormControl, NgControl, AbstractControl } from '@angular/forms';
+import * as SentryCore from '@sentry/core';
+import * as i1 from '@angular/router';
+import { Router, Route, Routes, LoadChildren, DefaultExport, CanActivateFn, CanMatchFn, CanActivateChildFn, RedirectFunction, Data, ActivatedRoute, ActivatedRouteSnapshot, NavigationExtras, UrlCreationOptions, UrlTree, RouterStateSnapshot, RouterLink, Params, ParamMap, CanDeactivate, MaybeAsync, GuardResult } from '@angular/router';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { Title, Meta, MetaDefinition, SafeHtml, DomSanitizer } from '@angular/platform-browser';
+import * as i22 from 'ngx-bootstrap-multiselect';
+import { IMultiSelectSettings, IMultiSelectTexts, NgxDropdownMultiselectComponent, IMultiSelectOption } from 'ngx-bootstrap-multiselect';
+import { ToastrService } from 'ngx-toastr';
+import { ColumnMode } from '@swimlane/ngx-datatable';
+
+declare class EndpointsAuthenticationNhCommonModuleConfig {
+    msAuthenticate: string;
+    msRedirectUrl: string;
+    authorizationFlow: string;
+    login: string;
+    logout: string;
+    refresh: string;
+    impersonate: string;
+    revertImpersonate: string;
+    accountInformation: string;
+    constructor(init?: Partial<EndpointsAuthenticationNhCommonModuleConfig>);
+}
+declare class AuthenticationNhCommonModuleConfig {
+    addAuthTokensToRequests: boolean;
+    additionalClaimPermissionTypes: string[];
+    additionalDivisionClaimPermissionTypes: string[];
+    endpoints: EndpointsAuthenticationNhCommonModuleConfig;
+    loginPath: string;
+    constructor(init?: Partial<AuthenticationNhCommonModuleConfig>);
+}
+declare class UserNotificationNhCommonModuleConfig {
+    urlSuffix: string;
+    pollingInterval: number;
+    constructor(init?: Partial<UserNotificationNhCommonModuleConfig>);
+}
+declare class NhSentryErrorLoggingNhCommonModuleConfig {
+    errorLoggingEnabled: boolean;
+    tracingEnabled: boolean;
+    beforeSendAddAuthServiceInformation: boolean;
+    options: BrowserOptions;
+    errorHandlerOptions: ErrorHandlerOptions;
+    constructor(init?: Partial<NhSentryErrorLoggingNhCommonModuleConfig>);
+}
+declare class NhErrorLoggingNhCommonModuleConfig {
+    sentry: NhSentryErrorLoggingNhCommonModuleConfig;
+    constructor(init?: Partial<NhErrorLoggingNhCommonModuleConfig>);
+}
+declare class NhTranslationNhCommonModuleConfig {
+    browserLoaderPrefix: string;
+    serverLoaderPath: string;
+    constructor(init?: Partial<NhTranslationNhCommonModuleConfig>);
+}
+declare class NhFormDropDownNhCommonModuleConfig {
+    deferLazyLoadUntilOpened: boolean;
+    constructor(init?: Partial<NhFormDropDownNhCommonModuleConfig>);
+}
+declare class NhHttpNhCommonModuleConfig {
+    deduplicateGetRequests: boolean;
+    deduplicateGetRequestHeaderNames: string[];
+    constructor(init?: Partial<NhHttpNhCommonModuleConfig>);
+}
+declare class NhCommonModuleConfig {
+    appDisplayName: string;
+    baseUrl: string;
+    apiBaseUrl: string;
+    authApiBaseUrl: string;
+    defaultLanguage: string;
+    supportedLanguages: string[];
+    authType: 'cookie' | 'header';
+    language: string;
+    defaultCulture: string;
+    culture: string;
+    authenticationRealm: string;
+    environment: string;
+    cookieDomain: string;
+    defaultItemsPerPage: number;
+    defaultDateFormat: string;
+    defaultDateTimeFormat: string;
+    authentication: AuthenticationNhCommonModuleConfig;
+    userNotification: UserNotificationNhCommonModuleConfig;
+    errorLogging: NhErrorLoggingNhCommonModuleConfig;
+    translation: NhTranslationNhCommonModuleConfig;
+    formDropdown: NhFormDropDownNhCommonModuleConfig;
+    http: NhHttpNhCommonModuleConfig;
+    constructor(init?: Partial<NhCommonModuleConfig>);
+}
+declare class NhCommonConfig {
+    languageCode: string;
+    culture: string;
+    constructor(init?: Partial<NhCommonConfig>);
+}
+declare class NhCommonConfigChanged {
+    config: NhCommonConfig;
+    constructor(init?: Partial<NhCommonConfigChanged>);
+}
+
+type SuccessResult<T> = TaskResult<T> & {
+    isSuccess: true;
+    data: T;
+};
+type ErrorResult<T> = TaskResult<T> & {
+    isSuccess: false;
+    data: T | undefined;
+};
+type TypedResult<T> = SuccessResult<T> | ErrorResult<T>;
+declare class TaskResultItem {
+    name: string;
+    errorMessages: string[];
+    constructor(init?: Partial<TaskResultItem>);
+}
+declare class TaskResult<T> {
+    isSuccess: boolean;
+    items: TaskResultItem[];
+    data: T | undefined;
+    constructor(init?: Partial<TaskResult<T>>);
+    withError(name: string, errorMessages: string | string[]): TaskResult<T>;
+    addError(name: string, errorMessages: string | string[]): void;
+    addErrors(errors: TaskResultItem[]): void;
+    copyTo<T2>(target: TaskResult<T2>): void;
+    getAllErrorMessages(): string[];
+    asTypedResult(): TypedResult<T>;
+}
+declare enum ListSortDirection {
+    Ascending = "Ascending",
+    Descending = "Descending"
+}
+declare class PreConnectUrlItem {
+    preConnect: boolean;
+    dnsPrefetch: boolean;
+    url: string;
+    withCrossOrigin: boolean;
+    crossOrigin?: string;
+    additionalAttributes: KeyValue<string, string>[];
+    constructor(init?: Partial<PreConnectUrlItem>);
+}
+declare class PreLoadUrlItem {
+    url: string;
+    withCrossOrigin: boolean;
+    crossOrigin?: string;
+    as: string;
+    type: string;
+    additionalAttributes: KeyValue<string, string>[];
+    constructor(init?: Partial<PreLoadUrlItem>);
+}
+type NhRouterLink = {
+    id: string;
+    arguments?: any;
+    language?: string | null | undefined;
+    scrollToTop?: boolean;
+};
+
+interface IHttpRequestOptions {
+    headers?: HttpHeaders;
+    observe?: 'body';
+    params?: HttpParams;
+    reportProgress?: boolean;
+    responseType?: 'json' | 'blob' | 'text' | 'arraybuffer';
+    withCredentials?: boolean;
+}
+declare class HttpRequestOptions implements IHttpRequestOptions {
+    headers?: HttpHeaders;
+    observe?: 'body';
+    params?: HttpParams;
+    reportProgress?: boolean;
+    responseType?: 'json';
+    withCredentials?: boolean;
+    constructor(init?: Partial<HttpRequestOptions>);
+}
+declare class HttpRequestOptionsArrayBuffer implements IHttpRequestOptions {
+    headers?: HttpHeaders;
+    observe?: 'body';
+    params?: HttpParams;
+    reportProgress?: boolean;
+    responseType?: 'arraybuffer';
+    withCredentials?: boolean;
+    constructor(init?: Partial<HttpRequestOptions>);
+}
+declare class HttpRequestOptionsText implements IHttpRequestOptions {
+    headers?: HttpHeaders;
+    observe?: 'body';
+    params?: HttpParams;
+    reportProgress?: boolean;
+    responseType?: 'text';
+    withCredentials?: boolean;
+    constructor(init?: Partial<HttpRequestOptionsText>);
+}
+interface IHttpDownloadRequestOptions extends IHttpRequestOptions {
+    responseType?: 'blob';
+}
+declare class HttpDownloadRequestOptions implements IHttpDownloadRequestOptions {
+    headers?: HttpHeaders;
+    observe?: 'body';
+    params?: HttpParams;
+    reportProgress?: boolean;
+    responseType?: 'blob';
+    withCredentials?: boolean;
+    constructor(init?: Partial<HttpDownloadRequestOptions>);
+}
+interface ISimpleCollectionHttpRequestOptions extends IHttpRequestOptions {
+    page: number;
+    itemsPerPage: number;
+}
+declare class SimpleCollectionHttpRequestOptions extends HttpRequestOptions implements ISimpleCollectionHttpRequestOptions {
+    page: number;
+    itemsPerPage: number;
+    constructor(init?: Partial<SimpleCollectionHttpRequestOptions>);
+}
+interface ISearchableCollectionHttpRequestOptions extends ISimpleCollectionHttpRequestOptions {
+    search?: string;
+}
+declare class SearchableCollectionHttpRequestOptions extends SimpleCollectionHttpRequestOptions implements ISearchableCollectionHttpRequestOptions {
+    search: string | undefined;
+    constructor(init?: Partial<SearchableCollectionHttpRequestOptions>);
+}
+interface ICollectionHttpRequestOptions extends ISearchableCollectionHttpRequestOptions {
+    orderBy: OrderByRequestOptions[];
+    filter: FilterRequestOptions[];
+}
+declare class CollectionHttpRequestOptions extends SearchableCollectionHttpRequestOptions implements ICollectionHttpRequestOptions {
+    orderBy: OrderByRequestOptions[];
+    filter: FilterRequestOptions[];
+    constructor(init?: Partial<CollectionHttpRequestOptions>);
+    or(condition: FilterRequestOptions): this;
+    and(condition: FilterRequestOptions): this;
+    equals(key: string, value: any, tag?: string): this;
+    notEquals(key: string, value: any, tag?: string): this;
+    isIn(key: string, value: any[], tag?: string): this;
+    isNotIn(key: string, value: any[], tag?: string): this;
+    lessThan(key: string, value: any, tag?: string): this;
+    lessThanOrEqual(key: string, value: any, tag?: string): this;
+    greaterThan(key: string, value: any, tag?: string): this;
+    greaterThanOrEqual(key: string, value: any, tag?: string): this;
+    like(key: string, value: string, tag?: string): this;
+    order(key: string, direction: 'ASC' | 'DESC'): this;
+    orderByFirst(propertyName: string, collectionItemProperty: string, direction: 'ASC' | 'DESC'): this;
+    orderByLast(propertyName: string, collectionItemProperty: string, direction: 'ASC' | 'DESC'): this;
+    orderAsc(key: string): this;
+    orderDesc(key: string): this;
+}
+interface ISimpleCollectionHttpResponse<T> {
+    page?: number;
+    itemsPerPage?: number;
+    resultCount?: number;
+    totalCount?: number;
+    items?: T[];
+}
+declare class SimpleCollectionHttpResponse<T> implements ISimpleCollectionHttpResponse<T> {
+    page: number;
+    itemsPerPage: number;
+    resultCount: number;
+    totalCount: number;
+    items: T[];
+    constructor(init?: Partial<SimpleCollectionHttpResponse<T>>);
+}
+interface ICollectionHttpResponse<T> extends ISimpleCollectionHttpResponse<T> {
+    orderBy?: OrderByRequestOptions[];
+    filter?: FilterRequestOptions[];
+    search?: string;
+}
+declare class CollectionHttpResponse<T> extends SimpleCollectionHttpResponse<T> implements ICollectionHttpResponse<T> {
+    orderBy: OrderByRequestOptions[];
+    filter: FilterRequestOptions[];
+    search: string;
+    constructor(init?: Partial<CollectionHttpResponse<T>>);
+}
+declare class OrderByRequestOptions {
+    key: string;
+    direction: 'ASC' | 'DESC';
+    constructor(init?: Partial<OrderByRequestOptions>);
+}
+declare class FilterRequestOptions {
+    tag: string | undefined;
+    key: string;
+    value: any;
+    operator: string;
+    ands: Array<FilterRequestOptions>;
+    ors: Array<FilterRequestOptions>;
+    static mergeToAndFilters(filters: Array<FilterRequestOptions>): FilterRequestOptions | null;
+    static mergeToOrFilters(filters: Array<FilterRequestOptions>): FilterRequestOptions | null;
+    and(options: FilterRequestOptions): this;
+    andArray(options: FilterRequestOptions[]): this;
+    or(options: FilterRequestOptions): this;
+    orArray(options: FilterRequestOptions[]): this;
+    static like(key: string, value: string, tag?: string): FilterRequestOptions;
+    static in(key: string, value: any[], tag?: string): FilterRequestOptions;
+    static notIn(key: string, value: any[], tag?: string): FilterRequestOptions;
+    static lessThan(key: string, value: any, tag?: string): FilterRequestOptions;
+    static lessThanOrEqual(key: string, value: any, tag?: string): FilterRequestOptions;
+    static greaterThan(key: string, value: any, tag?: string): FilterRequestOptions;
+    static greaterThanOrEqual(key: string, value: any, tag?: string): FilterRequestOptions;
+    static equals(key: string, value: any, tag?: string): FilterRequestOptions;
+    static notEquals(key: string, value: any, tag?: string): FilterRequestOptions;
+    constructor(init?: Partial<FilterRequestOptions>);
+}
+
+interface INhUser {
+    id: string | undefined;
+    email: string | undefined;
+    creationDateTime: any;
+    emailConfirmed: boolean;
+    lockoutEnd: any;
+    lockoutStart: any;
+    activeDivisionId: string | undefined;
+    activeDivision: INhDivision | undefined;
+    roles: Array<string>;
+}
+declare class NhUser implements INhUser {
+    id: string | undefined;
+    email: string | undefined;
+    creationDateTime: any;
+    emailConfirmed: boolean;
+    lockoutEnd: any;
+    lockoutStart: any;
+    activeDivisionId: string | undefined;
+    activeDivision: INhDivision | undefined;
+    division: INhDivision | undefined;
+    roles: Array<string>;
+    constructor(init?: Partial<NhUser>);
+}
+interface INhAuthorization {
+    realm: string;
+    provider: string;
+    token: string;
+    validTo: string | undefined;
+    refreshToken: string | undefined;
+    refreshTokenExpires: string | undefined;
+    user?: INhUser;
+    claims: Claim[];
+    divisions: INhDivision[];
+    activeDivision?: INhDivision;
+}
+declare class NhAuthorization implements INhAuthorization {
+    realm: string;
+    provider: string;
+    token: string;
+    validTo: string | undefined;
+    refreshToken: string | undefined;
+    refreshTokenExpires: string | undefined;
+    user?: INhUser;
+    claims: Claim[];
+    divisions: INhDivision[];
+    activeDivision?: INhDivision;
+    constructor(init?: Partial<NhAuthorization>);
+}
+interface INhAccountInformationResponse {
+    user?: INhUser;
+    claims: Claim[];
+    divisions: INhDivision[];
+    activeDivision?: INhDivision;
+}
+declare class NhAccountInformationResponse implements INhAccountInformationResponse {
+    user?: INhUser;
+    claims: Claim[];
+    divisions: INhDivision[];
+    activeDivision?: INhDivision;
+    constructor(init?: Partial<NhAccountInformationResponse>);
+}
+interface INhDivision {
+    id: string;
+    creationDateTime: any;
+    lastModifiedDateTime: any;
+    name: string;
+    description: string;
+    userSelectAllowed: boolean;
+    timeZoneId: string;
+}
+declare class NhDivision implements INhDivision {
+    id: string;
+    creationDateTime: any;
+    lastModifiedDateTime: any;
+    name: string;
+    description: string;
+    userSelectAllowed: boolean;
+    timeZoneId: string;
+    constructor(init?: Partial<NhDivision>);
+}
+interface INhDivisionRole {
+    id?: string;
+    name?: string;
+}
+declare class NhDivisionRole implements INhDivisionRole {
+    id?: string;
+    name?: string;
+    constructor(init?: Partial<NhDivisionRole>);
+}
+interface INhDivisionUser {
+    id?: string;
+    lockOutStartDateTime?: string;
+    lockOutEndDateTime?: string;
+    userId?: string;
+    user?: INhUser;
+    divisionId?: string;
+    division?: NhDivision;
+    roles: Array<NhDivisionRole>;
+    roleIds: Array<string>;
+}
+declare class NhDivisionUser implements INhDivisionUser {
+    id?: string;
+    lockOutStartDateTime?: string;
+    lockOutEndDateTime?: string;
+    userId?: string;
+    user?: INhUser;
+    divisionId?: string;
+    division?: INhDivision;
+    roles: Array<INhDivisionRole>;
+    roleIds: Array<string>;
+    constructor(init?: Partial<NhDivisionUser>);
+}
+declare class AuthSessionExpirationInformation {
+    isAuthenticated: boolean;
+    expiresWithin15MinutesOrExpired: boolean;
+    displayMinutesSecondsUntilExpiration: string;
+    constructor(init?: Partial<AuthSessionExpirationInformation>);
+}
+declare class RefreshTokenLoginAccountMutateModel {
+    token: string;
+    refreshToken: string;
+    constructor(init?: Partial<RefreshTokenLoginAccountMutateModel>);
+}
+declare class AuthenticationSessionCreateResponse {
+    sessionToken: string;
+    expirationDateTime: string;
+    constructor(init?: Partial<AuthenticationSessionCreateResponse>);
+}
+declare class ClaimAuthenticateSessionAccountMutateModel {
+    sessionToken: string;
+    constructor(init?: Partial<ClaimAuthenticateSessionAccountMutateModel>);
+}
+interface IClaimAuthenticateSessionAccountViewModel {
+    completed: boolean;
+    success: boolean;
+    errorMessages: string[];
+    token?: INhAuthorization;
+}
+declare class ClaimAuthenticateSessionAccountViewModel implements IClaimAuthenticateSessionAccountViewModel {
+    completed: boolean;
+    success: boolean;
+    errorMessages: string[];
+    token?: INhAuthorization;
+    constructor(init?: Partial<ClaimAuthenticateSessionAccountViewModel>);
+}
+declare class CheckAuthenticateSessionModel {
+    success: boolean;
+    didTry: boolean;
+    completed: boolean;
+    errorMessages: string[];
+    constructor(init?: Partial<CheckAuthenticateSessionModel>);
+}
+declare class Claim {
+    type: string | undefined;
+    value: string | undefined;
+    constructor(init?: Partial<Claim>);
+}
+declare enum ClaimTypes {
+    Name = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name",
+    Email = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress",
+    NameIdentifier = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier",
+    Country = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/country",
+    Role = "http://schemas.microsoft.com/ws/2008/06/identity/claims/role",
+    Permission = "nh.platform.permission",
+    DivisionRole = "nh.platform.division.role",
+    DivisionPermission = "nh.platform.division.permission",
+    ImpersonateOriginUserId = "nh.platform.auth.impersonate.origin-user-id"
+}
+declare class AuthenticateModel {
+    realm: string;
+    username: string;
+    password: string | undefined;
+    constructor(init?: Partial<AuthenticateModel>);
+}
+declare class ImpersonateAuthenticateModel {
+    userId: string;
+    constructor(init?: Partial<ImpersonateAuthenticateModel>);
+}
+declare class RevertImpersonateAuthenticateModel {
+    constructor(init?: Partial<RevertImpersonateAuthenticateModel>);
+}
+type AuthenticationFlow = 'password' | 'microsoft-oauth' | string;
+
+declare class NhUserNotificationCollectionHttpRequestOptions extends CollectionHttpRequestOptions {
+    constructor(init?: Partial<NhUserNotificationCollectionHttpRequestOptions>);
+}
+declare class NhUserNotificationState {
+    overview: NhUserNotificationOverview;
+    constructor(init?: Partial<NhUserNotificationState>);
+}
+declare class NhUserNotificationOverview {
+    totalCount: number;
+    unreadCount: number;
+    lastNotificationDate: string;
+    constructor(init?: Partial<NhUserNotificationOverview>);
+}
+declare class NhUserNotification {
+    id: string;
+    creationDateTime: string;
+    lastModifiedDateTime: string;
+    messages: NhUserNotificationMessage[];
+    lastTitle: string;
+    lastMessage: string;
+    isLastRead: boolean;
+    data: NhUserNotificationData;
+    constructor(init?: Partial<NhUserNotification>);
+}
+declare class NhUserNotificationMessage {
+    id: string;
+    creationDateTime: string;
+    lastModifiedDateTime: string;
+    title: string;
+    message: string;
+    userNotificationId: string;
+    constructor(init?: Partial<NhUserNotificationMessage>);
+}
+declare class NhUserNotificationData {
+    url: string;
+    urlInNewTab: boolean;
+    constructor(init?: Partial<NhUserNotificationData>);
+}
+
+declare const languageToCultureMap: {
+    nl: string;
+    en: string;
+    fr: string;
+    de: string;
+};
+declare const nameof: <T>(name: keyof T) => keyof T;
+declare const IsDefined: <T>(value: T) => value is NonNullable<T>;
+declare function enumKeysToArray(e: any): string[];
+declare function enumValuesToArray(e: any): any[];
+declare function enumIntValuesToArray(e: any): number[];
+declare function enumStringValuesToArray(e: any): string[];
+declare function getEmptyGuid(): string;
+declare function getRandomIdentifier(): string;
+declare function groupBy<T>(items: any[], keyGetter: any): any;
+declare function uppercaseFirst(val?: string): string | undefined;
+
+declare class NhStringUtil {
+    static upperFirst(inString: string | undefined | null): string | undefined | null;
+    static lowerFirst(inString: string | undefined | null): string | undefined | null;
+}
+
+declare class NhHttpUtil {
+    static filenameFromContentDisposition(contentDisposition: string): string;
+    static objectToFormData(obj: any, formData?: FormData, namespace?: string): FormData;
+}
+
+declare class NhEncodingUtil {
+    static convertBlobToBase64(blob: Blob): Promise<string | ArrayBuffer | null>;
+}
+
+declare class NhAngularUtil {
+    static idTrackBy(index: number, idObject: any): any;
+}
+
+declare class NhApiUtil {
+    static Constants: {
+        new (): {};
+        HttpHeaderKeys: {
+            new (): {};
+        };
+    };
+    static ParseCollectionRequestOptions(value?: string | null): CollectionHttpRequestOptions;
+    private static processFilter;
+    static taskResultFromResponse(response: any): TaskResult<any>;
+}
+
+interface NhEnumDropDownItem<TValue extends string | number> {
+    id: TValue | '';
+    name: string;
+}
+declare class NhFormHelper {
+    static clearErrors(form: any): void;
+    private static clearError;
+    private static clearFormGroupErrors;
+    private static clearFormArrayErrors;
+    private static clearControlErrors;
+    static getEnumDropDownByEnum(e: any, translateService: TranslateService, translationPrefix: string, emptyFirst?: boolean, skipValues?: any[]): any[];
+    static getEnumDropDownByEnum<TValue extends string | number>(e: any, translateService: TranslateService, translationPrefix: string, emptyFirst: boolean, skipValues: TValue[], translationKeySelector: (value: TValue) => string): NhEnumDropDownItem<TValue>[];
+}
+
+declare class NhMutex {
+    private lockPromise;
+    lock(): Promise<() => void>;
+}
+declare class NhAsyncLock {
+    private isLocked;
+    runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+}
+
+declare class NhEncodeHttpParamsInterceptor implements HttpInterceptor {
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhEncodeHttpParamsInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhEncodeHttpParamsInterceptor>;
+}
+
+/**
+ * Optional configuration to be used when parsing cookies.
+ * @public
+ */
+interface ParseCookieOptions {
+    /**
+     * If `true` then keyless cookies like `=abc` and `=` which are not RFC-compliant will be parsed.
+     */
+    loose?: boolean | undefined;
+}
+/**
+ * Configurable values that can be set when creating a {@link Cookie}.
+ * @public
+ */
+interface CreateCookieOptions {
+    /** {@inheritDoc Cookie.key} */
+    key?: string;
+    /** {@inheritDoc Cookie.value} */
+    value?: string;
+    /** {@inheritDoc Cookie.expires} */
+    expires?: Date | 'Infinity' | null;
+    /** {@inheritDoc Cookie.maxAge} */
+    maxAge?: number | 'Infinity' | '-Infinity' | null;
+    /** {@inheritDoc Cookie.domain} */
+    domain?: string | null;
+    /** {@inheritDoc Cookie.path} */
+    path?: string | null;
+    /** {@inheritDoc Cookie.secure} */
+    secure?: boolean;
+    /** {@inheritDoc Cookie.httpOnly} */
+    httpOnly?: boolean;
+    /** {@inheritDoc Cookie.extensions} */
+    extensions?: string[] | null;
+    /** {@inheritDoc Cookie.creation} */
+    creation?: Date | 'Infinity' | null;
+    /** {@inheritDoc Cookie.hostOnly} */
+    hostOnly?: boolean | null;
+    /** {@inheritDoc Cookie.pathIsDefault} */
+    pathIsDefault?: boolean | null;
+    /** {@inheritDoc Cookie.lastAccessed} */
+    lastAccessed?: Date | 'Infinity' | null;
+    /** {@inheritDoc Cookie.sameSite} */
+    sameSite?: string | undefined;
+}
+/**
+ * An HTTP cookie (web cookie, browser cookie) is a small piece of data that a server sends to a user's web browser.
+ * It is defined in {@link https://www.rfc-editor.org/rfc/rfc6265.html | RFC6265}.
+ * @public
+ */
+declare class Cookie {
+    /**
+     * The name or key of the cookie
+     */
+    key: string;
+    /**
+     * The value of the cookie
+     */
+    value: string;
+    /**
+     * The 'Expires' attribute of the cookie
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.2.1 | RFC6265 Section 5.2.1}).
+     */
+    expires: Date | 'Infinity' | null;
+    /**
+     * The 'Max-Age' attribute of the cookie
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.2.2 | RFC6265 Section 5.2.2}).
+     */
+    maxAge: number | 'Infinity' | '-Infinity' | null;
+    /**
+     * The 'Domain' attribute of the cookie represents the domain the cookie belongs to
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.2.3 | RFC6265 Section 5.2.3}).
+     */
+    domain: string | null;
+    /**
+     * The 'Path' attribute of the cookie represents the path of the cookie
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.2.4 | RFC6265 Section 5.2.4}).
+     */
+    path: string | null;
+    /**
+     * The 'Secure' flag of the cookie indicates if the scope of the cookie is
+     * limited to secure channels (e.g.; HTTPS) or not
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.2.5 | RFC6265 Section 5.2.5}).
+     */
+    secure: boolean;
+    /**
+     * The 'HttpOnly' flag of the cookie indicates if the cookie is inaccessible to
+     * client scripts or not
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.2.6 | RFC6265 Section 5.2.6}).
+     */
+    httpOnly: boolean;
+    /**
+     * Contains attributes which are not part of the defined spec but match the `extension-av` syntax
+     * defined in Section 4.1.1 of RFC6265
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-4.1.1 | RFC6265 Section 4.1.1}).
+     */
+    extensions: string[] | null;
+    /**
+     * Set to the date and time when a Cookie is initially stored or a matching cookie is
+     * received that replaces an existing cookie
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.3 | RFC6265 Section 5.3}).
+     *
+     * Also used to maintain ordering among cookies. Among cookies that have equal-length path fields,
+     * cookies with earlier creation-times are listed before cookies with later creation-times
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.4 | RFC6265 Section 5.4}).
+     */
+    creation: Date | 'Infinity' | null;
+    /**
+     * A global counter used to break ordering ties between two cookies that have equal-length path fields
+     * and the same creation-time.
+     */
+    creationIndex: number;
+    /**
+     * A boolean flag indicating if a cookie is a host-only cookie (i.e.; when the request's host exactly
+     * matches the domain of the cookie) or not
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.3 | RFC6265 Section 5.3}).
+     */
+    hostOnly: boolean | null;
+    /**
+     * A boolean flag indicating if a cookie had no 'Path' attribute and the default path
+     * was used
+     * (See {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.2.4 | RFC6265 Section 5.2.4}).
+     */
+    pathIsDefault: boolean | null;
+    /**
+     * Set to the date and time when a cookie was initially stored ({@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.3 | RFC6265 Section 5.3}) and updated whenever
+     * the cookie is retrieved from the {@link CookieJar} ({@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.4 | RFC6265 Section 5.4}).
+     */
+    lastAccessed: Date | 'Infinity' | null;
+    /**
+     * The 'SameSite' attribute of a cookie as defined in RFC6265bis
+     * (See {@link https://www.ietf.org/archive/id/draft-ietf-httpbis-rfc6265bis-13.html#section-5.2 | RFC6265bis (v13) Section 5.2 }).
+     */
+    sameSite: string | undefined;
+    /**
+     * Create a new Cookie instance.
+     * @public
+     * @param options - The attributes to set on the cookie
+     */
+    constructor(options?: CreateCookieOptions);
+    /**
+     * Sets the 'Expires' attribute on a cookie.
+     *
+     * @remarks
+     * When given a `string` value it will be parsed with {@link parseDate}. If the value can't be parsed as a cookie date
+     * then the 'Expires' attribute will be set to `"Infinity"`.
+     *
+     * @param exp - the new value for the 'Expires' attribute of the cookie.
+     */
+    setExpires(exp: string | Date): void;
+    /**
+     * Sets the 'Max-Age' attribute (in seconds) on a cookie.
+     *
+     * @remarks
+     * Coerces `-Infinity` to `"-Infinity"` and `Infinity` to `"Infinity"` so it can be serialized to JSON.
+     *
+     * @param age - the new value for the 'Max-Age' attribute (in seconds).
+     */
+    setMaxAge(age: number): void;
+    /**
+     * Encodes to a `Cookie` header value (specifically, the {@link Cookie.key} and {@link Cookie.value} properties joined with "=").
+     * @public
+     */
+    cookieString(): string;
+    /**
+     * Encodes to a `Set-Cookie header` value.
+     * @public
+     */
+    toString(): string;
+    /**
+     * Computes the TTL relative to now (milliseconds).
+     *
+     * @remarks
+     * - `Infinity` is returned for cookies without an explicit expiry
+     *
+     * - `0` is returned if the cookie is expired.
+     *
+     * - Otherwise a time-to-live in milliseconds is returned.
+     *
+     * @param now - passing an explicit value is mostly used for testing purposes since this defaults to the `Date.now()`
+     * @public
+     */
+    TTL(now?: number): number;
+    /**
+     * Computes the absolute unix-epoch milliseconds that this cookie expires.
+     *
+     * The "Max-Age" attribute takes precedence over "Expires" (as per the RFC). The {@link Cookie.lastAccessed} attribute
+     * (or the `now` parameter if given) is used to offset the {@link Cookie.maxAge} attribute.
+     *
+     * If Expires ({@link Cookie.expires}) is set, that's returned.
+     *
+     * @param now - can be used to provide a time offset (instead of {@link Cookie.lastAccessed}) to use when calculating the "Max-Age" value
+     */
+    expiryTime(now?: Date): number | undefined;
+    /**
+     * Similar to {@link Cookie.expiryTime}, computes the absolute unix-epoch milliseconds that this cookie expires and returns it as a Date.
+     *
+     * The "Max-Age" attribute takes precedence over "Expires" (as per the RFC). The {@link Cookie.lastAccessed} attribute
+     * (or the `now` parameter if given) is used to offset the {@link Cookie.maxAge} attribute.
+     *
+     * If Expires ({@link Cookie.expires}) is set, that's returned.
+     *
+     * @param now - can be used to provide a time offset (instead of {@link Cookie.lastAccessed}) to use when calculating the "Max-Age" value
+     */
+    expiryDate(now?: Date): Date | undefined;
+    /**
+     * Indicates if the cookie has been persisted to a store or not.
+     * @public
+     */
+    isPersistent(): boolean;
+    /**
+     * Parses a string into a Cookie object.
+     *
+     * @remarks
+     * Note: when parsing a `Cookie` header it must be split by ';' before each Cookie string can be parsed.
+     *
+     * @example
+     * ```
+     * // parse a `Set-Cookie` header
+     * const setCookieHeader = 'a=bcd; Expires=Tue, 18 Oct 2011 07:05:03 GMT'
+     * const cookie = Cookie.parse(setCookieHeader)
+     * cookie.key === 'a'
+     * cookie.value === 'bcd'
+     * cookie.expires === new Date(Date.parse('Tue, 18 Oct 2011 07:05:03 GMT'))
+     * ```
+     *
+     * @example
+     * ```
+     * // parse a `Cookie` header
+     * const cookieHeader = 'name=value; name2=value2; name3=value3'
+     * const cookies = cookieHeader.split(';').map(Cookie.parse)
+     * cookies[0].name === 'name'
+     * cookies[0].value === 'value'
+     * cookies[1].name === 'name2'
+     * cookies[1].value === 'value2'
+     * cookies[2].name === 'name3'
+     * cookies[2].value === 'value3'
+     * ```
+     *
+     * @param str - The `Set-Cookie` header or a Cookie string to parse.
+     * @param options - Configures `strict` or `loose` mode for cookie parsing
+     */
+    static parse(str: string, options?: ParseCookieOptions): Cookie | undefined;
+    /**
+     * Does the reverse of {@link Cookie.toJSON}.
+     *
+     * @remarks
+     * Any Date properties (such as .expires, .creation, and .lastAccessed) are parsed via Date.parse, not tough-cookie's parseDate, since ISO timestamps are being handled at this layer.
+     *
+     * @example
+     * ```
+     * const json = JSON.stringify({
+     *   key: 'alpha',
+     *   value: 'beta',
+     *   domain: 'example.com',
+     *   path: '/foo',
+     *   expires: '2038-01-19T03:14:07.000Z',
+     * })
+     * const cookie = Cookie.fromJSON(json)
+     * cookie.key === 'alpha'
+     * cookie.value === 'beta'
+     * cookie.domain === 'example.com'
+     * cookie.path === '/foo'
+     * cookie.expires === new Date(Date.parse('2038-01-19T03:14:07.000Z'))
+     * ```
+     *
+     * @param str - An unparsed JSON string or a value that has already been parsed as JSON
+     */
+    static fromJSON(str: unknown): Cookie | undefined;
+    private static cookiesCreated;
+    /**
+     * @internal
+     */
+    static sameSiteLevel: {
+        readonly strict: 3;
+        readonly lax: 2;
+        readonly none: 1;
+    };
+    /**
+     * @internal
+     */
+    static sameSiteCanonical: {
+        readonly strict: "Strict";
+        readonly lax: "Lax";
+    };
+    /**
+     * Cookie properties that will be serialized when using {@link Cookie.fromJSON} and {@link Cookie.toJSON}.
+     * @public
+     */
+    static serializableProperties: readonly ["key", "value", "expires", "maxAge", "domain", "path", "secure", "httpOnly", "extensions", "hostOnly", "pathIsDefault", "creation", "lastAccessed", "sameSite"];
+}
+
+declare class NhCookieService {
+    private document;
+    private platformId;
+    private requestContext;
+    private cookieService;
+    static readonly HTTP_COOKIE_PREFIX: string;
+    static readonly COOKIE_SPLIT_REGEX: RegExp;
+    static readonly NOP_COOKIE_CUSTOMER: string;
+    static readonly NOP_COOKIE_AUTHENTICATION: string;
+    static readonly Nh_COOKIE_AUTHENTICATION: string;
+    constructor(document: Document, platformId: Object, requestContext: any, cookieService: CookieService);
+    getAll(): string[];
+    get(key: string): string | undefined;
+    set(name: string, value: string, options?: CookieOptions): void;
+    delete(name: string, path?: CookieOptions['path'], domain?: CookieOptions['domain'], secure?: CookieOptions['secure'], sameSite?: SameSite): void;
+    requestRawCookiesHeaderToCookies(rawCookiesHeader: string): Cookie[];
+    responseRawCookiesHeaderToCookies(rawCookiesHeader: string): Cookie[];
+    getRequestServerCookies(): Cookie[];
+    setServerCookies(cookies: Cookie[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhCookieService, [null, null, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhCookieService>;
+}
+
+declare abstract class BaseNhAuthService<TAuthorization extends INhAuthorization> implements OnDestroy {
+    protected authorization: TAuthorization | undefined;
+    protected authSession: AuthenticationSessionCreateResponse | undefined;
+    readonly authSubject: BehaviorSubject<TAuthorization | undefined>;
+    protected onReady: ((value: (PromiseLike<unknown> | unknown)) => void) | undefined;
+    readonly authReady: Promise<unknown>;
+    protected _sessionExpirationInformation: BehaviorSubject<AuthSessionExpirationInformation>;
+    sessionExpirationInformationChanged: rxjs.Observable<AuthSessionExpirationInformation>;
+    protected intervalHandle: any;
+    protected zone: NgZone;
+    protected moduleConfig: NhCommonModuleConfig;
+    protected httpClient: HttpClient;
+    protected platformId: Object;
+    protected requestContext: any;
+    constructor();
+    dispatchSessionExpirationInformationChanged(): void;
+    ngOnDestroy(): void;
+    private getAllPermissionClaimTypes;
+    private getAllDivisionPermissionClaimTypes;
+    getSessionExpirationInformation(): AuthSessionExpirationInformation;
+    clearAuthorization(doDispatchEvent?: boolean): void;
+    setAuthorization(auth: TAuthorization, noEvent?: boolean): void;
+    protected abstract initEmptyAuthorization(): TAuthorization;
+    getAuthorization(fromCache?: boolean): TAuthorization | undefined;
+    isAuthenticated(): boolean;
+    isImpersonating(): boolean;
+    getActiveDivision(): NhDivision | null;
+    getActiveDivisionId(): string | undefined;
+    isGrantedRole(roles: string | string[]): boolean;
+    isClaimGranted(claim: Claim): boolean;
+    isOneClaimGranted(claims: Array<Claim>): boolean;
+    isOnePermissionGranted(permissions: Array<string>): boolean;
+    /**
+     * Returns true only when every requested permission is granted through one
+     * of the configured permission claim types. An empty requirement is allowed.
+     */
+    isAllPermissionsGranted(permissions: Array<string>): boolean;
+    isOneRoleGranted(roles: Array<string>): boolean;
+    isOneDivisionPermissionGranted(divisionId: string | undefined, permissions: Array<string>): boolean;
+    isOneDivisionRoleGranted(divisionId: string | undefined, roles: Array<string>): boolean;
+    isOneActiveDivisionPermissionGranted(permissions: Array<string>): boolean;
+    isOneActiveDivisionRoleGranted(roles: Array<string>): boolean;
+    getAuthenticationFlow(username: string): Promise<TaskResult<AuthenticationFlow>>;
+    getMicrosoftRedirectUrl(callbackUrl: string, username: string): Promise<TaskResult<string>>;
+    authorizeMicrosoft(code: string, state: string): Promise<TaskResult<TAuthorization>>;
+    authenticate(model: AuthenticateModel, loginAsUser?: boolean): Promise<TaskResult<TAuthorization>>;
+    reloadAuthorizationProfile(): Promise<TaskResult<TAuthorization>>;
+    logout(): Promise<TaskResult<void>>;
+    authenticateRefreshToken(model: RefreshTokenLoginAccountMutateModel): Promise<TaskResult<TAuthorization>>;
+    impersonate(model: ImpersonateAuthenticateModel): Promise<TaskResult<TAuthorization>>;
+    impersonateRevert(model: RevertImpersonateAuthenticateModel): Promise<TaskResult<TAuthorization>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseNhAuthService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseNhAuthService<any>>;
+}
+declare class NhAuthService extends BaseNhAuthService<NhAuthorization> {
+    protected initEmptyAuthorization(): NhAuthorization;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhAuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhAuthService>;
+}
+
+declare class NhRequestScopedServerHttpInterceptorService {
+    private moduleConfig;
+    private platformId;
+    private requestContext;
+    didSetCookies: boolean;
+    constructor(moduleConfig: NhCommonModuleConfig, platformId: Object, requestContext: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhRequestScopedServerHttpInterceptorService, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhRequestScopedServerHttpInterceptorService>;
+}
+declare class NhServerHttpInterceptor implements HttpInterceptor {
+    private moduleConfig;
+    private platformId;
+    private document;
+    private requestScopedServerHttpInterceptorService;
+    private cookieService;
+    private authService;
+    constructor(moduleConfig: NhCommonModuleConfig, platformId: Object, document: Document, requestScopedServerHttpInterceptorService: NhRequestScopedServerHttpInterceptorService, cookieService: NhCookieService, authService: NhAuthService);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhServerHttpInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhServerHttpInterceptor>;
+}
+
+declare class NhDeduplicateGetRequestsInterceptor implements HttpInterceptor {
+    private moduleConfig;
+    private activeRequests;
+    constructor(moduleConfig: NhCommonModuleConfig);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    private getRequestKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhDeduplicateGetRequestsInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhDeduplicateGetRequestsInterceptor>;
+}
+
+declare abstract class AbstractValueAccessor implements ControlValueAccessor {
+    _value: any;
+    get value(): any;
+    set value(v: any);
+    writeValue(value: any): void;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    registerOnChange(fn: (_: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+}
+declare function MakeProvider(type: any): {
+    provide: i0.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: i0.Type<any>;
+    multi: boolean;
+};
+
+declare const NH_ERROR_HANDLERS: InjectionToken<ErrorHandler[]>;
+declare class NhErrorHandlerService implements ErrorHandler {
+    private injector;
+    constructor(injector: Injector);
+    handleError(error: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhErrorHandlerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhErrorHandlerService>;
+}
+
+type NhSentryBeforeSendHook = (event: Sentry.ErrorEvent, hint: Sentry.EventHint) => Sentry.ErrorEvent | null | PromiseLike<Sentry.ErrorEvent | null>;
+type NhSentryBeforeSendLogHook = (event: SentryCore.Log) => SentryCore.Log | null;
+type NhSentryBeforeSendSpanHook = (span: SentryCore.SpanJSON) => SentryCore.SpanJSON;
+type NhSentryBeforeSendTransactionHook = (span: SentryCore.TransactionEvent, hint: Sentry.EventHint) => SentryCore.TransactionEvent | null | PromiseLike<SentryCore.TransactionEvent | null>;
+type NhSentryBeforeBreadcrumbHook = (span: Sentry.Breadcrumb, hint?: Sentry.BreadcrumbHint) => Sentry.Breadcrumb | null;
+declare const NH_SENTRY_BEFORE_SEND_HOOKS: InjectionToken<NhSentryBeforeSendHook[]>;
+declare const NH_SENTRY_BEFORE_SEND_LOG_HOOKS: InjectionToken<NhSentryBeforeSendLogHook[]>;
+declare const NH_SENTRY_BEFORE_SEND_SPAN_HOOKS: InjectionToken<NhSentryBeforeSendSpanHook[]>;
+declare const NH_SENTRY_BEFORE_SEND_TRANSACTION_HOOKS: InjectionToken<NhSentryBeforeSendTransactionHook[]>;
+declare const NH_SENTRY_BEFORE_BREADCRUMB_HOOKS: InjectionToken<NhSentryBeforeBreadcrumbHook[]>;
+declare class NhSentryInitializerService implements OnDestroy {
+    private readonly moduleConfig;
+    private readonly authService;
+    private providedHooksBeforeSend;
+    private providedHooksBeforeSendLog;
+    private providedHooksBeforeSendSpan;
+    private providedHooksBeforeSendTransaction;
+    private providedHooksBeforeBreadcrumb;
+    private _didInitialize;
+    private _sentryConfig;
+    private authorization;
+    private $auth;
+    private runtimeHooksBeforeSend;
+    private runtimeHooksBeforeSendLog;
+    private runtimeHooksBeforeSendSpan;
+    private runtimeHooksBeforeSendTransaction;
+    private runtimeHooksBeforeBreadcrumb;
+    get hooksBeforeSend(): NhSentryBeforeSendHook[];
+    get hooksBeforeSendLog(): NhSentryBeforeSendLogHook[];
+    get hooksBeforeSendSpan(): NhSentryBeforeSendSpanHook[];
+    get hooksBeforeSendTransaction(): NhSentryBeforeSendTransactionHook[];
+    get hooksBeforeBreadcrumb(): NhSentryBeforeBreadcrumbHook[];
+    get isEnabled(): boolean;
+    get isInitializedAndEnabled(): boolean;
+    get sentry(): typeof Sentry;
+    constructor(moduleConfig: NhCommonModuleConfig, authService: NhAuthService, providedHooksBeforeSend?: NhSentryBeforeSendHook[], providedHooksBeforeSendLog?: NhSentryBeforeSendLogHook[], providedHooksBeforeSendSpan?: NhSentryBeforeSendSpanHook[], providedHooksBeforeSendTransaction?: NhSentryBeforeSendTransactionHook[], providedHooksBeforeBreadcrumb?: NhSentryBeforeBreadcrumbHook[]);
+    private authChanged;
+    registerHookBeforeSend(hook: NhSentryBeforeSendHook): void;
+    registerHookBeforeSendLog(hook: NhSentryBeforeSendLogHook): void;
+    registerHookBeforeSendSpan(hook: NhSentryBeforeSendSpanHook): void;
+    registerHookBeforeSendTransaction(hook: NhSentryBeforeSendTransactionHook): void;
+    registerHookBeforeBreadcrumb(hook: NhSentryBeforeBreadcrumbHook): void;
+    private ourBeforeSendHook;
+    initialize(): void;
+    private runHooksBeforeSend;
+    private runHooksBeforeSendLog;
+    private runHooksBeforeSendSpan;
+    private runHooksBeforeSendTransaction;
+    private runHooksBeforeBreadcrumb;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhSentryInitializerService, [null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhSentryInitializerService>;
+}
+declare class NhSentryService implements OnDestroy {
+    private readonly moduleConfig;
+    private readonly sentryInitializerService;
+    private _sentryConfig;
+    get isEnabled(): boolean;
+    get isInitializedAndEnabled(): boolean;
+    get sentry(): typeof Sentry;
+    constructor(moduleConfig: NhCommonModuleConfig, sentryInitializerService: NhSentryInitializerService);
+    registerHookBeforeSend(hook: NhSentryBeforeSendHook): void;
+    registerHookBeforeSendLog(hook: NhSentryBeforeSendLogHook): void;
+    registerHookBeforeSendSpan(hook: NhSentryBeforeSendSpanHook): void;
+    registerHookBeforeSendTransaction(hook: NhSentryBeforeSendTransactionHook): void;
+    registerHookBeforeBreadcrumb(hook: NhSentryBeforeBreadcrumbHook): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhSentryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhSentryService>;
+}
+
+declare class NhErrorHandlerSentryService implements ErrorHandler, OnDestroy {
+    private readonly moduleConfig;
+    private readonly sentryInitializerService;
+    private _sentryErrorHandler;
+    private _didInitialize;
+    get sentryErrorHandler(): Sentry.SentryErrorHandler | undefined;
+    constructor(moduleConfig: NhCommonModuleConfig, sentryInitializerService: NhSentryInitializerService);
+    initialize(): void;
+    handleError(error: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhErrorHandlerSentryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhErrorHandlerSentryService>;
+}
+
+declare class NhSentryTraceService implements OnDestroy {
+    private readonly moduleConfig;
+    private readonly sentryInitializerService;
+    private readonly router;
+    private _sentryTraceService;
+    private _didInitialize;
+    get sentryTraceService(): Sentry.TraceService | undefined;
+    constructor(moduleConfig: NhCommonModuleConfig, sentryInitializerService: NhSentryInitializerService, router: Router);
+    initialize(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhSentryTraceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhSentryTraceService>;
+}
+
+declare class NhAppService implements OnDestroy {
+    private document;
+    private platformId;
+    private appRef;
+    private transferState;
+    private router;
+    private $appRefIsStable;
+    private appIsStable;
+    private afterNextRenderComplete;
+    private firstHydrateComplete;
+    private stateKeys;
+    private browserFirstHydrateComplete$;
+    readonly localStorage?: Storage;
+    constructor(document: Document, platformId: Object, appRef: ApplicationRef, transferState: TransferState, router: Router);
+    isAppStable(): boolean;
+    ngOnDestroy(): void;
+    originatedFromServer(): boolean;
+    isPlatformServer(): boolean;
+    isPlatformBrowser(): boolean;
+    firstHydrateCompleted(): boolean;
+    afterNextRenderCompleted(): boolean;
+    isPlatformBrowserInitial(): boolean;
+    setStateTransferData(key: string, data: any): void;
+    getStateTransferData<T>(key: string): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhAppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhAppService>;
+}
+
+declare class NhConfigCommonService implements OnDestroy {
+    private document;
+    private platformId;
+    private requestContext;
+    private authService;
+    private translateService;
+    private cookieService;
+    private commonModuleConfig;
+    private static STORAGE_KEY;
+    private static COOKIE_KEY_LANGUAGE_CODE;
+    private didInitialize;
+    private readonly localStorage?;
+    private config;
+    readonly configSubject: BehaviorSubject<NhCommonConfigChanged>;
+    constructor(document: Document, platformId: Object, requestContext: any, authService: NhAuthService, translateService: TranslateService, cookieService: NhCookieService, commonModuleConfig: NhCommonModuleConfig);
+    ngOnDestroy(): Promise<void>;
+    initialize(): Promise<void>;
+    getInitialConfig(): NhCommonConfig;
+    private resolveInitialLanguageCode;
+    resetConfig(): void;
+    setConfig(config: NhCommonConfig): void;
+    getConfig(fromCache?: boolean): NhCommonConfig;
+    changeLanguage(newLanguageCode: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhConfigCommonService, [null, null, { optional: true; }, null, null, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhConfigCommonService>;
+}
+
+declare class NhJsonLdDataItem {
+    id: string;
+    data: any;
+    placeholderKeys: string[];
+    resolvePlaceholderKey: string | undefined;
+    constructor(init?: Partial<NhJsonLdDataItem>);
+}
+declare class NhJsonLdData {
+    items: NhJsonLdDataItem[];
+    constructor(init?: Partial<NhJsonLdData>);
+}
+declare class JsonLdDataChanged {
+    data: NhJsonLdData;
+    constructor(init?: Partial<JsonLdDataChanged>);
+}
+declare const REVIEW_AGGREGATE_RATING_KEY: (id: string | undefined) => string;
+declare const REVIEW_KEY: (id: string | undefined) => string;
+declare class NhJsonLdService {
+    private data;
+    readonly dataSubject: BehaviorSubject<JsonLdDataChanged>;
+    constructor();
+    getData(): NhJsonLdData;
+    private _addItem;
+    private _removeItem;
+    addItem(item: NhJsonLdDataItem): void;
+    removeItem(itemId: string): void;
+    clear(): void;
+    build(): any;
+    private _resolvePlaceholderKeys;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhJsonLdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhJsonLdService>;
+}
+
+declare class NhTitleService {
+    private titleService;
+    title: BehaviorSubject<string>;
+    constructor(titleService: Title);
+    setTitle(title: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhTitleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhTitleService>;
+}
+
+declare class NhRoute {
+    language: string;
+    path: string;
+    constructor(init?: Partial<NhRoute>);
+}
+declare class NhRegisterRoute {
+    id: string;
+    parentIds: string[] | undefined;
+    routes: NhRoute[];
+    children?: Routes;
+    loadChildren?: LoadChildren;
+    component?: Type<any>;
+    loadComponent?: () => Type<unknown> | Observable<Type<unknown> | DefaultExport<Type<unknown>>> | Promise<Type<unknown> | DefaultExport<Type<unknown>>>;
+    canActivate?: Array<CanActivateFn>;
+    canMatch?: Array<CanMatchFn>;
+    canActivateChild?: Array<CanActivateChildFn>;
+    redirectTo?: string | RedirectFunction;
+    pathMatch?: 'prefix' | 'full';
+    data?: Data;
+    excludeFromSitemap?: boolean;
+    constructor(init?: Partial<NhRegisterRoute>);
+}
+declare class NhRouteInfo {
+    id: string;
+    parentIds: string[] | undefined;
+    activeRoute: NhRoute;
+    routes: NhRoute[];
+    excludeFromSitemap?: boolean;
+    constructor(init?: Partial<NhRouteInfo>);
+}
+declare class NhRouteNavigationItem {
+    id: string;
+    path: string;
+    route: Route;
+    parent: NhRouteNavigationItem | undefined;
+    children: NhRouteNavigationItem[];
+    constructor(init?: Partial<NhRouteNavigationItem>);
+}
+declare class NhRouterSetupService {
+    private moduleConfig;
+    private translateService;
+    static readonly Nh_ROUTE_DATA_KEY = "__nh_route_data_key__";
+    private supportedLanguages;
+    private defaultLanguage;
+    private activeLanguage;
+    private lastKnownActivatedRoute;
+    private registeredRoutes;
+    private rootRouteNavigationItem;
+    constructor(moduleConfig: NhCommonModuleConfig, translateService: TranslateService);
+    getRootRouteNavigationItem(): NhRouteNavigationItem;
+    private getNormalizedNavigationItemId;
+    getRouteNavigationItem(nhRouterLink: NhRouterLink): NhRouteNavigationItem | undefined;
+    createUrlForNavigationItem(nhRouterLink: NhRouterLink): string;
+    setDefaultLanguage(language: string): void;
+    getDefaultLanguage(): string;
+    setSupportedLanguages(languages: string[]): void;
+    getRouteTranslationKey(path: string): string;
+    createRoute(options: NhRegisterRoute): Route[];
+    processRegisteredRoutes(): void;
+    static rootRoute(activatedRoute: ActivatedRoute): ActivatedRoute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhRouterSetupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhRouterSetupService>;
+}
+
+declare const NH_ROUTER_ROOT_ROUTES: InjectionToken<() => Routes>;
+declare const NH_ROUTER_LANGUAGE_CHANGE_METHOD: InjectionToken<(newLanguage: string) => Promise<void>>;
+declare class NhBreadCrumbItem {
+    text: string;
+    nhRouterLink?: NhRouterLink;
+    constructor(init?: Partial<NhBreadCrumbItem>);
+}
+declare class NhBreadCrumb {
+    renderedItems?: string;
+    items: NhBreadCrumbItem[];
+    constructor(init?: Partial<NhBreadCrumb>);
+}
+declare class NhSitemapEntryItem {
+    language: string;
+    isPrimary: boolean;
+    path: string;
+    constructor(init?: Partial<NhSitemapEntryItem>);
+}
+declare class NhSitemapEntry {
+    id: string;
+    items: NhSitemapEntryItem[];
+    constructor(init?: Partial<NhSitemapEntry>);
+}
+declare class NhSitemap {
+    entries: NhSitemapEntry[];
+    constructor(init?: Partial<NhSitemap>);
+}
+declare class NhRouterService {
+    private moduleConfig;
+    private translateService;
+    private routerSetupService;
+    private router;
+    private activatedRoute;
+    private getRootRoutes;
+    private changeLanguageMethod;
+    private requestContext;
+    private activeLanguage;
+    private lastKnownActivatedRoute;
+    constructor(moduleConfig: NhCommonModuleConfig, translateService: TranslateService, routerSetupService: NhRouterSetupService, router: Router, activatedRoute: ActivatedRoute, getRootRoutes: () => Routes, changeLanguageMethod: (newLanguage: string) => Promise<void>, requestContext: any);
+    redirectServer(location: string, statusCode?: number): void;
+    platformSpecificRedirect(location: NhRouterLink, statusCode?: number): void;
+    notFound(): void;
+    getActivatedNhLink(activatedRouteSnapshot: ActivatedRouteSnapshot): NhRouterLink;
+    createUrlForNavigationItem(nhRouterLink: NhRouterLink): string;
+    navigate(nhRouterLink: NhRouterLink, navigationExtras?: NavigationExtras): Promise<boolean>;
+    createUrlTree(nhRouterLink: NhRouterLink, navigationExtras?: UrlCreationOptions): UrlTree;
+    parseUrl(nhRouterLink: NhRouterLink, navigationExtras?: UrlCreationOptions): UrlTree;
+    serializeUrl(nhRouterLink: NhRouterLink, navigationExtras?: UrlCreationOptions): string;
+    getRoutePathForLanguage(activatedRouteSnapshot: ActivatedRouteSnapshot | null, language: string): Promise<string>;
+    navigateToLanguage(language: string): Promise<void>;
+    reloadRoutes(): void;
+    getBreadcrumb(activatedRouteSnapshot: ActivatedRouteSnapshot | null): Promise<NhBreadCrumb>;
+    createSitemap(): NhSitemap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhRouterService, [null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhRouterService>;
+}
+
+declare class NhMetaService {
+    private angularMetaService;
+    private _rendererFactory;
+    private _renderer;
+    constructor(angularMetaService: Meta, _rendererFactory: RendererFactory2);
+    addTag(tag: MetaDefinition, forceCreation?: boolean): HTMLMetaElement | null;
+    addTags(tags: MetaDefinition[], forceCreation?: boolean): HTMLMetaElement[];
+    getTag(attrSelector: string): HTMLMetaElement | null;
+    getTags(attrSelector: string): HTMLMetaElement[];
+    updateTag(tag: MetaDefinition, selector?: string): HTMLMetaElement | null;
+    removeTag(attrSelector: string): void;
+    removeTags(attrSelector: string): void;
+    removeTagElement(meta: HTMLMetaElement): void;
+    stripHtml(html: string): string;
+    private static processMetaTags;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhMetaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhMetaService>;
+}
+
+declare class NhPageSettings {
+    title: string;
+    description: string;
+    jsonLdData: NhJsonLdData;
+    breadCrumbOverrideText?: (currentText: string) => string;
+    pageData: any;
+    constructor(init?: Partial<NhPageSettings>);
+}
+declare class TypedNhPageSettings<TPageData> extends NhPageSettings {
+    pageData: TPageData | undefined;
+    constructor(init?: Partial<TypedNhPageSettings<TPageData>>);
+}
+declare class NhPageService implements OnDestroy {
+    private document;
+    private platformId;
+    private moduleConfig;
+    private appRef;
+    private nhAppService;
+    private configService;
+    private authService;
+    private translateService;
+    private titleService;
+    private metaService;
+    private jsonLdService;
+    private routerService;
+    private $appRefIsStable;
+    private $auth;
+    private authorization;
+    private $config;
+    private config;
+    activePageSettings: NhPageSettings;
+    private didRestoreTransferState;
+    readonly breadcrumbUpdateRequest: Subject<void>;
+    constructor(document: Document, platformId: Object, moduleConfig: NhCommonModuleConfig, appRef: ApplicationRef, nhAppService: NhAppService, configService: NhConfigCommonService, authService: NhAuthService, translateService: TranslateService, titleService: NhTitleService, metaService: NhMetaService, jsonLdService: NhJsonLdService, routerService: NhRouterService);
+    restoreTransferState(): void;
+    updateTransferState(): void;
+    isPlatformServer(): boolean;
+    isPlatformBrowser(): boolean;
+    isPlatformBrowserInitial(): boolean;
+    originatedFromServer(): boolean;
+    isAppStable(): boolean;
+    ngOnDestroy(): Promise<void>;
+    private authChanged;
+    private configChanged;
+    clear(): Promise<void>;
+    flushMeta(activePageSettings: NhPageSettings): Promise<void>;
+    setTitle(title: string): void;
+    setDescription(description: string): void;
+    setBreadcrumbOverrideText(breadcrumbOverrideText?: (currentText: string) => string): void;
+    requestBreadcrumbUpdate(): void;
+    getBreadcrumb(activatedRouteSnapshot: ActivatedRouteSnapshot | null): Promise<NhBreadCrumb>;
+    navigateTo(nhRouterLink: NhRouterLink, navigationExtras?: NavigationExtras): Promise<boolean>;
+    navigateTo404NotFound(navigationExtras?: NavigationExtras): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhPageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhPageService>;
+}
+
+declare class NhApiService implements OnDestroy {
+    private moduleConfig;
+    private httpClient;
+    private authService;
+    authSubscription: Subscription;
+    authorization: NhAuthorization | undefined;
+    baseUrl: string | undefined;
+    static ActiveDivisionHeaderKey: string;
+    private static defaultHeaders;
+    private static skipObjectParamParseKeys;
+    constructor(moduleConfig: NhCommonModuleConfig, httpClient: HttpClient, authService: NhAuthService);
+    private authChanged;
+    ngOnDestroy(): void;
+    static taskResultFromResponse(response: any): TaskResult<any>;
+    prepareHeaders(httpHeaders?: HttpHeaders): HttpHeaders;
+    setCultureHttpParam(httpParams?: HttpParams): HttpParams;
+    setObjectParams(httpParams: HttpParams, requestOptions?: HttpRequestOptions | HttpDownloadRequestOptions): HttpParams;
+    task<T>(observable$: Observable<T>): Promise<TaskResult<T>>;
+    get<T>(url: string, requestOptions?: IHttpRequestOptions): Observable<T>;
+    getText(url: string, requestOptions?: IHttpRequestOptions): Observable<string>;
+    getResult<T>(url: string, requestOptions?: IHttpRequestOptions): Promise<TaskResult<T>>;
+    getCollection<T>(url: string, requestOptions?: ICollectionHttpRequestOptions): Observable<CollectionHttpResponse<T>>;
+    getCollectionT<T, TRequestOptions extends ICollectionHttpRequestOptions, TCollectionResult extends CollectionHttpResponse<T>>(url: string, requestOptions?: TRequestOptions): Observable<TCollectionResult>;
+    getSimpleCollection<T>(url: string, requestOptions?: ISimpleCollectionHttpRequestOptions): Observable<SimpleCollectionHttpResponse<T>>;
+    getSimpleCollectionT<T, TRequestOptions extends ISimpleCollectionHttpRequestOptions, TCollectionResult extends SimpleCollectionHttpResponse<T>>(url: string, requestOptions?: TRequestOptions): Observable<TCollectionResult>;
+    download(url: string, requestOptions?: IHttpDownloadRequestOptions): Observable<Blob>;
+    downloadResponse(url: string, requestOptions?: IHttpDownloadRequestOptions): Observable<HttpResponse<Blob>>;
+    postDownload(url: string, body: any, requestOptions?: IHttpDownloadRequestOptions): Observable<Blob>;
+    postDownloadResponse(url: string, body: any, requestOptions?: IHttpDownloadRequestOptions): Observable<HttpResponse<Blob>>;
+    putDownload(url: string, body: any, requestOptions?: IHttpDownloadRequestOptions): Observable<Blob>;
+    putDownloadResponse(url: string, body: any, requestOptions?: IHttpDownloadRequestOptions): Observable<HttpResponse<Blob>>;
+    delete<T>(url: string, requestOptions?: IHttpRequestOptions): Observable<T>;
+    deleteResult<T>(url: string, requestOptions?: HttpRequestOptions): Promise<TaskResult<T>>;
+    deleteWithBody<T>(url: string, body: any, requestOptions?: IHttpRequestOptions): Observable<T>;
+    post<T>(url: string, body: any, requestOptions?: IHttpRequestOptions): Observable<T>;
+    postResult<T>(url: string, body: any, requestOptions?: IHttpRequestOptions): Promise<TaskResult<T>>;
+    put<T>(url: string, body: any, requestOptions?: IHttpRequestOptions): Observable<T>;
+    putResult<T>(url: string, body: any, requestOptions?: IHttpRequestOptions): Promise<TaskResult<T>>;
+    patch<T>(url: string, body: any, requestOptions?: IHttpRequestOptions): Observable<T>;
+    patchResult<T>(url: string, body: any, requestOptions?: IHttpRequestOptions): Promise<TaskResult<T>>;
+    postHttpEvent<T>(url: string, body: any, requestOptions?: IHttpRequestOptions): Observable<HttpEvent<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhApiService>;
+}
+
+declare class NhModalContentDirective {
+    viewContainerRef: ViewContainerRef;
+    constructor(viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhModalContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NhModalContentDirective, "[nhModalContent]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NhModalComponentClosed {
+    constructor(init?: Partial<NhModalComponentClosed>);
+}
+declare class NhModalComponentImpl<C> implements INhModalComponent<C>, OnChanges, OnInit, AfterContentInit, AfterViewInit, OnDestroy {
+    protected modalComponentRef: NhModalComponentRef<C> | undefined;
+    setModalComponentRef(ref: NhModalComponentRef<C>): void;
+    close(): void;
+    ngOnChanges(): void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    appOnChanges(): Promise<void>;
+    appOnInit(): Promise<void>;
+    appAfterContentInit(): Promise<void>;
+    appAfterViewInit(): Promise<void>;
+    appOnDestroy(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhModalComponentImpl<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NhModalComponentImpl<any>, never, never, {}, {}, never, never, true, never>;
+}
+declare class NhModalComponent<C> implements OnInit, OnDestroy, AfterViewInit {
+    readonly modalContent: i0.Signal<NhModalContentDirective>;
+    readonly modalHolder: i0.Signal<ElementRef<any>>;
+    readonly modalBackdrop: i0.Signal<ElementRef<any>>;
+    readonly modal: i0.Signal<ElementRef<any>>;
+    readonly closed: i0.OutputEmitterRef<NhModalComponentClosed>;
+    componentRef: ComponentRef<C> | undefined;
+    private modalComponentRef;
+    private document;
+    title: string;
+    modalHolderClasses: string;
+    modalClasses: string;
+    modalHeaderClasses: string;
+    modalBodyClasses: string;
+    isLoading: boolean;
+    closeable: boolean;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    setModalComponentRef(modalComponentRef: NhModalComponentRef<C>): void;
+    setContentComponent(componentType: Type<C>): void;
+    close(): void;
+    ngOnDestroy(): void;
+    modalSlideStart(event: MouseEvent): void;
+    modalTouchStart(event: TouchEvent): void;
+    modalTouchEnd(event: TouchEvent): void;
+    modalTouchMove(event: TouchEvent): void;
+    modalMouseUp(event: MouseEvent): void;
+    modalScrollStop(): void;
+    modalMouseMove(event: MouseEvent): void;
+    modalScrollMove(y: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhModalComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhModalComponent<any>, "nh-modal", never, {}, { "closed": "closed"; }, never, never, false, never>;
+}
+
+declare class NhModalConfirmComponent implements OnInit, INhModalComponent<NhModalConfirmComponent> {
+    message: string | SafeHtml;
+    btnConfirmText: string;
+    btnCancelText: string;
+    modalClass: '' | 'success' | 'danger' | 'warning' | 'info';
+    btnConfirmDisabled: boolean;
+    btnCancelDisabled: boolean;
+    allBtnsDisabled: boolean;
+    showLoader: boolean;
+    errorResult: TaskResult<any> | undefined;
+    readonly confirmed: i0.OutputEmitterRef<void>;
+    modalComponentRef: NhModalComponentRef<NhModalConfirmComponent> | undefined;
+    setModalComponentRef(ref: NhModalComponentRef<NhModalConfirmComponent>): void;
+    onKeyUp(event: KeyboardEvent): void;
+    ngOnInit(): void;
+    closeDialog(event?: any): void;
+    onConfirm: (() => void) | (() => Promise<void>);
+    onCancel: (() => void) | (() => Promise<void>);
+    readonly value: i0.InputSignal<any>;
+    confirm(): Promise<void>;
+    cancel(): Promise<void>;
+    executeDelegate(func: (() => void) | (() => Promise<void>)): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhModalConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhModalConfirmComponent, "nh-confirm-modal", never, { "message": { "alias": "message"; "required": false; }; "btnConfirmText": { "alias": "btnConfirmText"; "required": false; }; "btnCancelText": { "alias": "btnCancelText"; "required": false; }; "modalClass": { "alias": "modalClass"; "required": false; }; "btnConfirmDisabled": { "alias": "btnConfirmDisabled"; "required": false; }; "btnCancelDisabled": { "alias": "btnCancelDisabled"; "required": false; }; "allBtnsDisabled": { "alias": "allBtnsDisabled"; "required": false; }; "showLoader": { "alias": "showLoader"; "required": false; }; "errorResult": { "alias": "errorResult"; "required": false; }; "onConfirm": { "alias": "onConfirm"; "required": false; }; "onCancel": { "alias": "onCancel"; "required": false; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; }, never, never, false, never>;
+}
+
+interface INhModalComponent<C> {
+    setModalComponentRef(ref: NhModalComponentRef<C>): void;
+}
+declare class NhModalComponentRef<C> {
+    componentRef: ComponentRef<NhModalComponent<C>>;
+    readonly closed: EventEmitter<NhModalComponentClosed>;
+    private _onCloses;
+    onClose(callback: () => void): void;
+    close(): void;
+    get modalComponent(): NhModalComponent<C>;
+    get contentComponent(): C | undefined;
+    constructor(componentRef: ComponentRef<NhModalComponent<C>>);
+}
+declare class NhModalOptions {
+    title: string;
+    modalHolderClasses: string;
+    modalClasses: string;
+    modalHeaderClasses: string;
+    isLoading: boolean;
+    closeable: boolean;
+    modalBodyClasses: string;
+    viewContainerRef?: ViewContainerRef;
+    constructor(init?: Partial<NhModalOptions>);
+}
+declare class NhModalService {
+    private viewContainerRef;
+    modalRefs: NhModalComponentRef<any>[];
+    modalRefsOpen: BehaviorSubject<boolean>;
+    constructor();
+    setViewContainerRef(viewContainerRef: ViewContainerRef): void;
+    confirm(onConfirm: (() => void) | (() => Promise<any>), onClose?: (() => void), options?: NhModalOptions): NhModalComponentRef<NhModalConfirmComponent>;
+    confirmDialog(text: string, onConfirm: (() => void) | (() => Promise<any>), onClose?: (() => void), options?: NhModalOptions): NhModalComponentRef<NhModalConfirmComponent>;
+    /**
+     * Create a modal dialog with a given component as content
+     * @param componentType Type of the component to show in the modal
+     * @param options Options for the modal
+     * @param inputs Inputs to set on {@link componentType}
+     */
+    open<C extends INhModalComponent<C>>(componentType: Type<C>, options?: Partial<NhModalOptions>, inputs?: Record<string, any>): NhModalComponentRef<C>;
+    close(componentRef: NhModalComponentRef<any>): void;
+    closeLatest(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhModalService>;
+}
+
+declare class NhTaskResultFormValidationService {
+    validate(formGroup: UntypedFormGroup, errors: TaskResultItem[]): void;
+    addError(formGroup: UntypedFormGroup, controlName: string | undefined | null, errorMessages: string[]): void;
+    private getFormControlFromFormGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhTaskResultFormValidationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhTaskResultFormValidationService>;
+}
+
+declare class NhHeadService {
+    private document;
+    private renderer;
+    constructor(document: Document, rendererFactory: RendererFactory2);
+    addPreConnectUrl(url: PreConnectUrlItem): void;
+    addPreLoadUrl(url: PreLoadUrlItem): void;
+    addLinkTag(rel: string, href: string, withCrossOrigin?: boolean, crossOrigin?: string, additionalAttributes?: KeyValue<string, string>[]): void;
+    addElementToHead(element: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhHeadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhHeadService>;
+}
+
+declare class NhInternetConnectionService {
+    private zone;
+    private connectionSubject;
+    internetIsConnected: rxjs.Observable<boolean>;
+    constructor(zone: NgZone);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhInternetConnectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhInternetConnectionService>;
+}
+
+declare class NhServerService {
+    private platformId;
+    private moduleConfig;
+    private transferState;
+    private static readonly DID_INIT_BY_SERVER_STATE_KEY;
+    constructor(platformId: Object, moduleConfig: NhCommonModuleConfig, transferState: TransferState);
+    didInitByServer(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhServerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhServerService>;
+}
+
+interface IServerSideFormValidationService {
+}
+declare class NhServerSideFormValidationService implements IServerSideFormValidationService {
+    validate<T extends IServerSideFormValidator>(formValidatorType: {
+        new (): T;
+    }, formGroup: UntypedFormGroup, objectToValidate: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhServerSideFormValidationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhServerSideFormValidationService>;
+}
+interface IServerSideFormValidator {
+    getFormControlFromFormGroup(formGroup: UntypedFormGroup, formControlKey: string): UntypedFormControl;
+    validate(object: any): FormValidationResult;
+}
+declare class AspMvcFormServerSideFormValidator implements IServerSideFormValidator {
+    getFormControlFromFormGroup(formGroup: UntypedFormGroup, formControlKey: string): UntypedFormControl;
+    validate(object: any): FormValidationResult;
+}
+interface IFormValidationResult {
+}
+declare class FormValidationResult implements IFormValidationResult {
+    private formErrors;
+    getErrors(): Array<FormError>;
+    hasErrors(): boolean;
+    hasErrorForFieldName(fieldName: string): boolean;
+    getErrorForFieldName(fieldName: string): FormError | null;
+    addErrorByFieldName(fieldName: string, errorMessage: string): void;
+    constructor();
+}
+interface IFormError {
+}
+declare class FormError implements IFormError {
+    private fieldName;
+    private errorMessages;
+    getErrorMessages(): Array<string>;
+    getFieldName(): string;
+    addErrorMessage(errorMessage: string): void;
+    private setFieldName;
+    constructor(fieldName: string);
+}
+
+declare abstract class NhBaseApiService {
+    protected authService: NhAuthService;
+    protected moduleConfig: NhCommonModuleConfig;
+    protected apiService: NhApiService;
+    protected readonly baseUrl: string;
+    protected constructor(suffix: string);
+    getCollection<T>(options: CollectionHttpRequestOptions): Observable<CollectionHttpResponse<T>>;
+    get<T>(id: string, requestOptions?: HttpRequestOptions): Observable<T>;
+    create<T>(item: any, requestOptions?: HttpRequestOptions): Observable<T>;
+    update<T>(id: string, item: any, requestOptions?: HttpRequestOptions): Observable<T>;
+    updatePartial<T>(id: string, partialUpdate: any, requestOptions?: HttpRequestOptions): Observable<T>;
+    delete(id: string, requestOptions?: HttpRequestOptions): Observable<any>;
+}
+
+declare class NhUserNotificationService implements OnDestroy {
+    private appService;
+    protected readonly baseUrl: string;
+    protected authService: NhAuthService;
+    protected moduleConfig: NhCommonModuleConfig;
+    protected apiService: NhApiService;
+    protected runningSubject: BehaviorSubject<boolean>;
+    readonly isRunning$: Observable<boolean>;
+    private task$;
+    private taskSub;
+    private userNotificationState;
+    private readonly userNotificationStateSubject;
+    readonly userNotificationState$: Observable<NhUserNotificationState>;
+    get state(): NhUserNotificationState;
+    get urlSuffix(): string;
+    isRunning(): boolean;
+    ngOnDestroy(): void;
+    protected constructor(appService: NhAppService);
+    start(): void;
+    stop(): void;
+    protected doWork(): Promise<void>;
+    loadState(): Promise<void>;
+    protected getOverview(): Observable<NhUserNotificationOverview>;
+    getNotifications(requestOptions?: NhUserNotificationCollectionHttpRequestOptions): Observable<CollectionHttpResponse<NhUserNotification>>;
+    markAsRead(id: string): Observable<unknown>;
+    markAllAsRead(): Observable<unknown>;
+    archive(id: string): Observable<unknown>;
+    archiveAll(): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhUserNotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhUserNotificationService>;
+}
+
+declare class NhContextMenuItem {
+    type: 'item' | 'divider';
+    title: string;
+    onClick: (event: any) => Promise<void>;
+    constructor(init?: Partial<NhContextMenuItem>);
+}
+type NhContextEventWithCoordinates = {
+    clientX: number;
+    clientY: number;
+};
+declare class NhContextMenu {
+    x: number;
+    y: number;
+    items: NhContextMenuItem[];
+    static fromEvent(event?: NhContextEventWithCoordinates): NhContextMenu;
+    withItems(items: NhContextMenuItem[]): NhContextMenu;
+    constructor(init?: Partial<NhContextMenu>);
+}
+declare class NhContextMenuServiceConfig {
+    zIndex: number;
+    constructor(init?: Partial<NhContextMenuServiceConfig>);
+}
+declare class NhContextMenuService implements OnDestroy {
+    private platformId;
+    private readonly appService;
+    private readonly rendererFactory;
+    readonly config: NhContextMenuServiceConfig;
+    private renderer;
+    private contextMenuElement;
+    private unlistenHandles;
+    private globalListenCloseHandles;
+    constructor(platformId: Object, appService: NhAppService, rendererFactory: RendererFactory2);
+    ngOnDestroy(): void;
+    private handleClose;
+    private isOpen;
+    private getContainerElement;
+    private cleanupContextMenu;
+    open(contextMenu: NhContextMenu): void;
+    close(): void;
+    private addMenuItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhContextMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhContextMenuService>;
+}
+
+declare const NhIsAuthenticatedGuard: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => boolean;
+declare const NhIsOneClaimGrantedGuard: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => boolean;
+declare const NhIsOnePermissionGrantedGuard: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => boolean;
+declare const NhIsAllPermissionsGrantedGuard: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => boolean;
+declare const NhIsOneRoleGrantedGuard: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => boolean;
+declare const IsOneActiveDivisionPermissionGrantedGuard: () => boolean;
+declare const IsOneActiveDivisionRoleGrantedGuard: () => boolean;
+
+declare class NhUrlEncodePipe implements PipeTransform {
+    transform(value: string | undefined | null): string | undefined | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhUrlEncodePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NhUrlEncodePipe, "nhUrlEncode", false>;
+}
+
+declare class NhDatePipe implements PipeTransform {
+    private moduleConfig;
+    constructor(moduleConfig: NhCommonModuleConfig);
+    transform(value: any, pattern?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NhDatePipe, "nhDate", false>;
+}
+declare class NhDateTimePipe implements PipeTransform {
+    private moduleConfig;
+    constructor(moduleConfig: NhCommonModuleConfig);
+    transform(value: any, pattern?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhDateTimePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NhDateTimePipe, "nhDateTime", false>;
+}
+declare class NhDateUtcPipe implements PipeTransform {
+    private moduleConfig;
+    constructor(moduleConfig: NhCommonModuleConfig);
+    transform(value: any, pattern?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhDateUtcPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NhDateUtcPipe, "nhDateUtc", false>;
+}
+
+declare class IsOnePermissionGrantedPipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(permissions: Array<string>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsOnePermissionGrantedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsOnePermissionGrantedPipe, "isOnePermissionGranted", false>;
+}
+declare class IsAllPermissionsGrantedPipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(permissions: Array<string>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsAllPermissionsGrantedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsAllPermissionsGrantedPipe, "isAllPermissionsGranted", false>;
+}
+declare class IsGrantedRolePipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(roles: string | string[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsGrantedRolePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsGrantedRolePipe, "isGrantedRole", false>;
+}
+declare class IsAuthenticatedPipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsAuthenticatedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsAuthenticatedPipe, "isAuthenticated", false>;
+}
+declare class IsClaimGrantedPipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(claim: Claim): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsClaimGrantedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsClaimGrantedPipe, "isClaimGranted", false>;
+}
+declare class IsOneClaimGrantedPipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(claims: Array<Claim>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsOneClaimGrantedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsOneClaimGrantedPipe, "isOneClaimGranted", false>;
+}
+declare class IsOneRoleGrantedPipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(roles: Array<string>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsOneRoleGrantedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsOneRoleGrantedPipe, "isOneRoleGranted", false>;
+}
+declare class IsOneDivisionPermissionGrantedPipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(divisionId: string, permissions: Array<string>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsOneDivisionPermissionGrantedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsOneDivisionPermissionGrantedPipe, "isOneDivisionPermissionGranted", false>;
+}
+declare class IsOneDivisionRoleGrantedPipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(divisionId: string, roles: Array<string>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsOneDivisionRoleGrantedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsOneDivisionRoleGrantedPipe, "isOneDivisionRoleGranted", false>;
+}
+declare class IsOneActiveDivisionPermissionGrantedPipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(permissions: Array<string>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsOneActiveDivisionPermissionGrantedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsOneActiveDivisionPermissionGrantedPipe, "isOneActiveDivisionPermissionGranted", false>;
+}
+declare class IsOneActiveDivisionRoleGrantedPipe implements PipeTransform {
+    private authService;
+    constructor(authService: NhAuthService);
+    transform(roles: Array<string>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsOneActiveDivisionRoleGrantedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsOneActiveDivisionRoleGrantedPipe, "isOneActiveDivisionRoleGranted", false>;
+}
+
+declare class NhBooleanToStringPipe implements PipeTransform {
+    private translateService;
+    constructor(translateService: TranslateService);
+    transform(value: boolean | undefined): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhBooleanToStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NhBooleanToStringPipe, "nhBooleanToString", false>;
+}
+
+declare class SafeHtmlPipe implements PipeTransform {
+    private sanitized;
+    constructor(sanitized: DomSanitizer);
+    transform(value: string): _angular_platform_browser.SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", false>;
+}
+declare class SafeUrlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(value: string): _angular_platform_browser.SafeUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeUrlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeUrlPipe, "safeUrl", false>;
+}
+declare class SafeResourceUrlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(value: string): _angular_platform_browser.SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeResourceUrlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeResourceUrlPipe, "safeResourceUrl", false>;
+}
+
+declare class NhToHeadDirective implements OnInit, OnDestroy {
+    private _document;
+    private _renderer;
+    private _elementRef;
+    constructor(_document: Document, _renderer: Renderer2, _elementRef: ElementRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhToHeadDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NhToHeadDirective, "[nhToHead]", ["nhToHead"], {}, {}, never, never, false, never>;
+}
+
+declare class NhDebounceDirective implements OnInit, OnDestroy {
+    model: NgControl;
+    readonly onDebounce: i0.OutputEmitterRef<any>;
+    readonly preDebounce: i0.OutputEmitterRef<any>;
+    readonly debounceTime: i0.InputSignal<number>;
+    private isFirstChange;
+    private ngUnsubscribe;
+    constructor(model: NgControl);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhDebounceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NhDebounceDirective, "[ngModel][nhDebounce]", never, { "debounceTime": { "alias": "nhDebounce"; "required": false; "isSignal": true; }; }, { "onDebounce": "onDebounce"; "preDebounce": "preDebounce"; }, never, never, false, never>;
+}
+declare class NhButtonDebounceDirective implements OnInit, OnDestroy {
+    readonly onDebounce: i0.OutputEmitterRef<any>;
+    readonly debounceTime: i0.InputSignal<number>;
+    private clicks;
+    private subscription?;
+    constructor();
+    ngOnInit(): void;
+    clickEvent(event: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhButtonDebounceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NhButtonDebounceDirective, "[nhButtonDebounce]", never, { "debounceTime": { "alias": "debounce"; "required": false; "isSignal": true; }; }, { "onDebounce": "onDebounce"; }, never, never, false, never>;
+}
+
+declare class NhRouterLinkDirective implements OnInit {
+    private elementRef;
+    private renderer;
+    private hostRouterLink;
+    private router;
+    private routerService;
+    private translateService;
+    private changeLanguageMethod;
+    private _nhRouterLink;
+    private _resolvedNhRouterLink;
+    set nhRouterLink(nhRouterLink: NhRouterLink | undefined);
+    get nhRouterLink(): NhRouterLink | null | undefined;
+    constructor(elementRef: ElementRef, renderer: Renderer2, hostRouterLink: RouterLink, router: Router, routerService: NhRouterService, translateService: TranslateService, changeLanguageMethod: (newLanguage: string) => Promise<void>);
+    ngOnInit(): void;
+    private transformRouteLink;
+    /** @nodoc */
+    onClick(button: number, ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhRouterLinkDirective, [null, null, null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NhRouterLinkDirective, "[nhRouterLink]", ["nhRouterLink"], { "nhRouterLink": { "alias": "nhRouterLink"; "required": false; }; }, {}, never, never, false, [{ directive: typeof i1.RouterLink; inputs: { "target": "target"; "queryParams": "queryParams"; "fragment": "fragment"; "queryParamsHandling": "queryParamsHandling"; "state": "state"; "info": "info"; "relativeTo": "relativeTo"; "preserveFragment": "preserveFragment"; "skipLocationChange": "skipLocationChange"; "replaceUrl": "replaceUrl"; }; outputs: {}; }]>;
+}
+
+declare class NhLoaderComponent {
+    clicked: boolean;
+    active: boolean;
+    closed: boolean;
+    readonly dark: i0.InputSignal<boolean>;
+    readonly hasBackdrop: i0.InputSignal<boolean>;
+    readonly backdropTransparent: i0.InputSignal<boolean>;
+    private _containerClass;
+    set containerClass(value: string[] | string);
+    get containerClass(): string[] | string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhLoaderComponent, "nh-loader", never, { "dark": { "alias": "dark"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "backdropTransparent": { "alias": "backdropTransparent"; "required": false; "isSignal": true; }; "containerClass": { "alias": "containerClass"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Port of https://github.com/coryrylan/ngx-lite/blob/master/projects/ngx-json-ld/src/ngx-json-ld.component.ts
+ */
+declare class NhJsonLdComponent {
+    private _sanitizer;
+    set json(value: any);
+    private _jsonLD?;
+    constructor(_sanitizer: DomSanitizer);
+    private _getSafeHTML;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhJsonLdComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhJsonLdComponent, "nh-json-ld", never, { "json": { "alias": "json"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NhModalLoadingComponent implements INhModalComponent<NhModalLoadingComponent> {
+    readonly information: i0.InputSignal<string>;
+    modalComponentRef: NhModalComponentRef<NhModalLoadingComponent> | undefined;
+    setModalComponentRef(ref: NhModalComponentRef<NhModalLoadingComponent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhModalLoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhModalLoadingComponent, "nh-loading-modal", never, { "information": { "alias": "information"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare abstract class NhPageTypeBaseComponent<TAuthorization extends INhAuthorization, TAuthService extends BaseNhAuthService<TAuthorization>> implements OnChanges, OnInit, AfterContentInit, AfterViewInit, OnDestroy {
+    readonly QUERY_PARAM_KEY_PAGE = "p";
+    readonly QUERY_PARAM_KEY_ITEMS_PER_PAGE = "ipp";
+    readonly QUERY_PARAM_KEY_SEARCH_QUERY = "sq";
+    readonly QUERY_PARAM_KEY_ORDER_BY = "ob";
+    readonly QUERY_PARAM_KEY_VIEW = "vw";
+    protected get pageSettings(): NhPageSettings;
+    protected configService: NhConfigCommonService;
+    protected authService: TAuthService;
+    protected translateService: TranslateService;
+    protected pageService: NhPageService;
+    protected modalService: NhModalService;
+    protected nhRouterService: NhRouterService;
+    protected activatedRoute: ActivatedRoute;
+    protected document: Document;
+    protected platformId: Object;
+    protected router: Router;
+    private $routeChanged;
+    protected config: NhCommonConfig;
+    private $config;
+    protected authorization: NhAuthorization | undefined;
+    private $auth;
+    private $activeRouteParams;
+    protected activeRouteParams: Params;
+    private $activeRouteParamMap;
+    protected activeRouteParamMap?: ParamMap;
+    private $activeQueryParams;
+    protected activeQueryParams: Params;
+    private $activeQueryParamMap;
+    protected activeQueryParamMap?: ParamMap;
+    private $activeUrlFragment;
+    private activeUrlFragment;
+    private onInitDidRunOnce;
+    get pageData(): any;
+    constructor(authServiceType: Type<TAuthService>);
+    protected _getInitialPageData(): unknown;
+    isPlatformServer(): boolean;
+    isPlatformBrowser(): boolean;
+    originatedFromServer(): boolean;
+    isPlatformBrowserInitial(): boolean;
+    private configChanged;
+    private authChanged;
+    flushMeta(): Promise<void>;
+    ngOnInit(): Promise<void>;
+    ngOnChanges(): Promise<void>;
+    ngAfterContentInit(): Promise<void>;
+    ngAfterViewInit(): Promise<void>;
+    ngOnDestroy(): Promise<void>;
+    appOnInitAndLoad(): Promise<void>;
+    private _appOnInitAndLoadWithSkipBrowserInitial;
+    appOnInitAndLoadWithSkipBrowserInitial(): Promise<void>;
+    appOnChanges(): Promise<void>;
+    appOnInit(): Promise<void>;
+    appAfterContentInit(): Promise<void>;
+    appAfterViewInit(): Promise<void>;
+    appOnDestroy(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhPageTypeBaseComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhPageTypeBaseComponent<any, any>, "nh-page-base-component-type", never, {}, {}, never, never, false, never>;
+}
+declare abstract class NhPageBaseComponent extends NhPageTypeBaseComponent<NhAuthorization, NhAuthService> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhPageBaseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhPageBaseComponent, "nh-page-base-component", never, {}, {}, never, never, false, never>;
+}
+declare abstract class NhTypedPageTypeBaseComponent<TPageData, TAuthorization extends INhAuthorization, TAuthService extends BaseNhAuthService<TAuthorization>> extends NhPageTypeBaseComponent<TAuthorization, TAuthService> {
+    protected get pageSettings(): TypedNhPageSettings<TPageData>;
+    protected _getInitialPageData(): unknown;
+    protected abstract getInitialPageData(): TPageData | undefined;
+    get pageData(): TPageData | undefined;
+    constructor(authServiceType: Type<TAuthService>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhTypedPageTypeBaseComponent<any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhTypedPageTypeBaseComponent<any, any, any>, "nh-page-base-component-type-typed", never, {}, {}, never, never, false, never>;
+}
+declare abstract class NhTypedPageBaseComponent<TPageData> extends NhTypedPageTypeBaseComponent<TPageData, NhAuthorization, NhAuthService> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhTypedPageBaseComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhTypedPageBaseComponent<any>, "nh-page-base-component-typed", never, {}, {}, never, never, false, never>;
+}
+
+declare class DefaultMultiSelectSettings implements IMultiSelectSettings {
+    pullRight: boolean;
+    enableSearch: boolean;
+    checkedStyle: 'checkboxes' | 'glyphicon' | 'fontawesome' | 'visual';
+    buttonClasses: string;
+    selectionLimit: number;
+    closeOnSelect: boolean;
+    autoUnselect: boolean;
+    showCheckAll: boolean;
+    showUncheckAll: boolean;
+    fixedTitle: boolean;
+    dynamicTitleMaxItems: number;
+    maxHeight: string;
+    isLazyLoad: boolean;
+    loadViewDistance: number;
+    stopScrollPropagation: boolean;
+    selectAddedValues: boolean;
+    constructor(init?: Partial<DefaultMultiSelectSettings>);
+}
+declare class DefaultMultiSelectTexts implements IMultiSelectTexts {
+    checkAll: string;
+    uncheckAll: string;
+    checked: string;
+    checkedPlural: string;
+    searchPlaceholder: string;
+    searchEmptyResult: string;
+    searchNoRenderText: string;
+    defaultTitle: string;
+    allSelected: string;
+    constructor(init?: Partial<DefaultMultiSelectTexts>);
+}
+declare class NhFormDropDownSettings {
+    lazyLoad: boolean;
+    translateOptionValue: boolean;
+    multiSelectSettings: IMultiSelectSettings;
+    multiSelectTexts: IMultiSelectTexts;
+    requestOptions: CollectionHttpRequestOptions;
+    debounceTime: number;
+    selectedRequestOptions: CollectionHttpRequestOptions;
+    deferLazyLoadUntilOpened?: boolean;
+    loadLambda?: () => Observable<Array<any>>;
+    lazyLoadLambda?: (options: CollectionHttpRequestOptions) => Observable<CollectionHttpResponse<any>>;
+    selectedLazyLoadLambda?: (options: CollectionHttpRequestOptions, value?: any) => Observable<CollectionHttpResponse<any>>;
+    componentRef?: NhFormDropDownComponent;
+    keyGetLambda: (x: any) => any;
+    imageGetLambda: (x: any) => undefined;
+    valueGetLambda: (x: any) => any;
+    onSuccess: () => void;
+    constructor(init?: Partial<NhFormDropDownSettings>);
+}
+declare class NhFormDropDownComponent extends AbstractValueAccessor implements OnInit, OnDestroy {
+    private translate;
+    private cdr;
+    private commonModuleConfig?;
+    lazyLoadComponent?: NgxDropdownMultiselectComponent;
+    noLazyLoadComponent?: NgxDropdownMultiselectComponent;
+    defaultTexts: DefaultMultiSelectTexts;
+    isLoading: boolean;
+    hasMoreLazyLoadItems: boolean;
+    lastLazyLoadEvent: any;
+    hasFocus: boolean;
+    disabled: boolean;
+    onLazyLoadError: EventEmitter<any>;
+    private _settings;
+    readonly closed: i0.OutputEmitterRef<void>;
+    readonly opened: i0.OutputEmitterRef<void>;
+    get settings(): NhFormDropDownSettings;
+    set settings(value: NhFormDropDownSettings);
+    activeLazyLoadDataRequestSubscription: any;
+    activeLazyLoadSelectedDataRequestSubscription: any;
+    activeLoadRequestSubscription: Subscription | null;
+    options: IMultiSelectOption[];
+    rawOptions: any[];
+    private debounceObserver;
+    private debounceSubscription;
+    private readonly destroy$;
+    private hasOpenedDropdown;
+    private hasLoadedDeferredLazyLoadData;
+    private selectedLazyLoadValueKey?;
+    private selectedLazyLoadOptions;
+    private activeLazyLoadSelectedDataValueKey?;
+    private activeLazyLoadSelectedDataObservers;
+    private valueKey;
+    constructor(translate: TranslateService, cdr: ChangeDetectorRef, commonModuleConfig?: NhCommonModuleConfig | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getDropdownComponent(): NgxDropdownMultiselectComponent | undefined;
+    toggleDropdown(): void;
+    closeDropdown(): void;
+    writeValue(value: any): void;
+    onDropdownOpened(): void;
+    resetSearch(): void;
+    load(resetDeferredState?: boolean): void;
+    private get deferLazyLoadUntilOpened();
+    private cloneValue;
+    private getValueKey;
+    private resetSelectedLazyLoadCache;
+    private loadSelectedOptions;
+    lazyLoadSelectedData(): Observable<Array<IMultiSelectOption>>;
+    lazyLoadData(eventIn: any): void;
+    private processLazyLoadEvent;
+    onModelChange(event: any): void;
+    private handleLazyLoadResponse;
+    private selectedHandleLazyLoadResponse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhFormDropDownComponent, [null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhFormDropDownComponent, "nh-form-dropdown", never, { "disabled": { "alias": "disabled"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; }, { "onLazyLoadError": "onLazyLoadError"; "closed": "closed"; "opened": "opened"; }, never, never, false, never>;
+}
+
+declare class NhFormErrorMessageComponent implements OnInit {
+    control: UntypedFormControl | AbstractControl | undefined;
+    constructor();
+    ngOnInit(): void;
+    getErrors(): Array<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhFormErrorMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhFormErrorMessageComponent, "nh-form-error-message", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare abstract class NhCollectionTypeBaseComponent<TCollectionResponseItem, TAuthorization extends INhAuthorization, TAuthService extends BaseNhAuthService<TAuthorization>> implements OnChanges, OnInit, AfterContentInit, AfterViewInit, OnDestroy {
+    private readonly loadLock;
+    protected readonly appService: NhAppService;
+    protected readonly ColumnMode: typeof ColumnMode;
+    protected document: Document;
+    protected platformId: Object;
+    protected static readonly URL_QUERY_PARAM_KEY = "q";
+    protected authService: TAuthService;
+    protected modalService: NhModalService;
+    protected translateService: TranslateService;
+    protected toastrService: ToastrService;
+    protected router: Router;
+    protected activatedRoute: ActivatedRoute;
+    protected nhRouterService: NhRouterService;
+    tableInfo: any;
+    claimTypes: typeof ClaimTypes;
+    readonly queryParamUpdates: i0.ModelSignal<boolean>;
+    readonly localStorageUpdates: i0.ModelSignal<boolean>;
+    protected filtersActive: boolean;
+    protected isLoading: boolean;
+    protected requestOptions: CollectionHttpRequestOptions;
+    private activeRequestSubscription;
+    protected collectionResponse: CollectionHttpResponse<TCollectionResponseItem>;
+    private get localStorageKey();
+    get items(): TCollectionResponseItem[];
+    protected constructor(authServiceType: Type<TAuthService>);
+    abstract onLoad(requestOptions: CollectionHttpRequestOptions): Promise<Observable<CollectionHttpResponse<TCollectionResponseItem>>>;
+    abstract getInitialRequestOptions(): CollectionHttpRequestOptions;
+    abstract getLocalStoragePartialKey(): string | null;
+    beforeLoad(): Promise<void>;
+    afterLoad(): Promise<void>;
+    ngOnChanges(): void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    appOnChanges(): Promise<void>;
+    appOnInit(): Promise<void>;
+    appAfterContentInit(): Promise<void>;
+    appAfterViewInit(): Promise<void>;
+    appOnDestroy(): Promise<void>;
+    initCollectionRequestModel(): void;
+    private syncRequestOptionsToTableInfo;
+    updateRequestOptions(): void;
+    resetRequestOptionsAndLoad(): void;
+    resetRequestOptions(): void;
+    load(): Promise<CollectionHttpResponse<TCollectionResponseItem>>;
+    search(search: string): Promise<void>;
+    sort(event: any): Promise<void>;
+    setPageByOffsetLimit(event: {
+        offset: number;
+        limit: number;
+    }): Promise<void>;
+    setPage(event: {
+        page: number;
+        itemsPerPage: number;
+    }): Promise<void>;
+    firstPage(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhCollectionTypeBaseComponent<any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhCollectionTypeBaseComponent<any, any, any>, "nh-shared-collection-base-component", never, { "queryParamUpdates": { "alias": "queryParamUpdates"; "required": false; "isSignal": true; }; "localStorageUpdates": { "alias": "localStorageUpdates"; "required": false; "isSignal": true; }; }, { "queryParamUpdates": "queryParamUpdatesChange"; "localStorageUpdates": "localStorageUpdatesChange"; }, never, never, false, never>;
+}
+declare abstract class NhCollectionBaseComponent<TCollectionResponseItem> extends NhCollectionTypeBaseComponent<TCollectionResponseItem, NhAuthorization, NhAuthService> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhCollectionBaseComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhCollectionBaseComponent<any>, "nh-shared-collection-type-base-component", never, {}, {}, never, never, false, never>;
+}
+
+declare enum MutationType {
+    Create = 0,
+    Update = 1
+}
+declare abstract class NhMutateBaseTypeComponent<TFormData, TResult, TAuthorization extends INhAuthorization, TAuthService extends BaseNhAuthService<TAuthorization>> implements OnChanges, OnInit, AfterContentInit, AfterViewInit, OnDestroy {
+    protected authService: TAuthService;
+    protected translateService: TranslateService;
+    protected toastrService: ToastrService;
+    protected activatedRoute: ActivatedRoute;
+    protected nhRouterService: NhRouterService;
+    protected formValidator: NhServerSideFormValidationService;
+    protected taskResultFormValidator: NhTaskResultFormValidationService;
+    claimTypes: typeof ClaimTypes;
+    private _isLoading;
+    private _isSubmitting;
+    private _mutationType;
+    private _formData;
+    get isLoading(): boolean;
+    protected set isLoading(value: boolean);
+    get isSubmitting(): boolean;
+    protected set isSubmitting(value: boolean);
+    protected get isLoadingOrSubmitting(): boolean;
+    get mutationType(): MutationType;
+    protected set mutationType(value: MutationType);
+    get formData(): TFormData | undefined;
+    protected set formData(value: TFormData | undefined);
+    form: any | undefined;
+    created: EventEmitter<TResult>;
+    updated: EventEmitter<TResult>;
+    protected constructor(authServiceType: Type<TAuthService>);
+    abstract onNewFormData(mutationType: MutationType): Promise<TFormData>;
+    abstract onSubmitCreate(event: any): Promise<TaskResult<TResult>>;
+    abstract onSubmitUpdate(event: any): Promise<TaskResult<TResult>>;
+    ngOnChanges(): void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    appOnChanges(): Promise<void>;
+    appOnInit(): Promise<void>;
+    appAfterContentInit(): Promise<void>;
+    appAfterViewInit(): Promise<void>;
+    appOnDestroy(): Promise<void>;
+    newFormData(mutationType: MutationType): Promise<void>;
+    submit(event: any, handleAll?: boolean): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhMutateBaseTypeComponent<any, any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhMutateBaseTypeComponent<any, any, any, any>, "nh-mutate-base-type-component", never, {}, { "created": "created"; "updated": "updated"; }, never, never, false, never>;
+}
+declare abstract class NhMutateBaseComponent<TFormData, TResult> extends NhMutateBaseTypeComponent<TFormData, TResult, NhAuthorization, NhAuthService> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhMutateBaseComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhMutateBaseComponent<any, any>, "nh-mutate-base-component", never, {}, {}, never, never, false, never>;
+}
+
+declare abstract class NhModalMutateBaseTypeComponent<TFormData, TResult, TAuthorization extends INhAuthorization, TAuthService extends BaseNhAuthService<TAuthorization>> extends NhMutateBaseTypeComponent<TFormData, TResult, TAuthorization, TAuthService> implements OnInit, OnDestroy, INhModalComponent<NhModalMutateBaseTypeComponent<TFormData, TResult, TAuthorization, TAuthService>> {
+    protected modalComponentRef: NhModalComponentRef<NhModalMutateBaseTypeComponent<TFormData, TResult, TAuthorization, TAuthService>> | undefined;
+    protected modalService: NhModalService;
+    setModalComponentRef(ref: NhModalComponentRef<NhModalMutateBaseTypeComponent<TFormData, TResult, TAuthorization, TAuthService>>): void;
+    protected constructor(authServiceType: Type<TAuthService>);
+    onKeyUp(event: KeyboardEvent): void;
+    closeDialog(event?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhModalMutateBaseTypeComponent<any, any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhModalMutateBaseTypeComponent<any, any, any, any>, "nh-modal-mutate-base-type-component", never, {}, {}, never, never, false, never>;
+}
+declare abstract class NhModalMutateBaseComponent<TFormData, TResult> extends NhModalMutateBaseTypeComponent<TFormData, TResult, NhAuthorization, NhAuthService> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhModalMutateBaseComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhModalMutateBaseComponent<any, any>, "nh-modal-mutate-base-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class NhErrorComponent {
+    key: i0.InputSignal<string | undefined>;
+    errors: i0.InputSignal<TaskResult<any> | undefined>;
+    get displayErrors(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhErrorComponent, "nh-error", never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; "errors": { "alias": "errors"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare abstract class NhUserNotificationsAbstractComponent extends NhCollectionBaseComponent<NhUserNotification> implements OnInit, OnDestroy {
+    allowStart: boolean;
+    allowStop: boolean;
+    itemsPerPage: number;
+    autoLoadNotificationChanges: boolean;
+    protected readonly userNotificationService: NhUserNotificationService;
+    protected readonly moduleConfig: NhCommonModuleConfig;
+    readonly partialLocalStorageKey: i0.InputSignal<string>;
+    requestOptions: NhUserNotificationCollectionHttpRequestOptions;
+    userNotificationState: NhUserNotificationState;
+    private lastNotificationDate;
+    private lastNotificationCount;
+    private lastUnreadNotificationCount;
+    protected userNotificationSubscription: rxjs.Subscription;
+    constructor();
+    protected onNewNotificationsAvailable(state: NhUserNotificationState): Promise<void>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getInitialRequestOptions(): NhUserNotificationCollectionHttpRequestOptions;
+    getLocalStoragePartialKey(): string | null;
+    onLoad(requestOptions: NhUserNotificationCollectionHttpRequestOptions): Promise<Observable<CollectionHttpResponse<NhUserNotification>>>;
+    afterLoad(): Promise<void>;
+    reload(): Promise<void>;
+    markAsRead(notification: NhUserNotification): Promise<TaskResult<unknown>>;
+    markAllAsRead(): Promise<TaskResult<unknown>>;
+    archive(notification: NhUserNotification): Promise<TaskResult<unknown>>;
+    archiveAll(): Promise<TaskResult<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhUserNotificationsAbstractComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhUserNotificationsAbstractComponent, "nh-user-notifications-abstract", never, { "allowStart": { "alias": "allowStart"; "required": false; }; "allowStop": { "alias": "allowStop"; "required": false; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; }; "autoLoadNotificationChanges": { "alias": "autoLoadNotificationChanges"; "required": false; }; "partialLocalStorageKey": { "alias": "partialLocalStorageKey"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class NhSearchInputComponent {
+    value: string | undefined;
+    onDebounce: EventEmitter<string>;
+    open: boolean;
+    searchInput?: ElementRef<HTMLInputElement>;
+    focusInput(): void;
+    onDebounceEvent(val: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhSearchInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhSearchInputComponent, "nh-search-input", never, { "value": { "alias": "value"; "required": false; }; }, { "onDebounce": "onDebounce"; }, never, never, false, never>;
+}
+
+declare class NhPageSizeComponent extends AbstractValueAccessor {
+    isDisabled: boolean;
+    name: string;
+    pageSizeDropDownSettings: NhFormDropDownSettings;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhPageSizeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NhPageSizeComponent, "nh-page-size", never, { "name": { "alias": "name"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NhCommonModule {
+    constructor(parentModule: NhCommonModule);
+    static forRoot<TAuthorization extends INhAuthorization, TAuthService extends BaseNhAuthService<TAuthorization>>(config: NhCommonModuleConfig, authService: Type<TAuthService>): ModuleWithProviders<NhCommonModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhCommonModule, [{ optional: true; skipSelf: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NhCommonModule, [typeof NhModalComponent, typeof NhLoaderComponent, typeof NhJsonLdComponent, typeof NhModalLoadingComponent, typeof NhModalConfirmComponent, typeof NhFormDropDownComponent, typeof NhFormErrorMessageComponent, typeof NhErrorComponent, typeof NhPageSizeComponent, typeof NhSearchInputComponent, typeof NhDatePipe, typeof NhDateTimePipe, typeof NhDateUtcPipe, typeof NhBooleanToStringPipe, typeof IsAuthenticatedPipe, typeof IsAllPermissionsGrantedPipe, typeof IsOnePermissionGrantedPipe, typeof IsClaimGrantedPipe, typeof IsOneClaimGrantedPipe, typeof IsOneRoleGrantedPipe, typeof IsGrantedRolePipe, typeof IsOneDivisionPermissionGrantedPipe, typeof IsOneDivisionRoleGrantedPipe, typeof IsOneActiveDivisionPermissionGrantedPipe, typeof IsOneActiveDivisionRoleGrantedPipe, typeof NhUrlEncodePipe, typeof SafeHtmlPipe, typeof SafeUrlPipe, typeof SafeResourceUrlPipe, typeof NhToHeadDirective, typeof NhDebounceDirective, typeof NhButtonDebounceDirective, typeof NhModalContentDirective, typeof NhRouterLinkDirective], [typeof i20.CommonModule, typeof i21.TranslateModule, typeof i22.NgxBootstrapMultiselectModule, typeof i23.FormsModule], [typeof NhModalComponent, typeof NhLoaderComponent, typeof NhJsonLdComponent, typeof NhModalLoadingComponent, typeof NhModalConfirmComponent, typeof NhFormDropDownComponent, typeof NhFormErrorMessageComponent, typeof NhErrorComponent, typeof NhPageSizeComponent, typeof NhSearchInputComponent, typeof NhDatePipe, typeof NhDateTimePipe, typeof NhDateUtcPipe, typeof NhBooleanToStringPipe, typeof IsAuthenticatedPipe, typeof IsAllPermissionsGrantedPipe, typeof IsOnePermissionGrantedPipe, typeof IsClaimGrantedPipe, typeof IsOneClaimGrantedPipe, typeof IsOneRoleGrantedPipe, typeof IsOneDivisionPermissionGrantedPipe, typeof IsOneDivisionRoleGrantedPipe, typeof IsOneActiveDivisionPermissionGrantedPipe, typeof IsOneActiveDivisionRoleGrantedPipe, typeof IsGrantedRolePipe, typeof NhUrlEncodePipe, typeof SafeHtmlPipe, typeof SafeUrlPipe, typeof SafeResourceUrlPipe, typeof NhToHeadDirective, typeof NhDebounceDirective, typeof NhButtonDebounceDirective, typeof NhModalContentDirective, typeof NhRouterLinkDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NhCommonModule>;
+}
+
+declare class NhCanCancelNavigationGuard implements CanDeactivate<ICancelNavigationComponent> {
+    canDeactivate(component: ICancelNavigationComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState: RouterStateSnapshot): MaybeAsync<GuardResult>;
+}
+interface ICancelNavigationComponent {
+    canDeactivateComponent(): boolean | Promise<boolean> | Observable<boolean>;
+}
+
+declare global {
+    interface Array<T> {
+        any(): boolean;
+        firstOrDefault(): any;
+        lastOrDefault(): any;
+    }
+}
+
+declare module "rxjs/internal/Observable" {
+    interface Observable<T> {
+        lastValueFrom(): Promise<T>;
+        taskResultLastValueFrom(): Promise<TaskResult<T>>;
+        typedResultLastValueFrom(): Promise<TypedResult<T>>;
+    }
+}
+
+declare class NhTranslateBrowserLoader implements TranslateLoader {
+    private http;
+    private transferState;
+    protected moduleConfig: NhCommonModuleConfig;
+    protected static readonly httpRequestOptions: HttpRequestOptions;
+    constructor(http: HttpClient, transferState: TransferState);
+    getTranslation(lang: string): Observable<any>;
+}
+declare function nhTranslateBrowserLoaderFactory(httpClient: HttpClient, transferState: TransferState): NhTranslateBrowserLoader;
+
+export { AbstractValueAccessor, AspMvcFormServerSideFormValidator, AuthSessionExpirationInformation, AuthenticateModel, AuthenticationNhCommonModuleConfig, AuthenticationSessionCreateResponse, BaseNhAuthService, CheckAuthenticateSessionModel, Claim, ClaimAuthenticateSessionAccountMutateModel, ClaimAuthenticateSessionAccountViewModel, ClaimTypes, CollectionHttpRequestOptions, CollectionHttpResponse, DefaultMultiSelectSettings, DefaultMultiSelectTexts, EndpointsAuthenticationNhCommonModuleConfig, FilterRequestOptions, FormError, FormValidationResult, HttpDownloadRequestOptions, HttpRequestOptions, HttpRequestOptionsArrayBuffer, HttpRequestOptionsText, ImpersonateAuthenticateModel, IsAllPermissionsGrantedPipe, IsAuthenticatedPipe, IsClaimGrantedPipe, IsDefined, IsGrantedRolePipe, IsOneActiveDivisionPermissionGrantedGuard, IsOneActiveDivisionPermissionGrantedPipe, IsOneActiveDivisionRoleGrantedGuard, IsOneActiveDivisionRoleGrantedPipe, IsOneClaimGrantedPipe, IsOneDivisionPermissionGrantedPipe, IsOneDivisionRoleGrantedPipe, IsOnePermissionGrantedPipe, IsOneRoleGrantedPipe, JsonLdDataChanged, ListSortDirection, MakeProvider, MutationType, NH_ERROR_HANDLERS, NH_ROUTER_LANGUAGE_CHANGE_METHOD, NH_ROUTER_ROOT_ROUTES, NH_SENTRY_BEFORE_BREADCRUMB_HOOKS, NH_SENTRY_BEFORE_SEND_HOOKS, NH_SENTRY_BEFORE_SEND_LOG_HOOKS, NH_SENTRY_BEFORE_SEND_SPAN_HOOKS, NH_SENTRY_BEFORE_SEND_TRANSACTION_HOOKS, NhAccountInformationResponse, NhAngularUtil, NhApiService, NhApiUtil, NhAppService, NhAsyncLock, NhAuthService, NhAuthorization, NhBaseApiService, NhBooleanToStringPipe, NhBreadCrumb, NhBreadCrumbItem, NhButtonDebounceDirective, NhCanCancelNavigationGuard, NhCollectionBaseComponent, NhCollectionTypeBaseComponent, NhCommonConfig, NhCommonConfigChanged, NhCommonModule, NhCommonModuleConfig, NhConfigCommonService, NhContextMenu, NhContextMenuItem, NhContextMenuService, NhContextMenuServiceConfig, NhCookieService, NhDatePipe, NhDateTimePipe, NhDateUtcPipe, NhDebounceDirective, NhDeduplicateGetRequestsInterceptor, NhDivision, NhDivisionRole, NhDivisionUser, NhEncodeHttpParamsInterceptor, NhEncodingUtil, NhErrorComponent, NhErrorHandlerSentryService, NhErrorHandlerService, NhErrorLoggingNhCommonModuleConfig, NhFormDropDownComponent, NhFormDropDownNhCommonModuleConfig, NhFormDropDownSettings, NhFormErrorMessageComponent, NhFormHelper, NhHeadService, NhHttpNhCommonModuleConfig, NhHttpUtil, NhInternetConnectionService, NhIsAllPermissionsGrantedGuard, NhIsAuthenticatedGuard, NhIsOneClaimGrantedGuard, NhIsOnePermissionGrantedGuard, NhIsOneRoleGrantedGuard, NhJsonLdComponent, NhJsonLdData, NhJsonLdDataItem, NhJsonLdService, NhLoaderComponent, NhMetaService, NhModalComponent, NhModalComponentClosed, NhModalComponentImpl, NhModalComponentRef, NhModalConfirmComponent, NhModalContentDirective, NhModalLoadingComponent, NhModalMutateBaseComponent, NhModalMutateBaseTypeComponent, NhModalOptions, NhModalService, NhMutateBaseComponent, NhMutateBaseTypeComponent, NhMutex, NhPageBaseComponent, NhPageService, NhPageSettings, NhPageSizeComponent, NhPageTypeBaseComponent, NhRegisterRoute, NhRequestScopedServerHttpInterceptorService, NhRoute, NhRouteInfo, NhRouteNavigationItem, NhRouterLinkDirective, NhRouterService, NhRouterSetupService, NhSearchInputComponent, NhSentryErrorLoggingNhCommonModuleConfig, NhSentryInitializerService, NhSentryService, NhSentryTraceService, NhServerHttpInterceptor, NhServerService, NhServerSideFormValidationService, NhSitemap, NhSitemapEntry, NhSitemapEntryItem, NhStringUtil, NhTaskResultFormValidationService, NhTitleService, NhToHeadDirective, NhTranslateBrowserLoader, NhTranslationNhCommonModuleConfig, NhTypedPageBaseComponent, NhTypedPageTypeBaseComponent, NhUrlEncodePipe, NhUser, NhUserNotification, NhUserNotificationCollectionHttpRequestOptions, NhUserNotificationData, NhUserNotificationMessage, NhUserNotificationOverview, NhUserNotificationService, NhUserNotificationState, NhUserNotificationsAbstractComponent, OrderByRequestOptions, PreConnectUrlItem, PreLoadUrlItem, REVIEW_AGGREGATE_RATING_KEY, REVIEW_KEY, RefreshTokenLoginAccountMutateModel, RevertImpersonateAuthenticateModel, SafeHtmlPipe, SafeResourceUrlPipe, SafeUrlPipe, SearchableCollectionHttpRequestOptions, SimpleCollectionHttpRequestOptions, SimpleCollectionHttpResponse, TaskResult, TaskResultItem, TypedNhPageSettings, UserNotificationNhCommonModuleConfig, enumIntValuesToArray, enumKeysToArray, enumStringValuesToArray, enumValuesToArray, getEmptyGuid, getRandomIdentifier, groupBy, languageToCultureMap, nameof, nhTranslateBrowserLoaderFactory, uppercaseFirst };
+export type { AuthenticationFlow, ErrorResult, ICancelNavigationComponent, IClaimAuthenticateSessionAccountViewModel, ICollectionHttpRequestOptions, ICollectionHttpResponse, IFormError, IFormValidationResult, IHttpDownloadRequestOptions, IHttpRequestOptions, INhAccountInformationResponse, INhAuthorization, INhDivision, INhDivisionRole, INhDivisionUser, INhModalComponent, INhUser, ISearchableCollectionHttpRequestOptions, IServerSideFormValidationService, IServerSideFormValidator, ISimpleCollectionHttpRequestOptions, ISimpleCollectionHttpResponse, NhContextEventWithCoordinates, NhEnumDropDownItem, NhRouterLink, NhSentryBeforeBreadcrumbHook, NhSentryBeforeSendHook, NhSentryBeforeSendLogHook, NhSentryBeforeSendSpanHook, NhSentryBeforeSendTransactionHook, SuccessResult, TypedResult };