@mediusinc/mng-commons 5.0.0-rc.0-c31d5206 → 5.0.0-rc.1

package/core/helpers/route.d.ts

@@ -0,0 +1,35 @@
+import { MenuItem as PrimeMenuItem } from 'primeng/api';
+import { CommonsMenuItem } from '../models/menu.model';
+export declare function removeRouteEmptyPathSegments(path: Array<string>): string[];
+export declare function appendRoutePathToBasePath(basePath: Array<string>, path: Array<string>): string[];
+export declare function doesUrlMatchRouterLink(link: Array<string> | string, url: Array<string> | string): boolean;
+export declare function adjustRouteMenuLazyChildrenRouterLinks(rootMenuItem: PrimeMenuItem, lazyChildren: Array<CommonsMenuItem>): {
+    index?: number | undefined;
+    key?: string | undefined;
+    id?: string | undefined;
+    positionIndex?: number | undefined;
+    label?: string | undefined;
+    icon?: string | undefined;
+    items?: CommonsMenuItem[] | undefined;
+    guards?: any[] | undefined;
+    permissions?: import("@mediusinc/mng-commons/core").APermissions | undefined;
+    separator?: boolean | undefined;
+    className?: string | undefined;
+    badge?: string | undefined;
+    badgeClassName?: string | undefined;
+    visible?: boolean | undefined;
+    disabled?: boolean | undefined;
+    routerLink?: string | string[] | null | undefined;
+    href?: string | undefined;
+    target?: string | undefined;
+    queryParams?: {
+        [k: string]: any;
+    } | undefined;
+    fragment?: string | undefined;
+    queryParamsHandling?: import("@angular/router").QueryParamsHandling | undefined;
+    preserveFragment?: boolean | undefined;
+    skipLocationChange?: boolean | undefined;
+    replaceUrl?: boolean | undefined;
+    updated?: boolean | undefined;
+    lazyChildren?: boolean | undefined;
+}[];

package/core/helpers/string.d.ts

@@ -0,0 +1,7 @@
+export declare function escapeHtml(value: string): any;
+export declare function escapeHtmlAny(value?: any): any;
+/**
+ * Stringifies a value - primitives with toString, dates with dateUtil, objects with JSON.stringify.
+ * @param value Any value.
+ */
+export declare function stringify(value: any): string;

package/core/helpers/templates.d.ts

@@ -0,0 +1,3 @@
+import { TemplateRef } from '@angular/core';
+import { TemplateDirective } from '../directives/template.directive';
+export declare function findTemplateByName(templates: TemplateDirective[], name: string): TemplateRef<any> | null;

package/core/helpers/type-helpers.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+export type KeyOfType = string | number | symbol;
+export type Nullable<T> = T | null | undefined;
+export type ObjectOptPropType<OT, P extends keyof OT, PT> = P extends keyof OT ? (OT[P] extends Nullable<PT> ? P : never) : never;
+export type KeyofAndOfType<Type, PropertyType> = {
+    [K in keyof Type]: NonNullable<Type[K]> extends NonNullable<PropertyType> ? K : never;
+}[keyof Type];
+export type ArrayItemType<T> = NonNullable<T> extends Array<infer U> ? U : T;
+export type IdType = number | string;
+export type PrimitiveType = string | boolean | number;
+export type PropertyType = PrimitiveType | Date | EnumType;
+export type ItemOrObservable<T> = T | Observable<T>;
+export type EnumConstantType = string | number;
+export interface EnumType<V = EnumConstantType> {
+    [key: string]: V;
+}

package/core/i18n/i18n-common.d.ts

@@ -0,0 +1,6 @@
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+export declare function getI18nAsync(translate: TranslateService, params?: any, ...keys: Array<string>): Observable<string | null>;
+export declare function getI18n(translate: TranslateService, params?: any, ...keys: Array<string>): string | null;
+export declare function populateI18nParams(item?: any, params?: any): any;
+export declare function selectI18n(keys: string[], i18n: any): string | null;

package/core/i18n/i18n-error.d.ts

@@ -0,0 +1,4 @@
+import { TranslateService } from '@ngx-translate/core';
+import { ICommonsError } from '../error/error.model';
+export declare function getI18nForError(translate: TranslateService, error: ICommonsError, params?: any): string | null;
+export declare function getI18nErrorParams(error: ICommonsError, params?: any): any;

