@mediusinc/mng-commons 4.2.0 → 5.0.0-rc.0

package/README.md

@@ -26,6 +26,7 @@ V tabeli so navedene kompatibilne verzije za commons knjižnico in povezane odvi
 
 | Commons | Angular | PrimeNG | Ngx-translate | Ngx-formly | Node                                 |
 |---------|---------|---------|---------------|------------|--------------------------------------|
+| 5.x.x   | 17.x.x  | 17.x.x  | 14.x.x        | 6.x.x      | ^18.13.0 \|\| ^20.9.0                |
 | 4.x.x   | 17.x.x  | 17.x.x  | 14.x.x        | 6.x.x      | ^18.13.0 \|\| ^20.9.0                |
 | 3.x.x   | 16.x.x  | 16.x.x  | 14.x.x        | 6.x.x      | ^16.14.0 \|\| ^18.10.0               |
 | 2.x.x   | 15.x.x  | 15.x.x  | 14.x.x        | 6.x.x      | ^14.20.0 \|\| ^16.13.0 \|\| ^18.10.0 |

package/core/README.md

@@ -0,0 +1,8 @@
+# @mediusinc/mng-commons/core
+
+Secondary entry point of `@mediusinc/mng-commons`. It can be used by importing from `@mediusinc/mng-commons/core`.
+
+## Dependencies within commons
+
+_This entry point has no other dependencies._
+

package/core/action/action-data.model.d.ts

@@ -0,0 +1,3 @@
+export type ActionData = {
+    [key: string]: any;
+};

package/core/action/action-parameters.model.d.ts

@@ -0,0 +1,17 @@
+import { ActivatedRoute } from '@angular/router';
+import { DataListParams } from '../data-list/data-list.model';
+import { IdType } from '../helpers/type-helpers';
+import { ActionData } from './action-data.model';
+export interface ActionParameters<Item> {
+    itemId?: IdType;
+    item?: Item;
+    actionData?: ActionData;
+    dataListParams?: DataListParams<any, any>;
+    sourceComponent?: any;
+    hostComponent?: unknown;
+    route?: ActivatedRoute;
+    selectedItems?: Item[];
+    locale?: string;
+    formItem?: Item | null;
+    submitResult?: Item | null;
+}

package/core/components/pages/error/error.page.component.d.ts

