@mediusinc/mng-commons 6.2.0-rc.0 → 7.0.0-rc.0

package/core/index.d.ts

@@ -1,84 +1,1743 @@
-export * from './action/action-data.model';
-export * from './action/action-parameters.model';
-export * from './components/notification/notification-wrapper.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-list/filter-metadata.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/rerender.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/number';
-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 './reactivity/effect';
-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/commons-storage.service';
-export * from './styles/style.model';
-export * from './styles/style-constants';
-export * from './provide';
+import * as _angular_router from '@angular/router';
+import { ActivatedRoute, Params, ActivatedRouteSnapshot, RouterStateSnapshot, QueryParamsHandling, Data, Route, Routes, CanActivateFn, CanDeactivateFn, ResolveFn, LoadChildren, DefaultExport } from '@angular/router';
+import * as rxjs from 'rxjs';
+import { Observable, OperatorFunction } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Type, InjectionToken, Injector, ComponentRef, TemplateRef, ErrorHandler, WritableSignal, Signal, PipeTransform, EffectRef, Provider, EnvironmentProviders } from '@angular/core';
+import { ToastMessageOptions, FilterMetadata, MessageService, MenuItem } from 'primeng/api';
+import { TableLazyLoadEvent } from 'primeng/table';
+import { HttpErrorResponse, HttpClient, HttpBackend } from '@angular/common/http';
+import * as _mediusinc_mng_commons_core from '@mediusinc/mng-commons/core';
+import { TranslateService, Translation, StrictTranslation } from '@ngx-translate/core';
+
+type ActionData = {
+    [key: string]: any;
+};
+
+type FilterMatchModeType = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'in' | 'notIn' | 'startsWith' | 'endsWith' | 'lessThan' | 'lessThanOrEqualTo' | 'greaterThan' | 'greaterThanOrEqualTo' | 'between' | 'exists' | 'doesNotExist';
+type FilterMatchModeExtendedType = FilterMatchModeType | string;
+declare class FilterMatchMode {
+    static Equals: FilterMatchModeType;
+    static EqualsAbbr: string;
+    static NotEquals: FilterMatchModeType;
+    static NotEqualsAbbr: string;
+    static Contains: FilterMatchModeType;
+    static ContainsAbbr: string;
+    static NotContains: FilterMatchModeType;
+    static NotContainsAbbr: string;
+    static In: FilterMatchModeType;
+    static InAbbr: string;
+    static NotIn: FilterMatchModeType;
+    static NotInAbbr: string;
+    static StartsWith: FilterMatchModeType;
+    static StartsWithAbbr: string;
+    static EndsWith: FilterMatchModeType;
+    static EndsWithAbbr: string;
+    static LessThan: FilterMatchModeType;
+    static LessThanAbbr: string;
+    static LessThanOrEqualTo: FilterMatchModeType;
+    static LessThanOrEqualToAbbr: string;
+    static GreaterThan: FilterMatchModeType;
+    static GreaterThanAbbr: string;
+    static GreaterThanOrEqualTo: FilterMatchModeType;
+    static GreaterThanOrEqualToAbbr: string;
+    static Between: FilterMatchModeType;
+    static BetweenAbbr: string;
+    static Exists: FilterMatchModeType;
+    static ExistsAbbr: string;
+    static DoesNotExist: FilterMatchModeType;
+    static DoesNotExistAbbr: string;
+    static getAbbreviation(mode: string): string | null;
+    static fromAbbreviation(abbr: string): string | null;
+}
+
+interface DataListParams<Sorts = string, Filters extends keyof any = string> {
+    offset?: number;
+    limit?: number;
+    sort?: DataListSort<Sorts>[];
+    search?: string;
+    searchCaseSensitive?: boolean;
+    filters?: Partial<DataListFiltersType<Filters>>;
+}
+interface DataListSort<Property = string> {
+    property: Property;
+    ascending?: boolean;
+}
+type DataListFilterBaseValueType = string | number | boolean | Date | undefined | null;
+type DataListFilterValueType = DataListFilterBaseValueType | DataListFilterBaseValueType[] | undefined | null;
+type DataListFilterFromUrlValueType = string | string[] | undefined | null;
+type DataListFiltersType<Filters extends keyof any = string> = {
+    [Prop in Filters]: DataListFilter;
+};
+interface DataListFilter<Value = DataListFilterValueType> {
+    value?: Value;
+    matchMode?: FilterMatchModeExtendedType;
+    caseSensitive?: boolean;
+}
+interface DataListResult<Item = any> {
+    data: Item[];
+    totalCount?: number;
+}
+
+type KeyOfType = string | number | symbol;
+type Nullable<T> = T | null | undefined;
+type Undefined<T> = T | undefined;
+type ObjectOptPropType<OT, P extends keyof OT, PT> = P extends keyof OT ? (OT[P] extends Nullable<PT> ? P : never) : never;
+type KeyofAndOfType<Type, PropertyType> = {
+    [K in keyof Type]: NonNullable<Type[K]> extends NonNullable<PropertyType> ? K : never;
+}[keyof Type];
+type ArrayItemType<T> = NonNullable<T> extends Array<infer U> ? U : T;
+type SingleOrArrayType<T> = T | Array<T>;
+type IdType = number | string;
+type PrimitiveType = string | boolean | number;
+type PropertyType = PrimitiveType | Date | EnumType;
+type ItemOrObservable<T> = T | Observable<T>;
+type EnumConstantType = string | number;
+interface EnumType<V = EnumConstantType> {
+    [key: string]: V;
+}
+type ClassFunctionKeysType<Clazz> = {
+    [K in keyof Clazz]: Clazz[K] extends (...args: any[]) => any ? K : never;
+}[keyof Clazz];
+type ClassFunctionKeysWithReturnType<Clazz, Return> = {
+    [K in keyof Clazz]: Clazz[K] extends () => Return ? K : never;
+}[keyof Clazz];
+type ClassFunctionKeysWithAnyArgsAndReturnType<Clazz, Return> = {
+    [K in keyof Clazz]: Clazz[K] extends (...args: any[]) => Return ? K : never;
+}[keyof Clazz];
+type ClassFunctionKeysWithParamAndReturnType<Clazz, Param, Return> = {
+    [K in keyof Clazz]: Clazz[K] extends (param: Param, ...args: any[]) => Return ? K : never;
+}[keyof Clazz];
+type ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, FnKey extends keyof Service, Param1Target = unknown> = Service[FnKey] extends (...args: infer Params) => any ? Params[0] extends object ? {
+    [Key in keyof Params[0]]: Param1Target extends Params[0][Key] ? Key : never;
+}[keyof Params[0]] : never : never;
+type CommonKeyof3<T, U, V> = keyof T & keyof U & keyof V;
+type CommonPropsObjType3<T, U, V> = {
+    [K in CommonKeyof3<T, U, V>]: T[K];
+};
+
+interface ActionParameters<Item, TableItem = Item, FormItem = Item, SubmitResultItem = Item> {
+    /**
+     * Identificator of an item.
+     */
+    itemId?: IdType;
+    /**
+     * Item value.
+     */
+    item?: Item;
+    /**
+     * Additional action data.
+     */
+    actionData?: ActionData;
+    /**
+     * Data list params when action is activated from table.
+     */
+    dataListParams?: DataListParams<any, any>;
+    /**
+     * Represents the component where which activates the action.
+     */
+    sourceComponent?: any;
+    /**
+     * Represents the component where the action is hosted or placed (activation button).
+     */
+    hostComponent?: unknown;
+    route?: ActivatedRoute;
+    /**
+     * @deprecated Selected items should accessed using `getActionParentTable`.
+     */
+    selectedItems?: TableItem[];
+    locale?: string;
+    /**
+     * Used on fetch fn to provide the form item of previous submit.
+     */
+    formItem?: FormItem | null;
+    /**
+     * Used on fetch fn to provide the result of previous submit (return of submit fn).
+     */
+    submitResult?: SubmitResultItem | null;
+}
+
+declare class NotificationWrapperComponent {
+    readonly notificationCutoff = 70;
+    isDialogNotificationVisible: i0.Signal<boolean>;
+    dialogNotification: i0.WritableSignal<ToastMessageOptions | null>;
+    dialogNotificationIconClass: i0.Signal<string>;
+    getMessageIcon(message: Nullable<ToastMessageOptions>): string;
+    onShowNotificationInDialog(message: ToastMessageOptions): void;
+    onDialogNotificationVisibilityChange(visible: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationWrapperComponent, "mng-notification-wrapper", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Converts a TableLazyLoadEvent to DataListParams.
+ *
+ * @param {TableLazyLoadEvent} event - The event containing the data to convert.
+ * @return {DataListParams} - The converted DataListParams object.
+ */
+declare function fromTableLoadToDataListParams(event: TableLazyLoadEvent): DataListParams;
+/**
+ * Converts the given parameters to URL query parameters.
+ * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListParams} params - The parameters to convert.
+ * @param {DataListParams|null} defaults - The default parameters used if no matching property in params is available. Defaults to { limit: 25, offset: 0 } if not provided.
+ * @param opts - Options in converting to url query:
+ *   - prependFilterName Prepends filter key with provided string
+ * @returns {Params} - The URL query parameters object.
+ */
+declare function dataListParamsToUrlQuery(params: DataListParams<any, any>, defaults?: DataListParams<any, any> | null, opts?: {
+    prependFilterName?: string;
+    skipPresetDefaultsLimit?: boolean;
+}): Params;
+/**
+ * Merges the provided parameters with default values and returns the merged object.
+ *
+ * @param {DataListParams} params - The parameters to merge with defaults.
+ * @param {DataListParams} defaults - The default values to merge with params (optional, default is { limit: 25, offset: 0 }).
+ * @returns {DataListParams} - The merged parameters object.
+ */
+declare function mergeDataListParamsWithDefaults<Sorts = any, Filters extends keyof any = any>(params: DataListParams<Sorts, Filters>, defaults?: DataListParams<Sorts, Filters>): DataListParams<Sorts, Filters>;
+/**
+ * Converts an object of parameters to a URL query string for sorting.
+ * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ *
+ * @param {DataListParams} params - An optional object containing sort parameters.
+ * @returns A string representing the URL query or undefined if no sort parameters are provided.
+ */
+declare function dataListParamsSortToUrlQuery(params?: DataListParams<any, any>): string | undefined;
+/**
+ * Converts a specific filter parameter (by key) from DataListParams object to a URL query string.
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListParams<any, Filters> | undefined} params - The DataListParams object containing the filters.
+ * @param {Filters} key - The key of the filter to convert.
+ * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the query string.
+ * @return {string | undefined} - The URL query string representing the specified filter, or undefined if the filter is not found.
+ */
+declare function dataListParamsFiltersToUrlQuery<Filters extends keyof any = string>(params: DataListParams<any, Filters> | undefined, key: Filters, allowNull?: boolean): string | undefined;
+/**
+ * Converts a filter to a URL query string.
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListFilter} paramFilter - The filter object to be converted.
+ * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the filter.
+ * @returns {string|undefined} - The filter converted to a URL query string, or undefined if no filter is provided or the filter has empty or invalid values.
+ * @throws {CommonsInternalError} - If the filter has invalid values.
+ */
+declare function dataListParamsFilterToUrlQuery(paramFilter?: DataListFilter, allowNull?: boolean): string | undefined;
+/**
+ * Converts URL query parameters to a DataListParams object.
+ * Sorts are formatted from Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ * Filter keys are all keys in Params object that are not matched elsewhere, values are formatted from Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {Params} urlParams - The URL query parameters.
+ * @param opts Additional options for conversion:
+ *  - searchAsGlobal - The URL query parameters.
+ *  - prependFilterName - Filter names are prepended with provided string.
+ * @return {DataListParams} - The converted DataListParams object.
+ */
+declare function fromUrlQueryToDataListParams(urlParams: Params, opts?: {
+    searchAsGlobal?: boolean;
+    prependFilterName?: string;
+}): DataListParams;
+/**
+ * Makes a copy of the given DataListParams object.
+ *
+ * @param {DataListParams<Sorts, Filters>} params - The DataListParams object to be copied.
+ * @returns {DataListParams<Sorts, Filters>} - Returns a new copy of the DataListParams object.
+ */
+declare function copyDataListParams<Sorts = string, Filters extends keyof any = string>(params: DataListParams<Sorts, Filters>): DataListParams<Sorts, Filters>;
+/**
+ * Converts a value to a URL query param string representation.
+ *
+ * @param {unknown} value - The value to be converted.
+ * @param {boolean} [allowNull=false] - Indicates whether null values are allowed.
+ * @returns {string} The URL parameter representation of the value.
+ * @throws {CommonsInternalError} If an undefined value is passed without allowNull set to true.
+ * @throws {CommonsInternalError} If the value is an object (excluding Date).
+ */
+declare function dataListParamsFilterValueToUrlString(value: unknown, allowNull?: boolean): string;
+
+interface CommonsFilterMetadata extends Omit<FilterMetadata, 'matchMode'> {
+    /**
+     * The value used for display.
+     */
+    displayValue?: any;
+    /**
+     * The match mode for display.
+     */
+    displayMatchMode?: FilterMatchModeExtendedType;
+    /**
+     * Overridden PrimeNg FilterMetadata to have more specific type.
+     */
+    matchMode?: FilterMatchModeExtendedType;
+    /**
+     * Case sensitive filter flag.
+     */
+    caseSensitive?: boolean;
+}
+
+type ServiceClassType<S> = Type<S>;
+type ServiceClassOptType<S> = ServiceClassType<S> | undefined;
+interface ClassType<T> extends Function {
+    new (...args: any[]): T;
+}
+type ClassOptType<T> = ClassType<T> | undefined;
+
+type IDataProvider<ModelType = any, ServiceType = any, ST = ServiceClassOptType<ServiceType>> = {
+    serviceType: ST;
+    isDataProvider: boolean;
+};
+/**
+ * A base data provider class used for handling data operations.
+ *
+ * @tparam Model - The type of data this data provider will handle.
+ * @tparam Service - The type of service used by this data provider (optional).
+ * @tparam ServiceClass - The service type for the data provider  (optional).
+ */
+declare class DataProviderInst<Model, Service = any, ServiceClass = ServiceClassOptType<Service>> implements IDataProvider<Model, Service, ServiceClass> {
+    readonly serviceType: ServiceClass;
+    constructor(serviceType: ServiceClass);
+    get isDataProvider(): boolean;
+}
+
+type LookupDataProviderLookupFnType<Model = any, Service = undefined, Sorts = keyof Model, Filters extends keyof any = keyof Model, ReturnType = ItemOrObservable<Array<Model>>> = (params: DataListParams<Sorts, Filters> | undefined, service: Service, search?: string) => ReturnType;
+interface ILookupDataProviderLookup<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model> {
+    lookup: LookupDataProviderLookupFnType<Model, Service, Sorts, Filters>;
+    withLookup(fn?: LookupDataProviderLookupFnType<Model, Service, Sorts, Filters>): this;
+}
+type ILookupDataProvider<Model = any, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model, ServiceClass = ServiceClassOptType<Service>> = IDataProvider<Model, Service, ServiceClass> & ILookupDataProviderLookup<Model, Service, Sorts, Filters>;
+
+interface IModelDescriptor<Model> {
+    i18nBaseKey: string;
+    idProperty?: string;
+    titleProperty?: string | ((item: Model) => string);
+}
+
+interface IActionDescriptor<Model, Service = any> {
+    model?: IModelDescriptor<Model>;
+    actionName: string;
+    actionNameLong: string;
+    parentType?: ClassType<unknown>;
+    parentTypeName?: string;
+    parentProperty?: string;
+    dataProvider?: IDataProvider<Model, Service>;
+}
+
+interface IColumnDescriptor<ColumnModel, TableModel, ColumnValue> {
+    property: string;
+}
+
+interface IEditorDescriptor<EditorModel, ParentEditorModel = undefined> {
+    model: IModelDescriptor<EditorModel>;
+    isLocalized: boolean;
+    localizationLocaleProperty?: string;
+    localizationModel?: IModelDescriptor<any>;
+    localizationLocalizationProperty?: string;
+    localized<K extends keyof EditorModel, LocalizationModel = ArrayItemType<EditorModel[K]>>(property: K, model: IModelDescriptor<LocalizationModel>, localeProperty: keyof LocalizationModel): this;
+    localizedUnsafe<LocalizationModel>(property: string, model: IModelDescriptor<LocalizationModel>, localeProperty: string): this;
+}
+
+interface IEnumDescriptor {
+    type: EnumType;
+    nameAsValue: boolean;
+    i18nBaseKey: string | null;
+}
+
+interface IFilterDescriptor<FilterModel, TableModel> {
+    property: string;
+}
+
+interface ILookupDescriptor<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model> {
+    optionsLabelProperty?: string;
+    optionsValueProperty?: string;
+    optionsTrackProperty?: string;
+    dataProvider: ILookupDataProvider<Model, Service, Sorts, Filters>;
+    withOptionsLabelProperty(property: keyof Model): this;
+    withOptionsLabelPropertyUnsafe(property: string): this;
+    withOptionsTrackProperty(property: keyof Model): this;
+    withOptionsTrackPropertyUnsafe(property: string): this;
+    withLookup(lookup: LookupDataProviderLookupFnType<Model, Service, Sorts, Filters>): this;
+}
+
+interface ITableDescriptor<TableModel, Sorts, Filters> {
+    model: IModelDescriptor<TableModel>;
+    withDefaultSortUnsafe(property: string, ascending?: boolean, enabled?: boolean): this;
+    withSortUnsafe(property: string, isDefault: boolean, ascending?: boolean): this;
+    withDefaultSorts(...properties: Sorts[]): this;
+    withoutDefaultSorts(): this;
+    addFilterFromColumnDescriptorUnsafe<FilterModel>(column: IColumnDescriptor<FilterModel, TableModel, any>, forceSimple: boolean): IFilterDescriptor<any, TableModel>;
+}
+
+interface ITableviewDescriptor<TableviewModel, SortProperty, FilterProperty, ParentEditorModel = undefined, TableModel = TableviewModel, AddModel = TableviewModel, EditModel = TableviewModel> {
+    model: IModelDescriptor<TableviewModel>;
+    table: ITableDescriptor<TableModel, SortProperty, FilterProperty>;
+    detailsEditor: IEditorDescriptor<TableviewModel, ParentEditorModel>;
+    addEditor: IEditorDescriptor<AddModel, ParentEditorModel>;
+    editEditor: IEditorDescriptor<EditModel, ParentEditorModel>;
+    copy(): ITableviewDescriptor<TableviewModel, SortProperty, FilterProperty, ParentEditorModel, TableModel, AddModel, EditModel>;
+}
+
+declare class ComponentDirective<C> {
+    private readonly injector;
+    private readonly elementRef;
+    private readonly applicationRef;
+    private readonly viewContainerRef;
+    readonly component: i0.InputSignal<Type<C> | undefined>;
+    readonly componentIt: i0.InputSignal<InjectionToken<Type<C>> | undefined>;
+    readonly inputs: i0.InputSignal<Record<string, any> | undefined>;
+    readonly attachToHost: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly parentInjector: i0.InputSignal<Injector | undefined>;
+    readonly instanceCreated: i0.OutputEmitterRef<C>;
+    componentRef?: ComponentRef<C>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComponentDirective<any>, "[mngComponent]", never, { "component": { "alias": "mngComponent"; "required": false; "isSignal": true; }; "componentIt": { "alias": "injectionToken"; "required": false; "isSignal": true; }; "inputs": { "alias": "inputs"; "required": false; "isSignal": true; }; "attachToHost": { "alias": "attachToHost"; "required": false; "isSignal": true; }; "parentInjector": { "alias": "parentInjector"; "required": false; "isSignal": true; }; }, { "instanceCreated": "instanceCreated"; }, never, never, true, never>;
+}
+
+declare class RerenderDirective {
+    private readonly templateRef;
+    private readonly viewContainerRef;
+    readonly mngRerender: i0.InputSignal<unknown>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RerenderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RerenderDirective, "[mngRerender]", never, { "mngRerender": { "alias": "mngRerender"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TemplateDirective {
+    readonly template: TemplateRef<any>;
+    readonly name: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateDirective, "[mngTemplate]", never, { "name": { "alias": "mngTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface EnumValue {
+    name?: string;
+    value: EnumConstantType;
+    title: string;
+    disabled?: boolean;
+}
+type EnumFromProperty<Type, Property extends keyof Type> = Type[Property] extends EnumType | undefined | null ? NonNullable<Type[Property]> : never;
+
+/**
+ * Returns array of names for constants in enum.
+ * @param enumType Enum object.
+ */
+declare function getEnumConstantNames(enumType: EnumType): Array<string>;
+/**
+ * Returns array of names for constants in enum.
+ * @param enumObj Enum object.
+ */
+declare function getEnumConstantNamesFromObject(enumObj: object): Array<string>;
+/**
+ * Returns array of values for constants in enum.
+ * @param enumType Enum object.
+ */
+declare function getEnumConstantValues(enumType: EnumType): Array<EnumConstantType>;
+/**
+ * Returns array of string values for constants in enum.
+ * @param enumType Enum object.
+ */
+declare function getEnumConstantValuesAsString(enumType: EnumType): Array<string>;
+/**
+ * Returns array of number values for constants in enum.
+ * @param enumType Enum object.
+ */
+declare function getEnumConstantValuesAsNumber(enumType: EnumType): Array<number>;
+/**
+ * Returns array of type EnumValue for all constants in enum.
+ * @param enumType Enum object.
+ * @param nameAsValue If use name of constant as value (optional, default: false).
+ * @param titlePath Base path for title to use as translation (optional).
+ */
+declare function fromEnumConstantsAsValueArray(enumType: EnumType, nameAsValue?: boolean, titlePath?: string): EnumValue[];
+/**
+ * Returns array of type EnumValue for provided values in enum.
+ * @param enumType Enum object.
+ * @param values Enum values (constants).
+ * @param nameAsValue If use name of constant as value (optional, default: false).
+ * @param titlePath Base path for title to use as translation (optional).
+ */
+declare function fromEnumValuesAsValueArray<EnumConstant = EnumConstantType>(enumType: EnumType, values: Array<EnumConstant>, nameAsValue?: boolean, titlePath?: string): EnumValue[];
+/**
+ * Gets constant name for value.
+ * @param enumType Enum object.
+ * @param value Value of enum constant.
+ */
+declare function getEnumConstantName<EnumConstant = EnumConstantType>(enumType: EnumType, value: EnumConstant): string | null;
+/**
+ * Gets constant name for value.
+ * @param enumObj Enum object.
+ * @param value Value of enum constant.
+ */
+declare function getEnumConstantNameFromObject<EnumConstant = EnumConstantType>(enumObj: object, value: EnumConstant): string | null;
+
+type ErrorTypes = 'CommonsInternalError' | 'CommonsActionError' | 'CommonsHttpError';
+/**
+ * Main use for commons error from action execution.
+ * If http error is thrown, add it in cause.
+ */
+interface ICommonsError extends Error {
+    type: ErrorTypes;
+    messageCode?: number | string;
+    message: string;
+    details?: any;
+    stack?: string;
+    cause?: Error | unknown;
+    notification?: ToastMessageOptions;
+    notificationEmitSource?: string;
+}
+interface CommonsErrorBaseOptions {
+    name?: string;
+    messageCode?: number | string;
+    details?: any;
+    cause?: Error;
+    stack?: string;
+    location?: string;
+    notification?: ToastMessageOptions;
+}
+declare abstract class ACommonsErrorBase extends Error implements ICommonsError {
+    abstract readonly type: ErrorTypes;
+    readonly messageCode?: number | string;
+    readonly location?: string;
+    readonly details?: any;
+    readonly notification?: ToastMessageOptions;
+    readonly notificationEmitSource?: string;
+    protected constructor(message: string, options?: CommonsErrorBaseOptions);
+}
+declare class CommonsInternalError extends ACommonsErrorBase implements ICommonsError {
+    readonly type = "CommonsInternalError";
+    constructor(message: string, options?: CommonsErrorBaseOptions);
+}
+declare class CommonsHttpError extends ACommonsErrorBase implements ICommonsError {
+    readonly type = "CommonsHttpError";
+    readonly httpError: HttpErrorResponse;
+    constructor(message: string, httpError: HttpErrorResponse, options?: CommonsErrorBaseOptions);
+}
+interface ICommonsActionError extends ICommonsError {
+    type: 'CommonsActionError';
+    httpError?: HttpErrorResponse;
+    actionContext?: ICommonsActionErrorContext;
+}
+interface ICommonsActionErrorContext {
+    parameters: ActionParameters<any>;
+}
+
+declare class CommonsErrorHandler implements ErrorHandler {
+    private static readonly logCategory;
+    private readonly logger;
+    handleError(error: Error): void;
+}
+
+declare enum LogLevelEnum {
+    Trace = 0,
+    Debug = 1,
+    Log = 2,
+    Info = 3,
+    Warning = 4,
+    Error = 5
+}
+interface LogEntry {
+    level: LogLevelEnum;
+    message: string;
+    messageDetails?: string;
+    timestamp: Date;
+    timestampFormatted?: string;
+    category?: string;
+    error?: Error;
+    data?: any[];
+}
+interface LogConfig {
+    level?: LogLevelEnum;
+    timestampFormat?: string;
+    category?: {
+        [category: string]: {
+            level?: LogLevelEnum;
+        };
+    };
+}
+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;
+}
+interface ILogPublisher {
+    addEntry(entry: LogEntry): void;
+}
+
+/**
+ * Converts RxJS subscription error to CommonsError.
+ * @param error Error.
+ * @param name Optional name to write in commons error.
+ * @param details Optional details of error.
+ */
+declare function fromSubscribeError(error: any, name?: string, details?: any): ACommonsErrorBase;
+/**
+ * Checks if error is Http error (Angular or Commons).
+ * @param error
+ */
+declare function isHttpErrorResponse(error: any): boolean;
+/**
+ * Gets HttpErrorResponse from error (Angular or Commons).
+ * @param error Error.
+ */
+declare function getHttpErrorResponse(error: any): HttpErrorResponse | null;
+/**
+ * Gets HttpErrorResponse status from error (Angular or Commons).
+ * @param error Error.
+ */
+declare function getHttpErrorResponseStatus(error: any): number | null;
+/**
+ * Gets HttpErrorResponse status text from error (Angular or Commons).
+ * @param error Error.
+ */
+declare function getHttpErrorResponseStatusText(error: any): string | null;
+/**
+ * Get error log level. All is error, except if error is http error with status >=400 and <500.
+ * @param error Error.
+ */
+declare function getErrorLogLevel(error: any): LogLevelEnum;
+/**
+ * Get error name (prototype name or type from commons error if name is not provided).
+ * @param error Error.
+ */
+declare function getErrorName(error: any): string;
+/**
+ * Writes http error to string with all headers and body.
+ * @param error Http response error.
+ * @param opts Options for hiding parts of error:
+ *  - hideMessage Hides message of error (message include url, status and status text!).
+ *  - hideHeaders Hides headers.
+ *  - hideBody Hides JSON representation of body.
+ */
+declare function httpErrorResponseToString(error: HttpErrorResponse, opts?: HttpErrorResponseToStringOptionsType): string;
+/**
+ * Error to string.
+ * @param error Error.
+ * @param opts Options for hiding parts of error:
+ * - hideMessage Hides message of error.
+ * - hideName Hides error name.
+ * - hideCause Hides cause of an error (if present, see @link(errorCauseToString) for other options).
+ * - hideStack Hides stack of an error (if present).
+ * - hideDetails Hides JSON detail's representation of error (if present).
+ * - hideLocation Hides location (URL) where error was thrown.
+ * - hideHttp Hides http error portion of error if http error response (see @link(httpErrorResponseToString) for other options).
+ */
+declare function errorToString(error: Error, opts?: ErrorToStringOptionsType): string;
+/**
+ * Commons error to string.
+ * @param error Commons error.
+ * @param opts Options for hiding parts of error:
+ * - hideMessage Hides message of error.
+ * - hideName Hides error name.
+ * - hideCause Hides cause of an error (if present, see @link(errorCauseToString) for other options).
+ * - hideStack Hides stack of an error (if present).
+ * - hideDetails Hides JSON detail's representation of error (if present).
+ * - hideLocation Hides location (URL) where error was thrown.
+ * - hideHttp Hides http error portion of error if http error response (see @link(httpErrorResponseToString) for other options).
+ * - hideItems Hides all item information (http body, action context data).
+ * - hideActionData See @link(commonsActionErrorContextToString) for additional info.
+ * - hideQueryParams See @link(commonsActionErrorContextToString) for additional info.
+ */
+declare function commonsErrorToString(error: ACommonsErrorBase, opts?: ErrorToStringOptionsType): string;
+/**
+ * Writes commons action error info from context as string.
+ * @param error Commons action error.
+ * @param opts Options for hiding parts of error:
+ * - hideItems Hides all item related information (item, form item, submit item, ...).
+ * - hideActionData Hides action data.
+ * - hideQueryParams Hides query params.
+ */
+declare function commonsActionErrorContextToString(error: ICommonsActionError, opts?: ActionErrorContextToStringOptionsType): string;
+/**
+ * Writes cause of an error as string.
+ * @param error Error.
+ * @param opts Options for hiding parts of error:
+ * - causeOnErrorOnly Prints only if cause is instance of error.
+ * - causeAsJson Print error cause as a JSON (by default, if error only message and name will be printed).
+ */
+declare function errorCauseToString(error: Error, opts?: ErrorCauseToStringOptionsType): string;
+/**
+ * Throws an error with the provided error message.
+ * The intended usage is for in-line throwing of an error with TS type narrowing.
+ * <br>
+ * <i>Example</i>:
+ * <pre>
+ *   const value: string | null = getValue("");
+ *   const nonNullValue: string = getValue("") ?? throwError("value missing");
+ * </pre>
+ *
+ * @param {string} errorMessage - The error message to be thrown.
+ * @param {CommonsErrorBaseOptions} [options] - Additional options for the thrown error.
+ * @throws {Error} - The error object with the provided error message.
+ * @returns {never} - This function does not return a value.
+ * @see CommonsErrorBaseOptions
+ */
+declare function throwError(errorMessage: string, options?: CommonsErrorBaseOptions): never;
+type ErrorToStringOptionsType = ErrorToStringOptionsBaseType & HttpErrorResponseToStringOptionsType & ActionErrorContextToStringOptionsType & ErrorCauseToStringOptionsType & {
+    hideDetails?: boolean;
+    hideLocation?: boolean;
+};
+interface ErrorToStringOptionsBaseType {
+    hideName?: boolean;
+    hideStack?: boolean;
+    hideCause?: boolean;
+    hideHttp?: boolean;
+}
+interface HttpErrorResponseToStringOptionsType {
+    hideMessage?: boolean;
+    hideHeaders?: boolean;
+    hideBody?: boolean;
+}
+interface ActionErrorContextToStringOptionsType {
+    hideItems?: boolean;
+    hideActionData?: boolean;
+    hideQueryParams?: boolean;
+}
+interface ErrorCauseToStringOptionsType {
+    causeOnErrorOnly?: boolean;
+    causeAsJson?: boolean;
+}
+
+declare function boolean$Attribute(value: unknown): Observable<boolean>;
+declare function booleanOrUndefinedAttribute(value: unknown): boolean | undefined;
+declare function number$Attribute(value: unknown): Observable<number>;
+declare const toObservable: <T>(value: T | Observable<T>) => Observable<T>;
+declare const itemIdToNumber: (value?: IdType) => number;
+declare const itemIdToString: (value?: IdType) => string;
+declare const itemIdToDefined: (value?: IdType) => IdType;
+declare const valueToDefined: <T>(value: Nullable<T>) => T;
+
+type toIsoStringTypeOptType = 'date' | 'date-time' | 'dateTime';
+type toIsoStringDateTimeOptsType = {
+    utc?: boolean;
+    noTimezone?: boolean;
+    noMillis?: boolean;
+};
+declare function dateToIsoString(value: string | number | Date, type?: 'date'): string;
+declare function dateToIsoString(value: string | number | Date, type: 'date-time' | 'dateTime', dateTimeOpts?: toIsoStringDateTimeOptsType): string;
+declare function dateToIsoString(value: undefined | null | unknown, type?: 'date'): null;
+declare function dateToIsoString(value: undefined | null | unknown, type: 'date-time' | 'dateTime', dateTimeOpts?: toIsoStringDateTimeOptsType): null;
+declare function dateToIsoString(value: unknown, type?: toIsoStringTypeOptType, dateTimeOpts?: toIsoStringDateTimeOptsType): string | null;
+declare function fromAngularDateFormatToPrime(ngDateFormat: string): string;
+declare function angularDateFormatHasTime(ngDateFormat: string): boolean;
+declare function angularDateFormatHasSeconds(ngDateFormat: string): boolean;
+
+type ToastMessageOptsType = {
+    messageService?: MessageService;
+    title?: string;
+    sticky?: boolean;
+    closable?: boolean;
+    icon?: string;
+};
+/**
+ * Displays a toast notification message with a specified severity level and optional customization. Presets the life of message and requires message.
+ *
+ * @param {string} message - The content of the toast message to be displayed.
+ * @param {'success' | 'warn' | 'warning' | 'error'} [severity='success'] - The severity level of the message.
+ * @param {ToastMessageOptsType} [opts] - Optional configuration for the toast message, which can include a title, icon, and message service for displaying the notification. If message service is provided, the message will be automatically added.
+ * @return {Message} - The notification message object created for the toast.
+ */
+declare function toastMessage(message: string, severity?: 'success' | 'warn' | 'warning' | 'error', opts?: ToastMessageOptsType): ToastMessageOptions;
+
+declare function fromAngularNumberFormatToFractions(format: string): {
+    integer: number;
+    fractionsMin: number;
+    fractionsMax: number;
+};
+
+interface DeepCopyPropsOptions {
+    mapGettersToProperties?: boolean;
+}
+interface DeepCopyOptions<P = object> extends DeepCopyPropsOptions {
+    objectPrototype?: ClassType<P>;
+}
+declare function objectDeepCopy<T = object, P = object>(obj: T, options: DeepCopyOptions<P> & {
+    mapGettersToProperties: true;
+}): T | Record<string, any>;
+declare function objectDeepCopy<T = object, P = object>(obj: T, options: DeepCopyOptions<P> & {
+    objectPrototype: ClassType<P>;
+} & {
+    mapGettersToProperties?: false;
+}): P;
+declare function objectDeepCopy<T = object, P = object>(obj: T, options: DeepCopyOptions<P> & {
+    objectPrototype: ClassType<P>;
+} & {
+    mapGettersToProperties: true;
+}): P | Record<string, any>;
+declare function objectDeepCopy<T = object, P = object>(obj: T, options?: DeepCopyOptions<P>): T;
+declare function objectDeepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any>;
+declare function getObjectProperties(obj: object): string[];
+declare function getObjectGetters(obj: any): string[];
+declare function getObjectPropertyByPath(value: any, path: string): any | undefined;
+declare function flattenObjectKeys(objectModel: any): string[];
+
+declare enum PermissionTypeEnum {
+    All = "ALL",
+    Any = "ANY",
+    Rbac = "ROLE_BASED_ACCESS_CONTROL",
+    Service = "SERVICE"
+}
+interface IActionContextValidation<Item, Service = undefined> {
+    descriptor: IActionDescriptor<Item, Service>;
+    parameters: ActionParameters<Item>;
+    serviceInstance: Service;
+    dataProvider?: IDataProvider<Item, Service>;
+}
+interface IPermissionService {
+    /**
+     * Determines whether a route can be activated.
+     *
+     * @param {ActivatedRouteSnapshot} route - The route snapshot object representing the current route for activation.
+     * @param {RouterStateSnapshot} state - The router state snapshot
+     *
+     * @returns {Observable<boolean>} - An observable that emits a boolean value indicating whether the route can be activated.
+     */
+    canActivateRoute(route?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): Observable<boolean>;
+    /**
+     * Determines the visibility of menu item.
+     *
+     * @param {CommonsMenuItem} menuItem - The menu item to check.
+     * @return {Observable<boolean>} - An observable that emits a boolean indicating
+     * whether the menu item is visible or not.
+     */
+    isMenuitemVisible(menuItem: CommonsMenuItem): Observable<boolean>;
+    /**
+     * Determines if the specified action is visible based on the action context and route.
+     *
+     * @param {IActionContextValidation<any, any>} [actionCtx] - The action context object containing the necessary information for validation.
+     * @param {ActivatedRouteSnapshot} [route] - The current route snapshot containing the necessary information for validation.
+     * @param {RouterStateSnapshot} state - The router state snapshot
+     *
+     * @return {Observable<boolean>} - An Observable that emits the visibility status of the action.
+     */
+    isActionVisible(actionCtx?: IActionContextValidation<any, any>, route?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): Observable<boolean>;
+}
+declare abstract class APermissions {
+    private readonly _authorizationType;
+    constructor(type: PermissionTypeEnum);
+    get authorizationType(): PermissionTypeEnum;
+}
+declare namespace Permissions {
+    class All extends APermissions {
+        private _permissions;
+        private constructor();
+        static of(...permissions: Array<APermissions>): All;
+        get permissions(): APermissions[];
+        and(...permissions: Array<APermissions>): this;
+    }
+    class Any extends APermissions {
+        private _permissions;
+        private constructor();
+        static of(...permissions: Array<APermissions>): Any;
+        get permissions(): APermissions[];
+        or(...permissions: Array<APermissions>): this;
+    }
+    class Roles extends APermissions {
+        private _roles;
+        private constructor();
+        static of(...roles: Array<string>): Roles;
+        get roles(): string[][];
+        and(...roles: Array<string>): this;
+        or(...roles: Array<string>): this;
+    }
+    class Service extends APermissions {
+        readonly service: Type<IPermissionService>;
+        private constructor();
+        static of(service: Type<IPermissionService>): Service;
+    }
+}
+
+interface CommonsMenuItem {
+    index?: number;
+    id?: string;
+    positionIndex?: number;
+    label?: string;
+    icon?: string;
+    items?: Array<CommonsMenuItem>;
+    permissions?: APermissions;
+    separator?: boolean;
+    className?: string;
+    badge?: string;
+    badgeClassName?: string;
+    isVisible?: ((menuItem: CommonsMenuItem) => Observable<boolean> | boolean) | boolean;
+    disabled?: boolean;
+    routerLink?: string | Array<string> | null;
+    href?: string;
+    hrefExternalIcon?: string | null;
+    target?: string;
+    queryParams?: {
+        [k: string]: any;
+    };
+    fragment?: string;
+    queryParamsHandling?: QueryParamsHandling;
+    preserveFragment?: boolean;
+    skipLocationChange?: boolean;
+    replaceUrl?: boolean;
+    updated?: boolean;
+    lazyChildren?: boolean;
+}
+type InternalCommonsMenuItem = Omit<CommonsMenuItem, 'key' | 'items' | 'lazyChildren' | 'visible'> & {
+    key: string;
+    config: CommonsMenuItem;
+    items: WritableSignal<InternalCommonsMenuItem[]>;
+    hasItems: Signal<boolean>;
+    itemsVisibility: WritableSignal<WritableSignal<boolean>[]>;
+    lazyChildren: WritableSignal<boolean>;
+    hasItemsOrLazyChildren: Signal<boolean>;
+};
+
+declare function removeRouteEmptyPathSegments(path: Array<string>): string[];
+declare function appendRoutePathToBasePath(basePath: Array<string>, path: Array<string>): string[];
+declare function doesUrlMatchRouterLink(link: Array<string> | string, url: Array<string> | string): boolean;
+declare function adjustRouteMenuLazyChildrenRouterLinks(rootMenuItem: MenuItem | InternalCommonsMenuItem, lazyChildren: Array<CommonsMenuItem>): {
+    index?: number;
+    id?: string;
+    positionIndex?: number;
+    label?: string;
+    icon?: string;
+    items?: Array<CommonsMenuItem>;
+    permissions?: _mediusinc_mng_commons_core.APermissions;
+    separator?: boolean;
+    className?: string;
+    badge?: string;
+    badgeClassName?: string;
+    isVisible?: ((menuItem: CommonsMenuItem) => rxjs.Observable<boolean> | boolean) | boolean;
+    disabled?: boolean;
+    routerLink?: string | Array<string> | null;
+    href?: string;
+    hrefExternalIcon?: string | null;
+    target?: string;
+    queryParams?: {
+        [k: string]: any;
+    };
+    fragment?: string;
+    queryParamsHandling?: _angular_router.QueryParamsHandling;
+    preserveFragment?: boolean;
+    skipLocationChange?: boolean;
+    replaceUrl?: boolean;
+    updated?: boolean;
+    lazyChildren?: boolean;
+}[];
+
+declare function escapeHtml(value: string): any;
+declare function escapeHtmlAny(value?: any): any;
+/**
+ * Stringifies a value - primitives with toString, dates with dateUtil, objects with JSON.stringify.
+ * @param value Any value.
+ */
+declare function stringify(value: any): string;
+
+declare function findTemplateByName(templates: TemplateDirective[], name: string): TemplateRef<any> | null;
+
+declare function getI18nAsync(translate: TranslateService, params?: any, ...keys: Array<string>): Observable<string | null>;
+declare function getI18n(translate: TranslateService, params?: any, ...keys: Array<string>): string | null;
+declare function populateI18nParams(item?: any, params?: any): any;
+declare function selectI18n(keys: string[], i18n: Translation): string | null;
+declare function narrowI18nToTranslation(i18n: StrictTranslation, keyOrIdx?: string | number): string | undefined;
+
+declare function getI18nForError(translate: TranslateService, error: Error, params?: any): string | null;
+declare function getI18nErrorParams(error: Error, params?: any): any;
+
+declare function getI18nTypeNameAsync(translate: TranslateService, typeName: string, singular?: boolean): Observable<string | null>;
+declare function getI18nTypeName(translate: TranslateService, typeName: string, singular?: boolean): string | null;
+declare function getI18nTypeTabKey(typeName: string, tab: string): string;
+declare function getI18nTypeGroupKey(typeName: string, group: string): string;
+declare function getI18nTypePropertyKey(typeName: string, property: string): string;
+declare function getI18nTypeKeyBasePath(typeName: string, ...path: Array<string>): string;
+declare function getI18nTypeParams(translate: TranslateService, typeName?: string, item?: any, params?: any): any;
+declare function getI18nTypeParamsAsync(translate: TranslateService, typeName?: string, item?: any, params?: any): Observable<any>;
+declare function populateI18nTypeParams(i18nTypeName?: string, item?: any, params?: any): any;
+
+declare class LogPublisherConsoleService implements ILogPublisher {
+    addEntry(entry: LogEntry): void;
+}
+
+type VersionConfigType = VersionConfig | VersionInfo | string | Array<VersionConfig> | undefined;
+type VersionConfig = {
+    source: 'info' | 'httpResource' | 'config';
+    displayName?: string;
+} & (VersionConfigFromInfo | VersionConfigFromHttpResource | VersionConfigFromConfiguration);
+interface VersionConfigFromInfo {
+    source: 'info';
+    info: VersionInfo | string;
+}
+interface VersionConfigFromHttpResource {
+    source: 'httpResource';
+    urlPath: string;
+    urlBaseConfigKey?: string;
+    infoJsonPath?: string;
+}
+interface VersionConfigFromConfiguration {
+    source: 'config';
+    configKey: string;
+}
+interface VersionInfo {
+    source?: undefined;
+    name: string;
+    version: string | null;
+    tag: string | null;
+    distance: number | null;
+    hash: string | null;
+    dirty: boolean;
+    semver: string | null;
+    raw: string;
+    buildTimestamp: number | null;
+}
+
+type ColorScheme = 'light' | 'dark' | 'auto';
+interface CommonsModuleConfig {
+    app?: {
+        name?: string;
+        owner?: string;
+        locales?: string[];
+        dataLocales?: string[];
+        version?: VersionConfigType;
+    };
+    configuration?: {
+        projectEnvironment?: any;
+        jsonSource?: string | Array<string>;
+        skipJsonSourceInit?: boolean;
+        jsonSourceEnableEnvProd?: boolean;
+    };
+    serialization?: CommonsSerializationConfig;
+    log?: LogConfig;
+}
+interface CommonsSerializationConfig {
+    dateTimeInUtc?: boolean;
+    dateTimeWithTimezone?: boolean;
+    dateTimeWithMillis?: boolean;
+    filtersDateOnlyDisabled?: boolean;
+}
+declare const COMMONS_MODULE_CONFIG_IT: InjectionToken<CommonsModuleConfig>;
+
+declare class CommonsConfigurationService {
+    private static _instance;
+    static get(): CommonsConfigurationService;
+    private logger?;
+    private http?;
+    private moduleConfig?;
+    private projectEnvironment?;
+    private jsonSources;
+    private objectSources;
+    private configuration;
+    private constructor();
+    init(httpClient: HttpClient, logger?: ILoggerService): this;
+    /**
+     * Add commons module config.
+     * @param config Module config.
+     */
+    addModuleConfigSource(config?: CommonsModuleConfig): void;
+    /**
+     * Add project environment source.
+     * @param environment Environment.
+     */
+    addEnvironmentSource(environment: any): void;
+    /**
+     * Adds new config source from JSON file loaded from HTTP.
+     * @param config Config for JSON file.
+     * @param loadImmediately Load is by default triggered on app initialization. If immediate load is required, pass true.
+     */
+    addJsonSource(config?: {
+        url?: string;
+        enableEnvProd?: boolean;
+    }, loadImmediately?: boolean): Observable<boolean>;
+    /**
+     * Adds new config object from any object.
+     * @param config Config object.
+     */
+    addObjectSource(config: any): void;
+    /**
+     * returns true if there is no jsonSources
+     */
+    private skipJsonConfigsLoading;
+    /**
+     * loads json sources or skips them returning true in both cases
+     * used for `skipJsonSourceInit` configuration parameter
+     */
+    loadJsonConfigurations: () => Observable<boolean>;
+    private loadJsonSources;
+    /**
+     * Get configuration.
+     */
+    getConfig(): any;
+    /**
+     * Get configuration value for key.
+     * @param key Configuration key.
+     */
+    getConfigValue<T = any>(key: string): T | null;
+    /**
+     * Gets the configuration value for the given key. If the value is not found,
+     * it throws an error with a custom error message.
+     *
+     * @param {string} key - The configuration key.
+     * @param {string} [errorMessage] - Custom error message to be thrown if the value is not found.
+     *
+     * @returns {T} - The configuration value.
+     *
+     * @throws {CommonsInternalError} - If the value is not found or a custom error message is provided.
+     */
+    getConfigValueOrThrow<T = any>(key: string, errorMessage?: string): T;
+    /**
+     * Has configuration for key.
+     * @param key Configuration key.
+     */
+    hasConfigKey(key: string): boolean;
+    /**
+     * Merges configuration from multiple sources with
+     */
+    private mergeConfigs;
+}
+
+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;
+}
+
+interface ClassAttributeDef {
+    name: string;
+    baseName: string;
+    type: string;
+    subtype?: string;
+}
+
+type GetterFn<Value = Nullable<any>, Item = any, ReturnType = any> = (value: Value, item: Item) => ReturnType;
+
+type I18nMissingTranslationStrategy = 'returnNull' | 'returnFallbackKey' | 'returnFirstKey';
+
+interface IUser {
+    id: IdType;
+    username: string;
+    displayName?: string;
+    logout?: () => void;
+    logoutUrl?: string;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+declare function getEnumerationI18nBaseKey(baseKey: string): string;
+declare function selectEnumerationI18n(value: EnumeratePipeI18nInternal, baseKey: string): string;
+declare function toEnumerationI18nEnumerate(value: unknown, jsonPath: string, baseKey: string): EnumeratePipeI18nInternal;
+interface EnumeratePipeI18nInternal {
+    value: string;
+    i18nKey: string;
+    i18n: string;
+}
+
+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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+/**
+ * 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])
+ */
+declare class JsonPathPipe implements PipeTransform {
+    transform(value: any, path?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonPathPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<JsonPathPipe, "mngJsonPath", true>;
+}
+
+type TransformOptsType = {
+    encodeParams?: boolean;
+};
+declare class ParametrizePipe implements PipeTransform {
+    private jsonPath;
+    transform(value: unknown, itemId?: IdType, item?: any, data?: Record<string, any>, opts?: TransformOptsType): any;
+    private transformString;
+    private parametrizeStringAsRouterLink;
+    private parametrizeString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParametrizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ParametrizePipe, "mngParametrize", true>;
+}
+
+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>;
+}
+
+type EffectWithDepsValues<T> = {
+    [K in keyof T]: () => T[K];
+};
+/**
+ * Effect function with explicit declaration of dependencies. Dependencies will be tracked, whereas the main execution will not be.
+ *
+ * @param deps Array of dependencies to be tracked.
+ * @param fn Function where dependencies will no longer be tracked.
+ * @param opts Additional options:
+ *   - firstOnly Executes effect only once, then destroy it.
+ */
+declare function effectWithDeps<Input extends readonly unknown[], Params = Input>(deps: readonly [...EffectWithDepsValues<Input>], fn: (deps: Params) => void, opts?: {
+    firstOnly?: boolean;
+}): EffectRef;
+
+declare function TypeName(typeName: string): ClassDecorator;
+declare function EnumName(typeName: string): ClassDecorator;
+
+declare const reflectTypeNameKey = "typeName";
+declare const reflectEnumNameKey = "enumName";
+/**
+ * Defines type name decorator.
+ * @param targetType class.
+ * @param typeName Name of the type.
+ */
+declare function defineReflectTypeName(targetType: ClassType<any>, typeName: string): void;
+/**
+ * Defines enum name decorator.
+ * @param targetType enum object.
+ * @param enumName Name of the enum.
+ */
+declare function defineReflectEnumName(targetType: EnumType, enumName: string): void;
+/**
+ * Gets type name from reflect metadata.
+ * @param type Class.
+ */
+declare function findReflectTypeName<T>(type?: ClassType<T>): string | null;
+/**
+ * Gets type name from either decorator or reflect metadata.
+ * @param type Class.
+ */
+declare function reflectTypeNameExists(type: ClassType<any>): boolean;
+/**
+ * Gets enum name from either decorator or reflect metadata.
+ * @param enumType Class.
+ */
+declare function findReflectEnumName(enumType: EnumType): string | null;
+
+interface RegistryTypeMap {
+    [index: string]: ClassType<any>;
+}
+interface RegistryEnumMap {
+    [index: string]: EnumType;
+}
+
+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;
+}
+
+type BreadcrumbType = string | string[] | BreadcrumbMenuItem | BreadcrumbMenuItem[] | ((routeUrl: string, route: ActivatedRouteSnapshot) => BreadcrumbMenuItem[]);
+interface BreadcrumbMenuItem extends CommonsMenuItem {
+    isHome?: boolean;
+}
+interface CommonsRouteData extends Data {
+    breadcrumb?: BreadcrumbType | null;
+    pageTitle?: string;
+    menuItems?: Array<CommonsMenuItem>;
+    permissions?: APermissions;
+}
+
+declare class RoutesBuilder {
+    private routes;
+    /**
+     * Adds an Angular route to the current route configuration.
+     *
+     * @param {Route} route - The Angular route object to be added.
+     * @param {RouteBuilderAdjustFnType} [builderAdjustFn] - Optional function to adjust the route builder before adding.
+     */
+    addFromNgRoute(route: Route, builderAdjustFn?: RouteBuilderAdjustFnType): this;
+    /**
+     * Adds a route redirect to the Angular route.
+     *
+     * @param {string} path - The path for the redirect.
+     * @param {string} redirectTo - The target route to redirect.
+     * @param {'full' | 'prefix'} pathMatch - The matching strategy for the redirect. Default is 'prefix'.
+     */
+    addRedirect(path: string, redirectTo: string, pathMatch?: 'full' | 'prefix'): this;
+    /**
+     * Adds a route to the routes.
+     *
+     * @param {RouteBuilder} routeBuilder - The route builder object representing the route to be added.
+     */
+    add(routeBuilder: RouteBuilder): this;
+    build(): Routes;
+}
+/**
+ * Creates a new instance of the RoutesBuilder class.
+ *
+ * @return {RoutesBuilder} A new instance of the RoutesBuilder class.
+ */
+declare function createRoutes(): RoutesBuilder;
+
+type RouteBuilderAdjustFnType = (builder: RouteBuilder) => void;
+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 permissions?;
+    constructor(route: Route);
+    /**
+     * Sets the link to root Routes builder.
+     *
+     * @param {RoutesBuilder} routesBuilder - The routes builder to set as the root.
+     */
+    withRoot(routesBuilder: RoutesBuilder): this;
+    /**
+     * Sets the link to parent Route builder.
+     *
+     * @param {RouteBuilder} parent - The parent route builder.
+     */
+    withParent(parent: RouteBuilder): this;
+    /**
+     * Sets the breadcrumb.
+     *
+     * @param {BreadcrumbType} breadcrumb - Breadcrumb configuration.
+     */
+    withBreadcrumb(breadcrumb: BreadcrumbType): this;
+    /**
+     * Sets the page title for the current route.
+     *
+     * @param {string} pageTitle - The title of the page.
+     */
+    withPageTitle(pageTitle: string): this;
+    /**
+     * Sets the page title and the breadcrumb.
+     *
+     * @param {string} title - The title of the page and breadcrumb.
+     */
+    withTitle(title: string): this;
+    /**
+     * Adds a can activate guard to route.
+     *
+     * @param {CanActivateFn} fn - The CanActivate function to be added.
+     */
+    withCanActivate(fn: CanActivateFn): this;
+    /**
+     * Adds a can deactivate guard to route.
+     *
+     * @param {CanDeactivateFn} fn - The CanActivate function to be added.
+     */
+    withCanDeactivate(fn: CanDeactivateFn<any>): this;
+    /**
+     * Adds a resolver to route.
+     *
+     * @param {string} name - Name of the resolver.
+     * @param {CanDeactivateFn} fn - The CanActivate function to be added.
+     */
+    withResolver(name: string, fn: ResolveFn<any>): this;
+    /**
+     * Adds a provider to the route.
+     *
+     * @param {Provider | EnvironmentProviders} provider - The provider to add.
+     */
+    withProvider(provider: Provider | EnvironmentProviders): this;
+    /**
+     * Sets the data for the route.
+     *
+     * @param {CommonsRouteData} data - The data to set for the route.
+     * @param {boolean} [merge=true] - If the data should be merged with current data setup (true by default) - page title and breadcrumb config are carried over.
+     */
+    withData(data: CommonsRouteData, merge?: boolean): this;
+    /**
+     * Updates the menu item of route. Merging with current configuration (set with {withMenuItem}) takes place.
+     *
+     * @param {CommonsMenuItem} opts - The opts properties to be merged on existing menu item for route.
+     */
+    withMenuItemOpts(opts: CommonsMenuItem): this;
+    /**
+     * Sets the menu item (basic). For more options, see the {withMenuItemFromOpts}.
+     *
+     * @param {string} [icon] - The icon for the menu item.
+     * @param {string} [label] - The label for the menu item.
+     * @param {Array<string>} [routerLink] - The router link for the menu item.
+     * @param {boolean} [breadcrumb=false] - Indicates whether to display breadcrumb for the menu item.
+     */
+    withMenuItem(icon?: string, label?: string, routerLink?: Array<string>, breadcrumb?: boolean): this;
+    /**
+     * Adds menu item child to route's menu item. If no menu item is present, children will be appended directly to parent/root menu item.
+     *
+     * @param {string} [icon] - The icon for the menu item.
+     * @param {string} [label] - The label for the menu item.
+     * @param {Array<string>} [routerLink] - The router link for the menu item.
+     * @param {boolean} [afterRouteChildren=false] If false, menu item child will be appended before route's children menu items, at the end otherwise.
+     */
+    withMenuItemChild(icon?: string, label?: string, routerLink?: Array<string>, afterRouteChildren?: boolean): this;
+    /**
+     * Adds menu item child from opts to route's menu item. If no menu item is present, children will be appended directly to parent/root menu item.
+     *
+     * @param {CommonsMenuItem} opts - The opts properties to be merged on existing menu item for route.
+     * @param {boolean} [afterRouteChildren=false] If false, menu item child will be appended before route's children menu items, at the end otherwise.
+     */
+    withMenuItemChildFromOpts(opts: CommonsMenuItem, afterRouteChildren?: boolean): this;
+    /**
+     * Sets the menu item's children to be generated lazily from route's lazy loaded routes after the chunk is loaded to runtime.
+     */
+    withMenuItemLazyChildren(): this;
+    /**
+     * Sets the permissions on the route.
+     *
+     * @param {APermissions} permissions - The permissions to be set on the route.
+     */
+    withPermissions(permissions: APermissions): this;
+    /**
+     * Adds a child route to the current route.
+     *
+     * @param {string} path - The path of the child route.
+     * @param {Type<any>} component - The component associated with the child route.
+     * @param {RouteBuilderAdjustFnType} [adjustFn] - An optional function to adjust the child route builder.
+     */
+    addChild(path: string, component: Type<any>, adjustFn?: RouteBuilderAdjustFnType): this;
+    /**
+     * Adds a child builder to the current route.
+     *
+     * @param {RouteBuilder} builder - The child builder to be added.
+     * @return {this} - The current builder with the added child builder.
+     */
+    addChildBuilder(builder: RouteBuilder): this;
+    /**
+     * Builds an Angular route based on configurations.
+     *
+     * @returns {Route} The built Angular route.
+     */
+    build(): Route;
+    /**
+     * Builds the menu items.
+     *
+     * @returns {Array<CommonsMenuItem>} - The built menu items.
+     */
+    private buildMenu;
+    protected findMenuItemPermissions(): APermissions | undefined;
+}
+/**
+ * Creates a new instance of RouteBuilder with the given path and component.
+ *
+ * @param {string} path - The path for the route.
+ * @param {Type<any>} component - The component for the route.
+ * @return {RouteBuilder} - A new instance of RouteBuilder.
+ */
+declare function createRoute(path: string, component: Type<any>): RouteBuilder;
+/**
+ * Creates a redirect route for the given path.
+ *
+ * @param {string} path - The path to match against.
+ * @param {string} redirectTo - The URL path to redirect to.
+ * @param {'full' | 'prefix'} [pathMatch='prefix'] - The path matching strategy ('full' or 'prefix').
+ * @return {RouteBuilder} - A new instance of the RouteBuilder class with the redirect route configuration.
+ */
+declare function createRouteRedirect(path: string, redirectTo: string, pathMatch?: 'full' | 'prefix'): RouteBuilder;
+/**
+ * Creates a lazy route module (or routes).
+ *
+ * @param {string} path - The path for the route.
+ * @param {LoadChildren} loadChildren - The function that loads the lazy module (or routes).
+ * @param {Array<any>} [canMatch] - An optional array of objects that can match the route.
+ * @returns {RouteBuilder} - A new instance of RouteBuilder class.
+ */
+declare function createChildrenLazyRoute(path: string, loadChildren: LoadChildren, canMatch?: Array<any>): RouteBuilder;
+/**
+ * Creates a lazy route component.
+ *
+ * @param {string} path - The path for the route.
+ * @param {() => Type<unknown> | Observable<Type<unknown> | DefaultExport<Type<unknown>>> | Promise<Type<unknown> | DefaultExport<Type<unknown>>>} loadComponent - The function that loads the component for the route.
+ * @param {Array<any>} [canMatch] - The array of values that determine if the route can match.
+ * @returns {RouteBuilder} - An instance of RouteBuilder with the created route.
+ */
+declare function createLazyRoute(path: string, loadComponent: () => Type<unknown> | Observable<Type<unknown> | DefaultExport<Type<unknown>>> | Promise<Type<unknown> | DefaultExport<Type<unknown>>>, canMatch?: Array<any>): RouteBuilder;
+
+/**
+ * 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.
+ */
+declare function mapToDataList<Item>(): OperatorFunction<{
+    data?: Item[];
+    totalCount?: number;
+}, DataListResult<Item>>;
+
+declare const permissionGuard: CanActivateFn;
+
+declare class PermissionService {
+    private readonly injector;
+    private readonly commons;
+    private readonly logger;
+    private userRoles$;
+    canActivateRoute(permissions: APermissions, route?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): Observable<boolean>;
+    private canActivateRouteAll;
+    private canActivateRouteAny;
+    private canActivateRouteService;
+    isMenuItemVisible(permissions: APermissions, menuItem: CommonsMenuItem): Observable<boolean>;
+    private isMenuItemVisibleAll;
+    private isMenuItemVisibleAny;
+    private isMenuItemVisibleService;
+    isActionVisible(permissions: APermissions, actionCtx?: IActionContextValidation<any, any>, route?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): Observable<boolean>;
+    private isActionVisibleAll;
+    private isActionVisibleAny;
+    private isActionVisibleService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionService>;
+}
+
+declare function isPermitted(permissions: APermissions, userRoles: Array<string>): boolean;
+declare function isRbacPermitted(permissions: Permissions.Roles, userRoles: Array<string>): boolean;
+
+declare enum CommonsInitEventEnum {
+    CommonsInitStart = 0,
+    ConfigSourceModuleLoaded = 1,
+    ConfigSourceProjectEnvLoaded = 2,
+    ConfigSourceJsonAdded = 3,
+    ConfigSourceJsonLoaded = 4,
+    CommonsInitEnd = 5,
+    CommonsInitError = 6
+}
+declare class CommonsInitService {
+    private readonly logger;
+    private readonly logPublishers;
+    private readonly config;
+    private readonly commons;
+    private readonly commonsRouter;
+    private readonly moduleConfig;
+    private readonly commonsInitializers;
+    private isInitialized;
+    private httpClient;
+    private isInitializedSubject;
+    private commonsInitServiceEvents;
+    get events$(): Observable<CommonsInitEventEnum>;
+    get isInitialized$(): Observable<boolean>;
+    initialize(handler: HttpBackend): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommonsInitService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommonsInitService>;
+}
+
+declare function commonsInitializerProvider(handler: HttpBackend, commonsInit: CommonsInitService): () => Observable<void>;
+
+declare const BROWSER_STORAGE_IT: InjectionToken<Storage>;
+
+declare const COMMONS_INITIALIZER_IT: InjectionToken<readonly (() => Observable<unknown>)[]>;
+
+declare const LOG_PUBLISHERS: InjectionToken<ILogPublisher[]>;
+
+declare class CommonsService {
+    private readonly logger;
+    private readonly router;
+    private readonly primengConfig;
+    private readonly translate;
+    private readonly titleService;
+    private readonly moduleConfig;
+    private readonly localStorage;
+    private readonly destroyRef;
+    readonly breadcrumbHome: i0.WritableSignal<CommonsMenuItem | null>;
+    readonly breadcrumbs: i0.WritableSignal<CommonsMenuItem[]>;
+    private breadcrumbsTranslateSubscription?;
+    private breadcrumbHomeTranslateSubscription?;
+    user: i0.WritableSignal<IUser | undefined>;
+    userRoles: i0.WritableSignal<string[]>;
+    appName: i0.WritableSignal<string>;
+    appOwner: i0.WritableSignal<string>;
+    getDefaultLocale(): string;
+    appLocales: i0.WritableSignal<string[]>;
+    private _appLocale;
+    appLocale: i0.Signal<string>;
+    private initAppLocale;
+    setAppLocale(language: string): void;
+    clearAppLocale(): void;
+    appDataLocales: i0.WritableSignal<string[]>;
+    private _appDataLocale;
+    appDataLocale: i0.Signal<string>;
+    private initAppDataLocale;
+    setAppDataLocale(dataLocale: string): void;
+    clearAppDataLocale(): void;
+    appVersion: i0.WritableSignal<_mediusinc_mng_commons_core.VersionConfigType>;
+    constructor();
+    initialize(): void;
+    findBreadcrumbItem(item: CommonsMenuItem): CommonsMenuItem | null;
+    updateBreadcrumbItem(item: CommonsMenuItem): boolean;
+    private updateBreadcrumbs;
+    private generateHomeBreadcrumb;
+    private generateBreadcrumbs;
+    private createBreadcrumb;
+    setPageTitle(title?: string): void;
+    private formatPageTitle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommonsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommonsService>;
+}
+
+declare class CommonsRouterService {
+    private readonly router;
+    private readonly logger;
+    private readonly routesLoadedPropKey;
+    private currentNavigationPath?;
+    private currentNavigationModuleKeys;
+    private lazyLoadedRoutesConfig;
+    constructor();
+    getRouteLoadedChildren(path: string | Array<string>): Routes | undefined;
+    getRouteLoadedChildren$(path: string | Array<string>): Observable<Routes>;
+    initialize(): void;
+    private startNavigation;
+    private finishNavigation;
+    private markNavigationConfigLoad;
+    private getLoadedRoutesFromRoute;
+    /**
+     * Search for route config by module path by recursive scanning of router config tree.
+     * @param modulePath Path of module that is searched.
+     * @param routes Routes to be scanned. If not provided, it starts on root router config.
+     * @private
+     */
+    private findRouteInRouteConfig;
+    /**
+     * Finds longest path match of source to match string. If match is '', it is considered as a match in Angular routing.
+     * @param source Source string from on which comparison is based.
+     * @param match Match string to which the source is matched to.
+     * @private
+     */
+    private findLongestPathMatch;
+    private getOrCreateRouteForModule;
+    private getModulePathFromRouterLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommonsRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommonsRouterService>;
+}
+
+type LocalstorageConfigValueType = string | number | Date | object | boolean;
+declare class CommonsStorageService {
+    private readonly localStorage;
+    private readonly _configKey;
+    private buildLocalStorageKey;
+    getItem<T = LocalstorageConfigValueType>(type: string, key: string): T | undefined;
+    setItem<T = LocalstorageConfigValueType>(type: string, key: string, value: T): void;
+    removeItem(type: string, key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommonsStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommonsStorageService>;
+}
+
+declare enum StyleSizeEnum {
+    ExtraSmall = 0,
+    Small = 1,
+    Normal = 2,
+    Large = 3,
+    ExtraLarge = 4
+}
+declare enum StyleLevelEnum {
+    Default = 0,
+    Primary = 1,
+    Secondary = 2,
+    Info = 3,
+    Help = 4,
+    Success = 5,
+    Warning = 6,
+    Danger = 7,
+    Contrast = 8
+}
+
+declare class Styles {
+    static readonly BUTTON_ROUNDED_WIDTH_XS = 28;
+    static readonly BUTTON_ROUNDED_WIDTH_SM = 31.5;
+    static readonly BUTTON_ROUNDED_WIDTH = 35;
+    static readonly BUTTON_ROUNDED_WIDTH_LG = 38.5;
+    static readonly BUTTON_ROUNDED_WIDTH_XL = 42;
+    static readonly ACTION_BUTTON_MARGIN_X = 2.1;
+    static readonly TABLE_CELL_PADDING_X_SM = 7;
+    static readonly TABLE_CELL_PADDING_X = 14;
+    static readonly TABLE_CELL_PADDING_X_LG = 17.5;
+}
+
+declare enum CommonsFeatureTypeEnum {
+    Layout = 0,
+    Table = 1,
+    Tableview = 2,
+    DataApiAsClassV1 = 3
+}
+interface CommonsFeature {
+    type: CommonsFeatureTypeEnum;
+    providers: (Provider | EnvironmentProviders)[];
+}
+declare function provideCommons(config?: CommonsModuleConfig, ...features: CommonsFeature[]): (Provider | EnvironmentProviders)[];
+
+export { ACommonsErrorBase, APermissions, BROWSER_STORAGE_IT, BooleanPipe, COMMONS_INITIALIZER_IT, COMMONS_MODULE_CONFIG_IT, ClassMapPipe, CommonsConfigurationService, CommonsErrorHandler, CommonsFeatureTypeEnum, CommonsHttpError, CommonsInitEventEnum, CommonsInitService, CommonsInternalError, CommonsRouterService, CommonsService, CommonsStorageService, ComponentDirective, DataProviderInst, EnumName, EnumPipe, EnumerateAsyncPipe, EnumeratePipe, FilterMatchMode, GetterPipe, I18nPropertyPipe, JsonPathPipe, LOG_PUBLISHERS, LogLevelEnum, LogPublisherConsoleService, LoggerService, NotificationWrapperComponent, ParametrizePipe, PermissionService, PermissionTypeEnum, Permissions, RerenderDirective, RouteBuilder, RoutesBuilder, StyleLevelEnum, StyleSizeEnum, Styles, TemplateDirective, TemplatePipe, TypeName, TypeRegistry, adjustRouteMenuLazyChildrenRouterLinks, angularDateFormatHasSeconds, angularDateFormatHasTime, appendRoutePathToBasePath, boolean$Attribute, booleanOrUndefinedAttribute, commonsActionErrorContextToString, commonsErrorToString, commonsInitializerProvider, copyDataListParams, createChildrenLazyRoute, createLazyRoute, createRoute, createRouteRedirect, createRoutes, dataListParamsFilterToUrlQuery, dataListParamsFilterValueToUrlString, dataListParamsFiltersToUrlQuery, dataListParamsSortToUrlQuery, dataListParamsToUrlQuery, dateToIsoString, defineReflectEnumName, defineReflectTypeName, doesUrlMatchRouterLink, effectWithDeps, errorCauseToString, errorToString, escapeHtml, escapeHtmlAny, findReflectEnumName, findReflectTypeName, findTemplateByName, flattenObjectKeys, fromAngularDateFormatToPrime, fromAngularNumberFormatToFractions, fromEnumConstantsAsValueArray, fromEnumValuesAsValueArray, fromSubscribeError, fromTableLoadToDataListParams, fromUrlQueryToDataListParams, getEnumConstantName, getEnumConstantNameFromObject, getEnumConstantNames, getEnumConstantNamesFromObject, getEnumConstantValues, getEnumConstantValuesAsNumber, getEnumConstantValuesAsString, getEnumerationI18nBaseKey, getErrorLogLevel, getErrorName, getHttpErrorResponse, getHttpErrorResponseStatus, getHttpErrorResponseStatusText, getI18n, getI18nAsync, getI18nErrorParams, getI18nForError, getI18nTypeGroupKey, getI18nTypeKeyBasePath, getI18nTypeName, getI18nTypeNameAsync, getI18nTypeParams, getI18nTypeParamsAsync, getI18nTypePropertyKey, getI18nTypeTabKey, getObjectGetters, getObjectProperties, getObjectPropertyByPath, httpErrorResponseToString, isHttpErrorResponse, isPermitted, isRbacPermitted, itemIdToDefined, itemIdToNumber, itemIdToString, mapToDataList, mergeDataListParamsWithDefaults, narrowI18nToTranslation, number$Attribute, objectDeepCopy, objectDeepMerge, permissionGuard, populateI18nParams, populateI18nTypeParams, provideCommons, reflectEnumNameKey, reflectTypeNameExists, reflectTypeNameKey, removeRouteEmptyPathSegments, selectEnumerationI18n, selectI18n, stringify, throwError, toEnumerationI18nEnumerate, toObservable, toastMessage, valueToDefined };
+export type { ActionData, ActionErrorContextToStringOptionsType, ActionParameters, ArrayItemType, BreadcrumbMenuItem, BreadcrumbType, ClassAttributeDef, ClassFunctionKeyParam1ObjKeyExtendsOfTargetType, ClassFunctionKeysType, ClassFunctionKeysWithAnyArgsAndReturnType, ClassFunctionKeysWithParamAndReturnType, ClassFunctionKeysWithReturnType, ClassOptType, ClassType, ColorScheme, CommonKeyof3, CommonPropsObjType3, CommonsErrorBaseOptions, CommonsFeature, CommonsFilterMetadata, CommonsMenuItem, CommonsModuleConfig, CommonsRouteData, CommonsSerializationConfig, DataListFilter, DataListFilterBaseValueType, DataListFilterFromUrlValueType, DataListFilterValueType, DataListFiltersType, DataListParams, DataListResult, DataListSort, DeepCopyOptions, EnumConstantType, EnumFromProperty, EnumType, EnumValue, EnumeratePipeI18nInternal, ErrorCauseToStringOptionsType, ErrorToStringOptionsBaseType, ErrorToStringOptionsType, ErrorTypes, FilterMatchModeExtendedType, FilterMatchModeType, GetterFn, HttpErrorResponseToStringOptionsType, I18nMissingTranslationStrategy, IActionContextValidation, IActionDescriptor, IColumnDescriptor, ICommonsActionError, ICommonsActionErrorContext, ICommonsError, IDataProvider, IEditorDescriptor, IEnumDescriptor, IFilterDescriptor, ILogPublisher, ILoggerService, ILookupDataProvider, ILookupDataProviderLookup, ILookupDescriptor, IModelDescriptor, IPermissionService, ITableDescriptor, ITableviewDescriptor, IUser, IdType, InternalCommonsMenuItem, ItemOrObservable, KeyOfType, KeyofAndOfType, LocalstorageConfigValueType, LogConfig, LogEntry, LookupDataProviderLookupFnType, Nullable, ObjectOptPropType, PrimitiveType, PropertyType, RegistryEnumMap, RegistryTypeMap, RouteBuilderAdjustFnType, ServiceClassOptType, ServiceClassType, SingleOrArrayType, Undefined, VersionConfig, VersionConfigFromConfiguration, VersionConfigFromHttpResource, VersionConfigFromInfo, VersionConfigType, VersionInfo, toIsoStringDateTimeOptsType, toIsoStringTypeOptType };