package/core/i18n/i18n-type.d.ts

@@ -0,0 +1,20 @@
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { ClassType } from '../models/class-service.model';
+export declare function getI18nClassNameAsync(translate: TranslateService, classType: ClassType<any>, singular?: boolean): Observable<string | null>;
+export declare function getI18nClassName(translate: TranslateService, classType: ClassType<any>, singular?: boolean): string | null;
+export declare function getI18nTypeNameAsync(translate: TranslateService, typeName: string, singular?: boolean): Observable<string | null>;
+export declare function getI18nTypeName(translate: TranslateService, typeName: string, singular?: boolean): string | null;
+export declare function getI18nClassTabKey(classType: ClassType<any>, tab: string): string;
+export declare function getI18nTypeTabKey(typeName: string, tab: string): string;
+export declare function getI18nClassGroupKey(classType: ClassType<any>, group: string): string;
+export declare function getI18nTypeGroupKey(typeName: string, group: string): string;
+export declare function getI18nClassPropertyKey(classType: ClassType<any>, property: string): string;
+export declare function getI18nTypePropertyKey(typeName: string, property: string): string;
+export declare function getI18nClassKeyBasePath(classType: ClassType<any>, ...path: Array<string>): string;
+export declare function getI18nTypeKeyBasePath(typeName: string, ...path: Array<string>): string;
+export declare function getI18nClassParams(translate: TranslateService, classType: ClassType<any>, item: any, params?: any): any;
+export declare function getI18nTypeParams(translate: TranslateService, typeName?: string, item?: any, params?: any): any;
+export declare function getI18nClassParamsAsync(translate: TranslateService, classType: ClassType<any>, item?: any, params?: any): Observable<any>;
+export declare function getI18nTypeParamsAsync(translate: TranslateService, typeName?: string, item?: any, params?: any): Observable<any>;
+export declare function populateI18nTypeParams(i18nTypeName?: string, item?: any, params?: any): any;

package/core/index.d.ts

@@ -0,0 +1,83 @@
+export * from './action/action-data.model';
+export * from './action/action-parameters.model';
+export * from './components/notification/notification-wrapper.component';
+export * from './components/pages/error/error.page.component';
+export * from './components/pages/not-found/not-found.page.component';
+export * from './data-list/data-list.model';
+export * from './data-list/data-list-params-helpers';
+export * from './data-list/filter-match.model';
+export * from './data-providers/base.data-provider';
+export * from './data-providers/lookup.data-provider';
+export * from './descriptors/action.descriptor';
+export * from './descriptors/column.descriptor';
+export * from './descriptors/editor.descriptor';
+export * from './descriptors/enum.descriptor';
+export * from './descriptors/filter.descriptor';
+export * from './descriptors/lookup.descriptor';
+export * from './descriptors/model.descriptor';
+export * from './descriptors/table.descriptor';
+export * from './descriptors/tableview.descriptor';
+export * from './directives/component.directive';
+export * from './directives/dialog-keydown-handler.directive';
+export * from './directives/template.directive';
+export * from './enum/enum.model';
+export * from './enum/enum-helpers';
+export * from './error/error.model';
+export * from './error/error-handler';
+export * from './error/error-helpers';
+export * from './helpers/coercion';
+export * from './helpers/date';
+export * from './helpers/notification';
+export * from './helpers/object';
+export * from './helpers/route';
+export * from './helpers/string';
+export * from './helpers/type-helpers';
+export * from './helpers/templates';
+export * from './i18n/i18n-common';
+export * from './i18n/i18n-error';
+export * from './i18n/i18n-type';
+export * from './log/log.model';
+export * from './log/log-publisher-console.service';
+export * from './log/logger.service';
+export * from './models/class-attribute.model';
+export * from './models/class-service.model';
+export * from './models/getter.model';
+export * from './models/i18n.model';
+export * from './models/menu.model';
+export * from './models/user.model';
+export * from './models/version.model';
+export * from './pipes/boolean.pipe';
+export * from './pipes/class-map.pipe';
+export * from './pipes/enum.pipe';
+export * from './pipes/enumerate.pipe';
+export * from './pipes/enumerate-async.pipe';
+export * from './pipes/getter.pipe';
+export * from './pipes/i18n-property.pipe';
+export * from './pipes/json-path.pipe';
+export * from './pipes/parametrize.pipe';
+export * from './pipes/template.pipe';
+export * from './reflect/type-enum-decorator';
+export * from './reflect/type-enum-metadata';
+export * from './registry/registry.model';
+export * from './registry/type-registry';
+export * from './router/route-builder';
+export * from './router/router.model';
+export * from './router/routes-builder';
+export * from './rxjs/map-data-list-result-operator';
+export * from './security/permission.guard';
+export * from './security/permission.service';
+export * from './security/permission-helpers';
+export * from './security/permissions.model';
+export * from './services/providers/commons-init.provider';
+export * from './services/tokens/browser-storage.token';
+export * from './services/tokens/commons-init.token';
+export * from './services/tokens/log-publisher.token';
+export * from './services/tokens/module-config.token';
+export * from './services/commons.service';
+export * from './services/commons-configuration.service';
+export * from './services/commons-init.service';
+export * from './services/commons-router.service';
+export * from './services/local-storage-config.service';
+export * from './styles/style.model';
+export * from './styles/style-constants';
+export * from './provide';