@@ -0,0 +1,8 @@
+import { CommonsService } from '../../../services/commons.service';
+import * as i0 from "@angular/core";
+export declare class ErrorPageComponent {
+    commons: CommonsService;
+    constructor(commons: CommonsService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorPageComponent, "mng-error-page", never, {}, {}, never, never, true, never>;
+}

package/core/components/pages/not-found/not-found.page.component.d.ts

@@ -0,0 +1,8 @@
+import { CommonsService } from '../../../services/commons.service';
+import * as i0 from "@angular/core";
+export declare class NotFoundPageComponent {
+    commons: CommonsService;
+    constructor(commons: CommonsService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotFoundPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotFoundPageComponent, "mng-not-found-page", never, {}, {}, never, never, true, never>;
+}

package/core/data-list/data-list-params.util.d.ts

@@ -0,0 +1,84 @@
+import { Params } from '@angular/router';
+import { TableLazyLoadEvent } from 'primeng/table';
+import { DataListFilter, DataListParams } from './data-list.model';
+export declare class DataListParamsUtil {
+    /**
+     * Converts a TableLazyLoadEvent to DataListParams.
+     *
+     * @param {TableLazyLoadEvent} event - The event containing the data to convert.
+     * @return {DataListParams} - The converted DataListParams object.
+     */
+    static fromPrimeTableLoad(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.
+     * @returns {Params} - The URL query parameters object.
+     */
+    static toUrlQueryParams(params: DataListParams<any, any>, defaults?: DataListParams<any, any> | null): 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.
+     */
+    static mergeWithDefaults<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.
+     */
+    static sortToUrlQuery(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.
+     */
+    static paramsFilterToUrlQuery<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.
+     */
+    static filterToUrlQuery(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.
+     * @return {DataListParams} - The converted DataListParams object.
+     */
+    static fromUrlQueryParams(urlParams: Params): 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.
+     */
+    static copy<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).
+     */
+    static filterValueToUrlParam(value: unknown, allowNull?: boolean): string;
+}

package/core/data-list/data-list.model.d.ts

@@ -0,0 +1,27 @@
+import { FilterMatchModeExtendedType } from './filter-match.model';
+export interface DataListParams<Sorts = string, Filters extends keyof any = string> {
+    offset?: number;
+    limit?: number;
+    sort?: DataListSort<Sorts>[];
+    search?: string;
+    filters?: DataListFiltersType<Filters>;
+}
+export interface DataListSort<Property = string> {
+    property: Property;
+    ascending?: boolean;
+}
+export type DataListFilterBaseValueType = string | number | boolean | Date | undefined | null;
+export type DataListFilterValueType = DataListFilterBaseValueType | DataListFilterBaseValueType[] | undefined | null;
+export type DataListFilterFromUrlValueType = string | string[] | undefined | null;
+export type DataListFiltersType<Filters extends keyof any = string> = {
+    [Prop in Filters]: DataListFilter;
+};
+export interface DataListFilter<Value = DataListFilterValueType> {
+    value?: Value;
+    matchMode?: FilterMatchModeExtendedType;
+    caseSensitive?: boolean;
+}
+export interface DataListResult<Item = any> {
+    data: Item[];
+    totalCount?: number;
+}

package/core/data-list/filter-match.model.d.ts

@@ -0,0 +1,36 @@
+export type FilterMatchModeType = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'in' | 'notIn' | 'startsWith' | 'endsWith' | 'lessThan' | 'lessThanOrEqualTo' | 'greaterThan' | 'greaterThanOrEqualTo' | 'between' | 'exists' | 'doesNotExist';
+export type FilterMatchModeExtendedType = FilterMatchModeType | string;
+export 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;
+}

package/core/data-providers/base.data-provider.d.ts

@@ -0,0 +1,32 @@
+import { ClassOptType, ClassType, ServiceClassOptType, ServiceClassType } from '../models/class-service.model';
+export type IDataProvider<ModelType = any, ServiceType = any, CT = ClassOptType<ModelType>, ST = ServiceClassOptType<ServiceType>> = {
+    classType: CT;
+    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 ModelClass - The model type for the data provider  (optional).
+ * @tparam ServiceClass - The service type for the data provider  (optional).
+ */
+export declare class DataProviderInst<Model, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> implements IDataProvider<Model, Service, ModelClass, ServiceClass> {
+    readonly classType: ModelClass;
+    readonly serviceType: ServiceClass;
+    protected constructor(classType: ModelClass, serviceType: ServiceClass);
+    get isDataProvider(): boolean;
+}
+export declare class DataProvider extends DataProviderInst<any> {
+    protected constructor();
+    static create<Model>(): DataProviderInst<Model, undefined, undefined, undefined>;
+    static fromClass<Model>(type: ClassType<Model>): DataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromClassWithService<Model, Service>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromService<Service, Model>(serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model>(): DataProviderInst<Model, undefined, undefined, undefined>;
+    static fromAnyParam<Model>(type: ClassType<Model>): DataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromAnyParam<Model, Service = any>(type: undefined, serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service = any>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): DataProviderInst<Model, Service, ModelClass, ServiceClass>;
+}

package/core/data-providers/lookup.data-provider.d.ts

@@ -0,0 +1,10 @@
+import { DataListParams } from '../data-list/data-list.model';
+import { ItemOrObservable } from '../helpers/type-helpers';
+import { ClassOptType, ServiceClassOptType } from '../models/class-service.model';
+import { IDataProvider } from './base.data-provider';
+export type LookupDataProviderLookupFnType<ModelType = any, ServiceType = undefined, ReturnType = ItemOrObservable<Array<ModelType>>> = (params: DataListParams | undefined, service: ServiceType, search?: string) => ReturnType;
+export interface ILookupDataProviderLookup<ModelType, ServiceType> {
+    lookup: LookupDataProviderLookupFnType<ModelType, ServiceType>;
+    withLookup(fn?: LookupDataProviderLookupFnType<ModelType, ServiceType>): this;
+}
+export type ILookupDataProvider<ModelType = any, ServiceType = any, CT = ClassOptType<ModelType>, ST = ServiceClassOptType<ServiceType>> = IDataProvider<ModelType, ServiceType, CT, ST> & ILookupDataProviderLookup<ModelType, ServiceType>;

package/core/descriptors/action.descriptor.d.ts

@@ -0,0 +1,12 @@
+import { IDataProvider } from '../data-providers/base.data-provider';
+import { ClassType } from '../models/class-service.model';
+import { IModelDescriptorInternal } from './model.descriptor';
+export interface IActionDescriptorInternal<Model, Service = any> {
+    model?: IModelDescriptorInternal<Model>;
+    actionName: string;
+    actionNameLong: string;
+    parentType?: ClassType<unknown>;
+    parentTypeName?: string;
+    parentProperty?: string;
+    dataProvider?: IDataProvider<Model, Service>;
+}

package/core/descriptors/column.descriptor.d.ts

@@ -0,0 +1,3 @@
+export interface IColumnDescriptorInternal<ColumnModel, TableModel, ColumnValue> {
+    property: string;
+}

package/core/descriptors/editor.descriptor.d.ts

@@ -0,0 +1,11 @@
+import { ArrayItemType } from '../helpers/type-helpers';
+import { IModelDescriptorInternal } from './model.descriptor';
+export interface IEditorDescriptorInternal<EditorModel> {
+    model: IModelDescriptorInternal<EditorModel>;
+    isLocalized: boolean;
+    localizationLocaleProperty?: string;
+    localizationModel?: IModelDescriptorInternal<any>;
+    localizationLocalizationProperty?: string;
+    localized<K extends keyof EditorModel, LocalizationModel = ArrayItemType<EditorModel[K]>>(property: K, model: IModelDescriptorInternal<LocalizationModel>, localeProperty: keyof LocalizationModel): this;
+    localizedUnsafe<LocalizationModel>(property: string, model: IModelDescriptorInternal<LocalizationModel>, localeProperty: string): this;
+}

package/core/descriptors/filter.descriptor.d.ts

@@ -0,0 +1,3 @@
+export interface IFilterDescriptorInternal<FilterModel, TableModel> {
+    property: string;
+}

package/core/descriptors/lookup.descriptor.d.ts

@@ -0,0 +1,12 @@
+import { ILookupDataProvider, LookupDataProviderLookupFnType } from '../data-providers/lookup.data-provider';
+export interface ILookupDescriptor<Model, Service = any> {
+    optionsLabelProperty?: string;
+    optionsValueProperty?: string;
+    optionsTrackProperty?: string;
+    dataProvider: ILookupDataProvider<Model, Service>;
+    withOptionsLabelProperty(property: keyof Model): this;
+    withOptionsLabelPropertyUnsafe(property: string): this;
+    withOptionsTrackProperty(property: keyof Model): this;
+    withOptionsTrackPropertyUnsafe(property: string): this;
+    withLookup(lookup: LookupDataProviderLookupFnType<Model, Service>): this;
+}

package/core/descriptors/model.descriptor.d.ts

@@ -0,0 +1,8 @@
+import { ClassOptType } from '../models/class-service.model';
+export interface IModelDescriptorInternal<Model, ModelClass = ClassOptType<Model>> {
+    type: ModelClass;
+    typeName?: string;
+    i18nBaseKey: string;
+    idProperty?: string;
+    titleProperty?: string;
+}

package/core/descriptors/table.descriptor.d.ts

@@ -0,0 +1,9 @@
+import { IColumnDescriptorInternal } from './column.descriptor';
+import { IFilterDescriptorInternal } from './filter.descriptor';
+import { IModelDescriptorInternal } from './model.descriptor';
+export interface ITableDescriptorInternal<TableModel, SortProperty, FilterProperty> {
+    model: IModelDescriptorInternal<TableModel>;
+    withDefaultSortUnsafe(property: string, ascending?: boolean, order?: number, enabled?: boolean): this;
+    withSortUnsafe(property: string, isDefault: boolean, ascending?: boolean): this;
+    addFilterFromColumnDescriptorUnsafe<ColumnModel, ColumnValue>(column: IColumnDescriptorInternal<ColumnModel, TableModel, ColumnValue>, forceSimple: boolean): IFilterDescriptorInternal<any, TableModel>;
+}

package/core/descriptors/tableview.descriptor.d.ts

@@ -0,0 +1,11 @@
+import { IEditorDescriptorInternal } from './editor.descriptor';
+import { IModelDescriptorInternal } from './model.descriptor';
+import { ITableDescriptorInternal } from './table.descriptor';
+export interface ITableviewDescriptorInternal<TableviewModel, SortProperty, FilterProperty> {
+    model: IModelDescriptorInternal<TableviewModel>;
+    table: ITableDescriptorInternal<TableviewModel, SortProperty, FilterProperty>;
+    detailsEditor: IEditorDescriptorInternal<TableviewModel>;
+    addEditor: IEditorDescriptorInternal<TableviewModel>;
+    editEditor: IEditorDescriptorInternal<TableviewModel>;
+    copy(): ITableviewDescriptorInternal<TableviewModel, SortProperty, FilterProperty>;
+}

package/core/directives/component.directive.d.ts

@@ -0,0 +1,20 @@
+import { ComponentRef, InjectionToken, Injector, OnInit, Type } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ComponentDirective<C> implements OnInit {
+    private readonly injector;
+    private readonly elementRef;
+    private readonly applicationRef;
+    private readonly viewContainerRef;
+    component?: Type<C>;
+    componentIt?: InjectionToken<Type<C>>;
+    inputs?: {
+        [key: string]: any;
+    };
+    attachToHost: boolean;
+    nodeInjector?: Injector;
+    private componentInstanceEventEmitter;
+    componentRef: ComponentRef<C>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComponentDirective<any>, "[mngComponent]", never, { "component": { "alias": "mngComponent"; "required": false; }; "componentIt": { "alias": "injectionToken"; "required": false; }; "inputs": { "alias": "inputs"; "required": false; }; "attachToHost": { "alias": "attachToHost"; "required": false; }; "nodeInjector": { "alias": "nodeInjector"; "required": false; }; }, { "componentInstanceEventEmitter": "instanceCreated"; }, never, never, true, never>;
+}

package/core/directives/dialog-keydown-handler.directive.d.ts

@@ -0,0 +1,12 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DialogKeydownHandlerDirective implements OnInit, OnDestroy {
+    private readonly dialogService;
+    private readonly dynamicDialog;
+    private readonly dialog;
+    private readonly dialogsWithKeydownListener;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogKeydownHandlerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogKeydownHandlerDirective, "[mngDialogKeydownHandler]", never, {}, {}, never, never, true, never>;
+}

package/core/directives/template.directive.d.ts

@@ -0,0 +1,12 @@
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TemplateDirective {
+    readonly template: TemplateRef<any>;
+    private readonly viewContainerRef;
+    type: string;
+    name: string;
+    getType(): string;
+    getViewContainerRef(): ViewContainerRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateDirective, "[mngTemplate]", never, { "type": { "alias": "type"; "required": false; }; "name": { "alias": "mngTemplate"; "required": true; }; }, {}, never, never, true, never>;
+}

package/core/enum/enum.model.d.ts

@@ -0,0 +1,8 @@
+import { EnumConstantType, EnumType } from '../helpers/type-helpers';
+export interface EnumValue {
+    name?: string;
+    value: EnumConstantType;
+    title: string;
+    disabled?: boolean;
+}
+export type EnumFromProperty<Type, Property extends keyof Type> = Type[Property] extends EnumType | undefined | null ? NonNullable<Type[Property]> : never;

package/core/enum/enum.util.d.ts

@@ -0,0 +1,51 @@
+import { EnumConstantType, EnumType } from '../helpers/type-helpers';
+import { EnumValue } from './enum.model';
+export declare class EnumUtil {
+    /**
+     * Returns array of names for constants in enum.
+     * @param enumType Enum object.
+     */
+    static getConstantNames(enumType: EnumType): Array<string>;
+    /**
+     * Returns array of names for constants in enum.
+     * @param enumObj Enum object.
+     */
+    static getConstantNamesFromEnumObject(enumObj: object): Array<string>;
+    /**
+     * Returns array of string values for constants in enum.
+     * @param enumType Enum object.
+     */
+    static getConstantValuesAsString(enumType: EnumType): Array<string>;
+    /**
+     * Returns array of number values for constants in enum.
+     * @param enumType Enum object.
+     */
+    static getConstantValuesAsNumber(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).
+     */
+    static fromConstantsAsEnumValueArray(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).
+     */
+    static fromValuesAsEnumValueArray<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.
+     */
+    static getConstantName<EnumConstant = EnumConstantType>(enumType: EnumType, value: EnumConstant): string | null;
+    /**
+     * Gets constant name for value.
+     * @param enumObj Enum object.
+     * @param value Value of enum constant.
+     */
+    static getConstantNameFromEnumObject<EnumConstant = EnumConstantType>(enumObj: object, value: EnumConstant): string | null;
+}

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

@@ -0,0 +1,6 @@
+import { ErrorHandler } from '@angular/core';
+export declare class CommonsErrorHandler implements ErrorHandler {
+    private static readonly logCategory;
+    private readonly logger;
+    handleError(error: Error): void;
+}

package/core/error/error.model.d.ts

@@ -0,0 +1,47 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { ActionParameters } from '../action/action-parameters.model';
+export type ErrorTypes = 'CommonsInternalError' | 'CommonsActionError' | 'CommonsHttpError';
+/**
+ * Main use for commons error from action execution.
+ * If http error is thrown, add it in cause.
+ */
+export interface ICommonsError extends Error {
+    type: ErrorTypes;
+    messageCode?: number | string;
+    message: string;
+    details?: any;
+    stack?: string;
+    cause?: Error | unknown;
+}
+export interface CommonsErrorBaseOptions {
+    name?: string;
+    messageCode?: number | string;
+    details?: any;
+    cause?: Error;
+    stack?: string;
+    location?: string;
+}
+export declare abstract class ACommonsErrorBase extends Error implements ICommonsError {
+    abstract readonly type: ErrorTypes;
+    readonly messageCode?: number | string;
+    readonly location?: string;
+    readonly details?: any;
+    protected constructor(message: string, options?: CommonsErrorBaseOptions);
+}
+export declare class CommonsInternalError extends ACommonsErrorBase implements ICommonsError {
+    readonly type = "CommonsInternalError";
+    constructor(message: string, options?: CommonsErrorBaseOptions);
+}
+export declare class CommonsHttpError extends ACommonsErrorBase implements ICommonsError {
+    readonly type = "CommonsHttpError";
+    readonly httpError: HttpErrorResponse;
+    constructor(message: string, httpError: HttpErrorResponse, options?: CommonsErrorBaseOptions);
+}
+export interface ICommonsActionError extends ICommonsError {
+    type: 'CommonsActionError';
+    httpError?: HttpErrorResponse;
+    actionContext?: ICommonsActionErrorContext;
+}
+export interface ICommonsActionErrorContext {
+    parameters: ActionParameters<any>;
+}

package/core/error/error.util.d.ts

@@ -0,0 +1,116 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { LogLevelEnum } from '../log/log.model';
+import { ACommonsErrorBase, ICommonsActionError } from './error.model';
+export declare class ErrorUtil {
+    /**
+     * Converts RxJS subscription error to CommonsError.
+     * @param error Error.
+     * @param name Optional name to write in commons error.
+     * @param details Optional details of error.
+     */
+    static fromSubscribeError(error: any, name?: string, details?: any): ACommonsErrorBase;
+    /**
+     * Checks if error is Http error (Angular or Commons).
+     * @param error
+     */
+    static isHttpErrorResponse(error: any): boolean;
+    /**
+     * Gets HttpErrorResponse from error (Angular or Commons).
+     * @param error Error.
+     */
+    static getHttpErrorResponse(error: any): HttpErrorResponse | null;
+    /**
+     * Gets HttpErrorResponse status from error (Angular or Commons).
+     * @param error Error.
+     */
+    static getHttpErrorResponseStatus(error: any): number | null;
+    /**
+     * Get error log level. All is error, except if error is http error with status >=400 and <500.
+     * @param error Error.
+     */
+    static getErrorLogLevel(error: any): LogLevelEnum;
+    /**
+     * Get error name (prototype name or type from commons error if name is not provided).
+     * @param error Error.
+     */
+    static 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.
+     */
+    static 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).
+     */
+    static 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.
+     */
+    static 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.
+     */
+    static 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).
+     */
+    static errorCauseToString(error: Error, opts?: ErrorCauseToStringOptionsType): string;
+}
+export type ErrorToStringOptionsType = ErrorToStringOptionsBaseType & HttpErrorResponseToStringOptionsType & ActionErrorContextToStringOptionsType & ErrorCauseToStringOptionsType & {
+    hideDetails?: boolean;
+    hideLocation?: boolean;
+};
+export interface ErrorToStringOptionsBaseType {
+    hideName?: boolean;
+    hideStack?: boolean;
+    hideCause?: boolean;
+    hideHttp?: boolean;
+}
+export interface HttpErrorResponseToStringOptionsType {
+    hideMessage?: boolean;
+    hideHeaders?: boolean;
+    hideBody?: boolean;
+}
+export interface ActionErrorContextToStringOptionsType {
+    hideItems?: boolean;
+    hideActionData?: boolean;
+    hideQueryParams?: boolean;
+}
+export interface ErrorCauseToStringOptionsType {
+    causeOnErrorOnly?: boolean;
+    causeAsJson?: boolean;
+}

package/core/helpers/coercion.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { IdType, Nullable } from './type-helpers';
+export declare function boolean$Attribute(value: unknown): Observable<boolean>;
+export declare function number$Attribute(value: unknown): Observable<number>;
+export declare const toObservable: <T>(value: T | Observable<T>) => Observable<T>;
+export declare const itemIdToNumber: (value?: IdType) => number;
+export declare const itemIdToString: (value?: IdType) => string;
+export declare const itemIdToDefined: (value?: IdType) => IdType;
+export declare const valueToDefined: <T>(value: Nullable<T>) => T;

package/core/helpers/notification.d.ts

@@ -0,0 +1,2 @@
+import { Message, MessageService } from 'primeng/api';
+export declare function toastMessage(messageService: MessageService, title?: string, message?: string, severity?: 'success' | 'warn' | 'error', icon?: string): Message;