package/core/log/log-publisher-console.service.d.ts

@@ -0,0 +1,4 @@
+import { ILogPublisher, LogEntry } from './log.model';
+export declare class LogPublisherConsoleService implements ILogPublisher {
+    addEntry(entry: LogEntry): void;
+}

package/core/log/log.model.d.ts

@@ -0,0 +1,40 @@
+export declare enum LogLevelEnum {
+    Trace = 0,
+    Debug = 1,
+    Log = 2,
+    Info = 3,
+    Warning = 4,
+    Error = 5
+}
+export interface LogEntry {
+    level: LogLevelEnum;
+    message: string;
+    messageDetails?: string;
+    timestamp: Date;
+    timestampFormatted?: string;
+    category?: string;
+    error?: Error;
+    data?: any[];
+}
+export interface LogConfig {
+    level?: LogLevelEnum;
+    timestampFormat?: string;
+    category?: {
+        [category: string]: {
+            level?: LogLevelEnum;
+        };
+    };
+}
+export interface ILoggerService {
+    create(context: string): ILoggerService;
+    trace(msgOrError: string | Error, ...data: any[]): void;
+    debug(msgOrError: string | Error, ...data: any[]): void;
+    log(msgOrError: string | Error, logLevel: LogLevelEnum, category: string | undefined, ...data: any[]): void;
+    logEntry(logEntry: Partial<LogEntry>): void;
+    info(msgOrError: string | Error, ...data: any[]): void;
+    warn(msgOrError: string | Error, ...data: any[]): void;
+    error(msgOrError: string | Error, ...data: any[]): void;
+}
+export interface ILogPublisher {
+    addEntry(entry: LogEntry): void;
+}

package/core/log/logger.service.d.ts

@@ -0,0 +1,33 @@
+import { CommonsConfigurationService } from '../services/commons-configuration.service';
+import { ILogPublisher, ILoggerService, LogEntry, LogLevelEnum } from './log.model';
+export declare class LoggerService implements ILoggerService {
+    private static _instance;
+    private static _isInit;
+    private static _configurationService?;
+    private static _publishers;
+    private static _entriesBuffer;
+    private static _categoryInstances;
+    private static _timestampFormat;
+    private category?;
+    private readonly defaultLogLevel;
+    private datePipe;
+    private constructor();
+    static get(): LoggerService;
+    static configure(config: {
+        timestampFormat?: string;
+    }): void;
+    static init(configurationService: CommonsConfigurationService, publishers: ILogPublisher[]): void;
+    private static _flushBuffer;
+    static create(category: string): LoggerService;
+    create(category: string): LoggerService;
+    private _processLog;
+    private _getTimestamps;
+    private _log;
+    trace(msgOrError: string | Error, ...data: any[]): void;
+    debug(msgOrError: string | Error, ...data: any[]): void;
+    log(msgOrError: string | Error, logLevel?: LogLevelEnum, category?: string | undefined, ...data: any[]): void;
+    logEntry<E extends Partial<LogEntry>>(logEntry: E): void;
+    info(msgOrError: string | Error, ...data: any[]): void;
+    warn(msgOrError: string | Error, ...data: any[]): void;
+    error(msgOrError: string | Error, ...data: any[]): void;
+}

package/core/models/class-service.model.d.ts

@@ -0,0 +1,7 @@
+import { Type } from '@angular/core';
+export type ServiceClassType<S> = Type<S>;
+export type ServiceClassOptType<S> = ServiceClassType<S> | undefined;
+export interface ClassType<T> extends Function {
+    new (...args: any[]): T;
+}
+export type ClassOptType<T> = ClassType<T> | undefined;

package/core/models/getter.model.d.ts

@@ -0,0 +1,2 @@
+import { Nullable } from '../helpers/type-helpers';
+export type GetterFn<Value = Nullable<any>, Item = any, ReturnType = any> = (value: Value, item: Item) => ReturnType;

package/core/models/i18n.model.d.ts

@@ -0,0 +1 @@
+export type I18nMissingTranslationStrategy = 'returnNull' | 'returnFallbackKey' | 'returnFirstKey';

package/core/models/menu.model.d.ts

@@ -0,0 +1,32 @@
+import { QueryParamsHandling } from '@angular/router';
+import { APermissions } from '../security/permissions.model';
+export interface CommonsMenuItem {
+    index?: number;
+    key?: string;
+    id?: string;
+    positionIndex?: number;
+    label?: string;
+    icon?: string;
+    items?: Array<CommonsMenuItem>;
+    guards?: Array<any>;
+    permissions?: APermissions;
+    separator?: boolean;
+    className?: string;
+    badge?: string;
+    badgeClassName?: string;
+    visible?: boolean;
+    disabled?: boolean;
+    routerLink?: string | Array<string> | null;
+    href?: string;
+    target?: string;
+    queryParams?: {
+        [k: string]: any;
+    };
+    fragment?: string;
+    queryParamsHandling?: QueryParamsHandling;
+    preserveFragment?: boolean;
+    skipLocationChange?: boolean;
+    replaceUrl?: boolean;
+    updated?: boolean;
+    lazyChildren?: boolean;
+}

package/core/models/user.model.d.ts

@@ -0,0 +1,8 @@
+import { IdType } from '../helpers/type-helpers';
+export interface IUser {
+    id: IdType;
+    username: string;
+    displayName?: string;
+    logout?: () => void;
+    logoutUrl?: string;
+}

package/core/pipes/boolean.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class BooleanPipe implements PipeTransform {
+    transform(value: any, yes?: string, no?: string, icon?: boolean): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BooleanPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BooleanPipe, "mngBoolean", true>;
+}

package/core/pipes/class-map.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ClassMapPipe<T> implements PipeTransform {
+    transform(className?: string, classNameMapFn?: (className?: string, item?: T) => string, item?: T): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClassMapPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ClassMapPipe<any>, "mngClassMap", true>;
+}

package/core/pipes/enum.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { IEnumDescriptor } from '../descriptors/enum.descriptor';
+import * as i0 from "@angular/core";
+export declare class EnumPipe implements PipeTransform {
+    transform(value: unknown, enumDesc?: IEnumDescriptor, i18nPath?: string | null): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EnumPipe, "mngEnum", true>;
+}

package/core/pipes/enumerate-async.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class EnumerateAsyncPipe implements PipeTransform {
+    private readonly translate;
+    transform(value: Observable<Array<unknown> | Set<unknown>>, jsonPath?: string, valueSeparator?: string, emptyValueReturn?: string, i18nBaseKey?: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumerateAsyncPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EnumerateAsyncPipe, "mngEnumerateAsync", true>;
+}

package/core/pipes/enumerate.pipe.d.ts

@@ -0,0 +1,16 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class EnumeratePipe implements PipeTransform {
+    private readonly translate;
+    transform<T>(value: Array<T> | Set<T>, jsonPath?: string, valueSeparator?: string, emptyValueReturn?: string, i18nBaseKey?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumeratePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EnumeratePipe, "mngEnumerate", true>;
+}
+export declare function getEnumerationI18nBaseKey(baseKey: string): string;
+export declare function selectEnumerationI18n(value: EnumeratePipeI18nInternal, baseKey: string): string;
+export declare function toEnumerationI18nEnumerate(value: unknown, jsonPath: string, baseKey: string): EnumeratePipeI18nInternal;
+export interface EnumeratePipeI18nInternal {
+    value: string;
+    i18nKey: string;
+    i18n: string;
+}

package/core/pipes/getter.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { GetterFn } from '../models/getter.model';
+import * as i0 from "@angular/core";
+export declare class GetterPipe implements PipeTransform {
+    transform(value: unknown, getterFn?: GetterFn, item?: unknown): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GetterPipe, "mngGetter", true>;
+}

package/core/pipes/i18n-property.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { IModelDescriptor } from '../descriptors/model.descriptor';
+import * as i0 from "@angular/core";
+export declare class I18nPropertyPipe implements PipeTransform {
+    transform(property: string, model: IModelDescriptor<any>): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<I18nPropertyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<I18nPropertyPipe, "mngI18nProperty", true>;
+}

package/core/pipes/json-path.pipe.d.ts

@@ -0,0 +1,13 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Imitation of JSONPath Syntax. Supports:
+ *  - Root object notation with '$'
+ *  - Dot notation (e.g.: $.foo.bar), no bracket notation for properties
+ *  - Array notation (e.g.: [0])
+ */
+export declare class JsonPathPipe implements PipeTransform {
+    transform(value: any, path?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonPathPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<JsonPathPipe, "mngJsonPath", true>;
+}

package/core/pipes/parametrize.pipe.d.ts

@@ -0,0 +1,12 @@
+import { PipeTransform } from '@angular/core';
+import { IdType } from '../helpers/type-helpers';
+import * as i0 from "@angular/core";
+export declare class ParametrizePipe implements PipeTransform {
+    private jsonPath;
+    transform(value: unknown, itemId?: IdType, item?: any, data?: Record<string, any>): any;
+    private transformString;
+    private parametrizeStringAsRouterLink;
+    private parametrizeString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParametrizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ParametrizePipe, "mngParametrize", true>;
+}

package/core/pipes/template.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TemplatePipe implements PipeTransform {
+    private parametrizePipe;
+    transform(value: unknown, template?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TemplatePipe, "template", true>;
+}

package/core/provide.d.ts

@@ -0,0 +1,12 @@
+import { Provider } from '@angular/core';
+import { CommonsModuleConfig } from './services/tokens/module-config.token';
+export declare enum CommonsFeatureTypeEnum {
+    Layout = 0,
+    Tableview = 1,
+    DataApiAsClassV1 = 2
+}
+export interface CommonsFeature {
+    type: CommonsFeatureTypeEnum;
+    providers: Provider[];
+}
+export declare function provideCommons(config?: CommonsModuleConfig, ...features: CommonsFeature[]): Provider[];

package/core/reflect/type-enum-metadata.d.ts

@@ -0,0 +1,32 @@
+import 'reflect-metadata';
+import { EnumType } from '../helpers/type-helpers';
+import { ClassType } from '../models/class-service.model';
+export declare const reflectTypeNameKey = "typeName";
+export declare const reflectEnumNameKey = "enumName";
+/**
+ * Defines type name decorator.
+ * @param targetType class.
+ * @param typeName Name of the type.
+ */
+export declare function defineReflectTypeName(targetType: ClassType<any>, typeName: string): void;
+/**
+ * Defines enum name decorator.
+ * @param targetType enum object.
+ * @param enumName Name of the enum.
+ */
+export declare function defineReflectEnumName(targetType: EnumType, enumName: string): void;
+/**
+ * Gets type name from reflect metadata.
+ * @param type Class.
+ */
+export declare function findReflectTypeName<T>(type?: ClassType<T>): string | null;
+/**
+ * Gets type name from either decorator or reflect metadata.
+ * @param type Class.
+ */
+export declare function reflectTypeNameExists(type: ClassType<any>): boolean;
+/**
+ * Gets enum name from either decorator or reflect metadata.
+ * @param enumType Class.
+ */
+export declare function findReflectEnumName(enumType: EnumType): string | null;

package/core/registry/registry.model.d.ts

@@ -0,0 +1,8 @@
+import { EnumType } from '../helpers/type-helpers';
+import { ClassType } from '../models/class-service.model';
+export interface RegistryTypeMap {
+    [index: string]: ClassType<any>;
+}
+export interface RegistryEnumMap {
+    [index: string]: EnumType;
+}

package/core/registry/type-registry.d.ts

@@ -0,0 +1,27 @@
+import { EnumType } from '../helpers/type-helpers';
+import { ClassAttributeDef } from '../models/class-attribute.model';
+import { ClassType } from '../models/class-service.model';
+import { RegistryEnumMap, RegistryTypeMap } from './registry.model';
+export declare class TypeRegistry {
+    private static _instance;
+    private readonly _logCategory;
+    private readonly _typeMap;
+    private readonly _enumMap;
+    get typeMap(): RegistryTypeMap;
+    get enumMap(): RegistryEnumMap;
+    /**
+     * Only use one instance of object (out of Angular context)
+     */
+    static get(): TypeRegistry;
+    findAttributeDefinitionByClassType(type: ClassType<any>, attributeName: string): ClassAttributeDef | null;
+    findAttributeDefinition(typeName: string, attributeName: string): ClassAttributeDef | null;
+    findAttributesDefinitionByClassType(type: ClassType<any>): Array<ClassAttributeDef> | null;
+    findAttributesDefinition(typeName: string): Array<ClassAttributeDef> | null;
+    findByClassType(type: ClassType<any>): any;
+    findType(typeName: string): any;
+    findEnum(enumName: string): any;
+    registerTypes(types: RegistryTypeMap): void;
+    registerType(type: ClassType<any>, optTypeName?: string): void;
+    registerEnums(enums: RegistryEnumMap): void;
+    registerEnum(enumType: EnumType, enumName: string): void;
+}

package/core/router/route-builder.d.ts

@@ -0,0 +1,65 @@
+import { EnvironmentProviders, Provider, Type } from '@angular/core';
+import { CanActivateFn, CanDeactivateFn, DefaultExport, LoadChildren, ResolveFn, Route } from '@angular/router';
+import { Observable } from 'rxjs';
+import { CommonsMenuItem } from '../models/menu.model';
+import { APermissions } from '../security/permissions.model';
+import { BreadcrumbType, CommonsRouteData } from './router.model';
+import { RoutesBuilder } from './routes-builder';
+export type RouteBuilderAdjustFnType = (builder: RouteBuilder) => void;
+export declare class RouteBuilder {
+    protected readonly route: Route;
+    private routePath;
+    protected routeData: CommonsRouteData;
+    private root?;
+    private parent?;
+    private children;
+    private menuItem?;
+    private menuItemChildren;
+    private menuItemChildrenAfter;
+    private breadcrumb?;
+    private pageTitle?;
+    private permissions?;
+    protected constructor(route: Route);
+    static create(path: string, component: Type<any>): RouteBuilder;
+    static createRedirect(path: string, redirectTo: string, pathMatch?: 'full' | 'prefix'): RouteBuilder;
+    static createLazyRouteModule(path: string, loadChildren: LoadChildren, canMatch?: Array<any>): RouteBuilder;
+    static createLazyRouteComponent(path: string, loadComponent: () => Type<unknown> | Observable<Type<unknown> | DefaultExport<Type<unknown>>> | Promise<Type<unknown> | DefaultExport<Type<unknown>>>, canMatch?: Array<any>): RouteBuilder;
+    static createFromRoute(route: Route): RouteBuilder;
+    withRoot(routesBuilder: RoutesBuilder): this;
+    withParent(parent: RouteBuilder): this;
+    withBreadcrumb(breadcrumb: BreadcrumbType): this;
+    withPageTitle(pageTitle: string): this;
+    withRedirectTo(redirectTo: string): this;
+    withPathMatch(pathMatch: 'full' | 'prefix'): this;
+    withTitle(title: string): this;
+    withCanActivate(diToken: CanActivateFn): this;
+    withCanDeactivate(diToken: CanDeactivateFn<any>): this;
+    withResolver(diToken: ResolveFn<any>, name: string): this;
+    withProvider(provider: Provider | EnvironmentProviders): this;
+    withData(data: CommonsRouteData): this;
+    withCommonsMenuItem(menuItem: CommonsMenuItem): this;
+    withMenuItem(icon?: string, label?: string, routerLink?: Array<string>, breadcrumb?: boolean): this;
+    /**
+     * Adds menu item child to this instance of menu item.
+     * @param label Label.
+     * @param icon Icon.
+     * @param routerLink Router link.
+     * @param afterRouteChildren If false, menu item child will be appended before route children menu items, at the end otherwise.
+     */
+    withMenuItemChild(label: string, icon?: string, routerLink?: Array<string>, afterRouteChildren?: boolean): this;
+    /**
+     * Adds menu item child to this instance of menu item.
+     * @param menuItem Configuration object for menu item.
+     * @param afterRouteChildren If false, menu item child will be appended before route children menu items, at the end otherwise.
+     */
+    withCommonsMenuItemChild(menuItem: CommonsMenuItem, afterRouteChildren?: boolean): this;
+    withMenuItemLazyChildren(): this;
+    withPermissions(permissions: APermissions): this;
+    addChild(path: string, component: Type<any>, adjustFn?: RouteBuilderAdjustFnType): this;
+    addChildBuilder(builder: RouteBuilder): this;
+    build(): Route;
+    private buildMenu;
+    private createMenuItem;
+    private findMenuItemGuards;
+    protected findMenuItemPermissions(): APermissions | undefined;
+}

package/core/router/router.model.d.ts

@@ -0,0 +1,13 @@
+import { ActivatedRouteSnapshot, Data } from '@angular/router';
+import { CommonsMenuItem } from '../models/menu.model';
+import { APermissions } from '../security/permissions.model';
+export type BreadcrumbType = string | string[] | BreadcrumbMenuItem | BreadcrumbMenuItem[] | ((routeUrl: string, route: ActivatedRouteSnapshot) => BreadcrumbMenuItem[]);
+export interface BreadcrumbMenuItem extends CommonsMenuItem {
+    isHome?: boolean;
+}
+export interface CommonsRouteData extends Data {
+    breadcrumb?: BreadcrumbType | null;
+    pageTitle?: string;
+    menuItems?: Array<CommonsMenuItem>;
+    permissions?: APermissions;
+}

package/core/router/routes-builder.d.ts

@@ -0,0 +1,18 @@
+import { Type } from '@angular/core';
+import { DefaultExport, LoadChildren, Route, Routes } from '@angular/router';
+import { Observable } from 'rxjs';
+import { RouteBuilder, RouteBuilderAdjustFnType } from './route-builder';
+export declare class RoutesBuilder {
+    private readonly layoutRoute?;
+    private routes;
+    private currentRoute?;
+    private constructor();
+    static create(): RoutesBuilder;
+    addAngularRoute(route: Route, builderAdjustFn?: RouteBuilderAdjustFnType): this;
+    addRouteRedirect(path: string, redirectTo: string, pathMatch?: 'full' | 'prefix'): this;
+    addLazyRouteComponent(path: string, loadComponent: () => Type<unknown> | Observable<Type<unknown> | DefaultExport<Type<unknown>>> | Promise<Type<unknown> | DefaultExport<Type<unknown>>>, canMatch?: Array<any>, builderAdjustFn?: RouteBuilderAdjustFnType): this;
+    addLazyRouteModule(path: string, loadChildren: LoadChildren, canMatch?: Array<any>, builderAdjustFn?: RouteBuilderAdjustFnType): this;
+    addRoute(path: string, component: Type<any>, builderAdjustFn?: RouteBuilderAdjustFnType): this;
+    addRouteBuilder(routeBuilder: RouteBuilder): this;
+    build(): Routes;
+}

package/core/rxjs/map-data-list-result-operator.d.ts

@@ -0,0 +1,9 @@
+import { OperatorFunction } from 'rxjs';
+import { DataListResult } from '../data-list/data-list.model';
+/**
+ * Maps an Observable of data with optional totalCount and data to a data list result object with provided defaults of empty array and count 0.
+ */
+export declare function mapToDataList<Item>(): OperatorFunction<{
+    data?: Item[];
+    totalCount?: number;
+}, DataListResult<Item>>;