@mediusinc/mng-commons 0.0.1-rc.2 → 0.2.0

package/lib/components/form/formly/wrappers/formly-table-wrapper/formly-table-wrapper.component.d.ts

@@ -1,8 +1,8 @@
 import { OnInit } from '@angular/core';
 import { FieldWrapper } from '@ngx-formly/core';
 import * as i0 from "@angular/core";
-export declare class FormlyTableWrapperComponent extends FieldWrapper implements OnInit {
+export declare class MngFormlyTableWrapperComponent extends FieldWrapper implements OnInit {
     ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyTableWrapperComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyTableWrapperComponent, "mng-formly-table-wrapper", never, {}, {}, never, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngFormlyTableWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngFormlyTableWrapperComponent, "mng-formly-table-wrapper", never, {}, {}, never, never>;
 }

package/lib/components/form/index.d.ts

@@ -1 +1,3 @@
 export * from './editor/form-editor.component';
+export * from './autocomplete/autocomplete.component';
+export * from './dropdown/dropdown.component';

package/lib/components/form/models/form-editor.event.d.ts

@@ -0,0 +1,5 @@
+export declare class MngFormEditorSubmitEvent<T> {
+    readonly formItem: T;
+    success: boolean;
+    constructor(formItem: T);
+}

package/lib/components/form/models/index.d.ts

@@ -0,0 +1 @@
+export * from './form-editor.event';

package/lib/components/layout/breadcrumb.component.d.ts

@@ -0,0 +1,8 @@
+import { MngCommonsService } from '../../services';
+import * as i0 from "@angular/core";
+export declare class MngBreadcrumbComponent {
+    mngCommons: MngCommonsService;
+    constructor(mngCommons: MngCommonsService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngBreadcrumbComponent, "mng-breadcrumb", never, {}, {}, never, never>;
+}

package/lib/components/layout/footer.component.d.ts

@@ -0,0 +1,9 @@
+import { MngCommonsService } from '../../services';
+import * as i0 from "@angular/core";
+export declare class MngFooterComponent {
+    mngCommons: MngCommonsService;
+    currentYear: number;
+    constructor(mngCommons: MngCommonsService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngFooterComponent, "mng-footer", never, {}, {}, never, never>;
+}

package/lib/components/layout/index.d.ts

@@ -1,6 +1,6 @@
-export * from './app.breadcrumb.component';
-export * from './app.footer.component';
-export * from './app.main.component';
-export * from './app.menu.component';
-export * from './app.menuitem.component';
-export * from './app.topbar.component';
+export * from './breadcrumb.component';
+export * from './footer.component';
+export * from './main-layout.component';
+export * from './menu.component';
+export * from './menu-item.component';
+export * from './topbar.component';

package/lib/components/layout/main-layout.component.d.ts

@@ -0,0 +1,21 @@
+import { AfterViewInit, QueryList, Type } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { MngCommonsService } from '../../services';
+import { MngMainLayoutComponentService } from './services';
+import { MngTemplateDirective } from '../../directives';
+import * as i0 from "@angular/core";
+export declare class MngMainLayoutComponent implements AfterViewInit {
+    private route;
+    mngCommons: MngCommonsService;
+    mainLayoutService: MngMainLayoutComponentService;
+    templates: QueryList<MngTemplateDirective>;
+    topbarComponent: Type<any>;
+    menuComponent: Type<any>;
+    footerComponent: Type<any>;
+    constructor(route: ActivatedRoute, mngCommons: MngCommonsService, mainLayoutService: MngMainLayoutComponentService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onWindowResize(event: UIEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngMainLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngMainLayoutComponent, "mng-main-layout", never, {}, {}, never, never>;
+}

package/lib/components/layout/menu-item.component.d.ts

@@ -0,0 +1,29 @@
+import { OnInit, ChangeDetectorRef, OnDestroy } from '@angular/core';
+import { Router } from '@angular/router';
+import { Subscription } from 'rxjs';
+import { MngCommonsService } from '../../services';
+import { MngMainLayoutComponentService } from './services';
+import * as i0 from "@angular/core";
+export declare class MngMenuItemComponent implements OnInit, OnDestroy {
+    router: Router;
+    private cd;
+    mngCommons: MngCommonsService;
+    mainLayoutService: MngMainLayoutComponentService;
+    item: any;
+    index: number;
+    root: boolean;
+    parentKey: string | null;
+    active: boolean;
+    hover: boolean;
+    menuSourceSubscription: Subscription;
+    menuResetSubscription: Subscription;
+    key: string;
+    constructor(router: Router, cd: ChangeDetectorRef, mngCommons: MngCommonsService, mainLayoutService: MngMainLayoutComponentService);
+    ngOnInit(): void;
+    updateActiveStateFromRoute(): void;
+    itemClick(event: Event): void;
+    onMouseEnter(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngMenuItemComponent, "[mng-menuitem]", never, { "item": "item"; "index": "index"; "root": "root"; "parentKey": "parentKey"; }, {}, never, never>;
+}

package/lib/components/layout/menu.component.d.ts

@@ -0,0 +1,10 @@
+import { MngCommonsService } from '../../services';
+import { MngMainLayoutComponentService } from './services';
+import * as i0 from "@angular/core";
+export declare class MngMenuComponent {
+    mngCommons: MngCommonsService;
+    mainLayoutService: MngMainLayoutComponentService;
+    constructor(mngCommons: MngCommonsService, mainLayoutService: MngMainLayoutComponentService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngMenuComponent, "mng-menu", never, {}, {}, never, never>;
+}

package/lib/components/layout/services/index.d.ts

@@ -0,0 +1 @@
+export * from './main-layout.component.service';

package/lib/components/layout/services/main-layout.component.service.d.ts

@@ -0,0 +1,65 @@
+import { MngCommonsService } from '../../../services';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class MngMainLayoutComponentService {
+    private mngCommons;
+    private _overlayMenuActive;
+    private _overlayMenuActiveSubject;
+    private _staticMenuDesktopInactive;
+    private _staticMenuDesktopInactiveSubject;
+    private _staticMenuMobileActive;
+    private _staticMenuMobileActiveSubject;
+    private _sidebarActive;
+    private _sidebarActiveSubject;
+    private _sidebarStatic;
+    private _sidebarStaticSubject;
+    private _menuClick;
+    private _menuHoverActive;
+    private _topbarItemClick;
+    private _activeTopbarItem;
+    private _activeTopbarItemSubject;
+    private _pinActive;
+    private _pinActiveSubject;
+    private _innerWidth;
+    private _innerWidthSubject;
+    constructor(mngCommons: MngCommonsService);
+    get overlayMenuActive$(): Observable<boolean>;
+    set overlayMenuActive(value: boolean);
+    get staticMenuDesktopInactive$(): Observable<boolean>;
+    set staticMenuDesktopInactive(value: boolean);
+    get staticMenuMobileActive$(): Observable<boolean>;
+    set staticMenuMobileActive(value: boolean);
+    get sidebarActive$(): Observable<boolean>;
+    set sidebarActive(value: boolean);
+    get sidebarStatic$(): Observable<boolean>;
+    set sidebarStatic(value: boolean);
+    set menuHoverActive(value: boolean);
+    set topbarItemClick(value: boolean);
+    get activeTopbarItem$(): Observable<any>;
+    set activeTopbarItem(value: any);
+    get pinActive$(): Observable<boolean>;
+    set pinActive(value: boolean);
+    get isDesktop$(): Observable<boolean>;
+    get isMobile$(): Observable<boolean>;
+    set innerWidth(value: number);
+    onLayoutClick(): void;
+    onSidebarClick(event: any): void;
+    onToggleMenu(event: any): void;
+    onSidebarMouseOver(event: any): void;
+    onSidebarMouseLeave(event: any): void;
+    onMenuButtonClick(event: any): void;
+    onTopbarItemClick(event: any, item: any): void;
+    onTopbarSubItemClick(event: any): void;
+    /**
+     * Checks if is desktop width, DO NOT use within HTML templates or within functions called by HTML templates
+     */
+    isDesktop(): boolean;
+    /**
+     * Checks if is mobile width, DO NOT use within HTML templates or within functions called by HTML templates
+     */
+    isMobile(): boolean;
+    private isWidthDesktop;
+    private isWidthMobile;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngMainLayoutComponentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MngMainLayoutComponentService>;
+}

package/lib/components/layout/topbar.component.d.ts

@@ -0,0 +1,25 @@
+import { OnInit, QueryList, Type } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { MngMainLayoutComponentService } from './services';
+import { MngCommonsService } from '../../services';
+import { MngTemplateDirective } from '../../directives';
+import { IUser } from '../../models';
+import * as i0 from "@angular/core";
+export declare class MngTopbarComponent implements OnInit {
+    private route;
+    mngCommons: MngCommonsService;
+    mainLayoutService: MngMainLayoutComponentService;
+    templates: QueryList<MngTemplateDirective>;
+    breadcrumbComponent: Type<any>;
+    menuComponent: Type<any>;
+    languages: Array<string>;
+    selectedLanguage: string;
+    user?: IUser;
+    constructor(route: ActivatedRoute, mngCommons: MngCommonsService, mainLayoutService: MngMainLayoutComponentService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    switchLanguage(language: string): void;
+    logout(user: IUser, event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngTopbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngTopbarComponent, "mng-topbar", never, {}, {}, never, never>;
+}

package/lib/components/tableview/index.d.ts

@@ -1,3 +1,5 @@
 export * from './tableview.component';
 export * from './route/tableview-route.abstract.component';
 export * from './table/table.component';
+export * from './table/column-filter/column-filter.component';
+export * from './table/column-value/column-value.component';

package/lib/components/tableview/models/index.d.ts

@@ -0,0 +1 @@
+export * from './table.event';

package/lib/{models/events/table-event.model.d.ts → components/tableview/models/table.event.d.ts}

@@ -1,15 +1,15 @@
 import { LazyLoadEvent } from 'primeng/api';
-import { QueryParam } from '../../api/models';
-import { ColumnDescriptor } from '../descriptors';
+import { MediusQueryParam } from '../../../api/models';
+import { ColumnDescriptor } from '../../../descriptors';
 export declare class MngTableLoadEvent {
-    queryParam?: QueryParam;
+    queryParam?: MediusQueryParam;
     originalEvent?: LazyLoadEvent;
 }
 export declare class MngTableCellClickEvent<T> {
-    readonly column: ColumnDescriptor<any>;
+    readonly column: ColumnDescriptor<any, T>;
     readonly rowItem: T;
     readonly rowIndex: number;
-    constructor(column: ColumnDescriptor<any>, rowItem: T, rowIndex: number);
+    constructor(column: ColumnDescriptor<any, T>, rowItem: T, rowIndex: number);
 }
 export declare class MngTableReloadEvent {
     resetParams: boolean;

package/lib/components/tableview/route/tableview-route.abstract.component.d.ts

@@ -1,7 +1,6 @@
-import { TableviewDescriptor, ActionDescriptor } from '../../../models/descriptors';
-import { ITableviewDataProvider } from '../../../models/providers';
+import { TableviewDescriptor, ActionDescriptor } from '../../../descriptors';
+import { ITableviewDataProvider } from '../../../data-providers';
 import * as i0 from "@angular/core";
-export declare const mngTableviewRouteComponentTemplate: string;
 export declare abstract class AMngTableviewRouteComponent<T, S> {
     descriptor: TableviewDescriptor<T>;
     dataProvider: ITableviewDataProvider<T, S>;

package/lib/components/tableview/services/index.d.ts

@@ -0,0 +1 @@
+export * from './tableview.component.service';

package/lib/components/tableview/{tableview.component.service.d.ts → services/tableview.component.service.d.ts}

@@ -1,8 +1,10 @@
-import { ITableviewDataProvider } from '../../models/providers';
-import { ActionDescriptor } from '../../models/descriptors';
+import { MessageService } from 'primeng/api';
+import { ITableviewDataProvider } from '../../../data-providers';
+import { ActionDescriptor } from '../../../descriptors';
 import * as i0 from "@angular/core";
 export declare class TableviewComponentService<T, S> {
     dataProvider?: ITableviewDataProvider<T, S>;
+    messageService?: MessageService;
     actions: Array<ActionDescriptor<T>>;
     constructor();
     reloadTable(): void;

package/lib/components/tableview/table/column-filter/column-filter.component.d.ts

@@ -0,0 +1,22 @@
+import { OnInit } from '@angular/core';
+import { FilterDescriptor, FilterLookupDescriptor, TableDescriptor } from '../../../../descriptors';
+import * as i0 from "@angular/core";
+/**
+ * Cannot be on push change detection strategy because of filter updates triggered from route which causes to force update values in force metadata
+ * and these must be propagated through to this component and beyond to primeNG.
+ */
+export declare class MngTableColumnFilterComponent<T> implements OnInit {
+    readonly lookupTypeDropdown: FilterLookupDescriptor.LookupTypeEnum;
+    readonly lookupTypeAutocomplete: FilterLookupDescriptor.LookupTypeEnum;
+    descriptor: FilterDescriptor<T>;
+    display: TableDescriptor.FilterDisplayEnum;
+    lookupDescriptor?: FilterLookupDescriptor<T>;
+    primeField: string;
+    primeType: string;
+    primeDefaultMatchMode: string;
+    primeDisplay: string;
+    ngOnInit(): void;
+    autocompleteFilter(value: T, filterCallback: Function): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngTableColumnFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngTableColumnFilterComponent<any>, "mng-table-column-filter", never, { "descriptor": "descriptor"; "display": "display"; }, {}, never, never>;
+}

package/lib/components/tableview/table/column-value/column-value.component.d.ts

@@ -0,0 +1,12 @@
+import { ColumnDescriptor } from '../../../../descriptors';
+import * as i0 from "@angular/core";
+export declare class MngTableColumnValueComponent<T, TT> {
+    readonly columnTypeString: ColumnDescriptor.TypeEnum;
+    readonly columnTypeNumber: ColumnDescriptor.TypeEnum;
+    readonly columnTypeBoolean: ColumnDescriptor.TypeEnum;
+    readonly columnTypeDate: ColumnDescriptor.TypeEnum;
+    descriptor: ColumnDescriptor<T, TT>;
+    item: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngTableColumnValueComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngTableColumnValueComponent<any, any>, "mng-table-column-value", never, { "descriptor": "descriptor"; "item": "item"; }, {}, never, never>;
+}

package/lib/components/tableview/table/table.component.d.ts

@@ -1,47 +1,79 @@
 import { AfterContentInit, Injector, OnDestroy, OnInit, QueryList, TemplateRef } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
 import { LazyLoadEvent, SortMeta } from 'primeng/api';
+import { FilterMetadata } from 'primeng/api/filtermetadata';
 import { Observable } from 'rxjs';
-import { QueryResult } from '../../../api/models';
-import { TableDescriptor, ColumnDescriptor } from '../../../models/descriptors';
-import { ITableDataProvider } from '../../../models/providers';
-import { TemplateDirective } from '../../../directives';
+import { TranslateService } from '@ngx-translate/core';
+import { MediusQueryResult } from '../../../api/models';
+import { ColumnDescriptor, TableDescriptor } from '../../../descriptors';
+import { ITableDataProvider } from '../../../data-providers';
+import { MngTemplateDirective } from '../../../directives';
+import { TableviewComponentService } from '../services';
 import * as i0 from "@angular/core";
-export declare class TableComponent<T> implements OnInit, AfterContentInit, OnDestroy {
+export declare class MngTableComponent<T, S> implements OnInit, AfterContentInit, OnDestroy {
     private injector;
+    private router;
+    private activatedRoute;
+    private translate;
+    private tableviewService;
+    readonly filterDisplayRow: TableDescriptor.FilterDisplayEnum;
+    readonly filterDisplayMenu: TableDescriptor.FilterDisplayEnum;
     descriptor: TableDescriptor<T>;
     items?: Observable<Array<T>> | Array<T>;
-    queryResult?: Observable<QueryResult<T>> | QueryResult<T>;
+    queryResult?: Observable<MediusQueryResult<T>> | MediusQueryResult<T>;
     loading?: Observable<boolean> | boolean;
     dataProvider?: ITableDataProvider<T, any>;
+    useQueryParams: boolean;
     selectionEnabled: boolean;
     private loadEventEmitter;
     private cellClickEventEmitter;
     private selectionChangeEventEmitter;
-    templates: QueryList<TemplateDirective>;
+    templates: QueryList<MngTemplateDirective>;
     private primeTable;
     captionTemplate?: TemplateRef<any>;
     columnActionTemplate?: TemplateRef<any>;
     useDataProvider: boolean;
-    queryResult$?: Observable<QueryResult<T>>;
+    useQueryParamsInitialized: boolean;
+    queryResult$?: Observable<MediusQueryResult<T>>;
     loading$?: Observable<boolean>;
+    dataProviderInfiniteScrollItems: Array<T>;
     private dataProviderService;
     private dataProviderQueryResultSubject;
     private dataProviderLoadingSubject;
     private dataProviderLatestLazyLoadEvent?;
+    private dataProviderLatestLazyLoadEventVersion;
+    private dataProviderLatestQueryParam?;
+    private dataProviderLatestQueryParamVersion;
     private dataProviderSubscription?;
     readonly rowsPerPageOptions: number[];
-    multiSortMeta?: SortMeta[];
+    rows: number;
+    offset: number;
+    multiSortMeta: SortMeta[] | null;
+    filterMetadata: {
+        [s: string]: FilterMetadata | FilterMetadata[];
+    };
+    private isFilterChanged;
+    private isSortChanged;
+    infiniteScroll: boolean;
+    scrollHeight: 'flex' | null;
+    rowHeight: number | null;
     selection: Array<T>;
     private subscriptions;
-    constructor(injector: Injector);
+    private filterDescriptors;
+    constructor(injector: Injector, router: Router, activatedRoute: ActivatedRoute, translate: TranslateService, tableviewService: TableviewComponentService<T, S>);
     ngOnInit(): void;
     ngAfterContentInit(): void;
     ngOnDestroy(): void;
     reload(emitEvent?: boolean, resetParams?: boolean): void;
     onTableLazyLoad(event: LazyLoadEvent): void;
-    onCellClick(col: ColumnDescriptor<any>, item: T, idx: number): void;
+    onTableSort(event: any): void;
+    onTableFilter(event: any): void;
+    onCellClick(col: ColumnDescriptor<any, T>, item: T, idx: number): void;
     onSelectionChange(event: Array<T>): void;
     private loadTableWithDataProvider;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "mng-table", never, { "descriptor": "descriptor"; "items": "items"; "queryResult": "queryResult"; "loading": "loading"; "dataProvider": "dataProvider"; "selectionEnabled": "selectionEnabled"; }, { "loadEventEmitter": "onLoad"; "cellClickEventEmitter": "onCellClick"; "selectionChangeEventEmitter": "onSelectionChange"; }, ["templates"], never>;
+    private loadTableFromRouteUpdate;
+    private updatePrimeSortAndFilter;
+    private getDefaultSortMeta;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngTableComponent<any, any>, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngTableComponent<any, any>, "mng-table", never, { "descriptor": "descriptor"; "items": "items"; "queryResult": "queryResult"; "loading": "loading"; "dataProvider": "dataProvider"; "useQueryParams": "useQueryParams"; "selectionEnabled": "selectionEnabled"; }, { "loadEventEmitter": "onLoad"; "cellClickEventEmitter": "onCellClick"; "selectionChangeEventEmitter": "onSelectionChange"; }, ["templates"], never>;
 }

package/lib/components/tableview/tableview.component.d.ts

@@ -3,15 +3,14 @@ import { ActivatedRoute } from '@angular/router';
 import { TranslateService } from '@ngx-translate/core';
 import { ConfirmationService, MessageService } from 'primeng/api';
 import { DialogService } from 'primeng/dynamicdialog';
-import { ActionService } from '../../services';
-import { TableviewDescriptor } from '../../models/descriptors';
-import { ITableviewDataProvider } from '../../models/providers';
-import { MngTableCellClickEvent } from '../../models/events';
-import { ActionDescriptor } from '../../models/descriptors';
-import { TableComponent } from './table/table.component';
-import { TableviewComponentService } from './tableview.component.service';
+import { MngActionService } from '../../services';
+import { TableviewDescriptor, ActionDescriptor } from '../../descriptors';
+import { ITableviewDataProvider } from '../../data-providers';
+import { MngTableCellClickEvent } from './models';
+import { TableviewComponentService } from './services';
+import { MngTableComponent } from './table/table.component';
 import * as i0 from "@angular/core";
-export declare class TableviewComponent<T, S> implements OnInit {
+export declare class MngTableviewComponent<T, S> implements OnInit {
     private route;
     private messageService;
     private translateService;
@@ -22,15 +21,15 @@ export declare class TableviewComponent<T, S> implements OnInit {
     descriptor: TableviewDescriptor<T>;
     dataProvider?: ITableviewDataProvider<T, S>;
     actions: Array<ActionDescriptor<T>>;
-    tableComponent: TableComponent<T> | null;
+    tableComponent: MngTableComponent<T, S> | null;
     rowClickActions: ActionDescriptor<T>[];
     rowInlineActions: ActionDescriptor<T>[];
     toolbarLeftActions: ActionDescriptor<T>[];
     toolbarRightActions: ActionDescriptor<T>[];
-    constructor(route: ActivatedRoute, messageService: MessageService, translateService: TranslateService, dialogService: DialogService, confirmationService: ConfirmationService, actionService: ActionService, tableviewService: TableviewComponentService<T, S>);
+    constructor(route: ActivatedRoute, messageService: MessageService, translateService: TranslateService, dialogService: DialogService, confirmationService: ConfirmationService, actionService: MngActionService, tableviewService: TableviewComponentService<T, S>);
     ngOnInit(): void;
     reloadTable(): void;
     onTableCellClick(event: MngTableCellClickEvent<T>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableviewComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableviewComponent<any, any>, "mng-tableview", never, { "descriptor": "descriptor"; "dataProvider": "dataProvider"; "actions": "actions"; }, {}, never, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MngTableviewComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MngTableviewComponent<any, any>, "mng-tableview", never, { "descriptor": "descriptor"; "dataProvider": "dataProvider"; "actions": "actions"; }, {}, never, never>;
 }

package/lib/config/formly.config.d.ts

@@ -1,8 +1,14 @@
-import { FormlyFieldWrapperComponent } from '../components/form/formly/wrappers';
 import { TranslateService } from '@ngx-translate/core';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { Observable } from 'rxjs';
+import { MngFormlyFieldWrapperComponent } from '../components/form/formly/wrappers';
 export declare const formlyWrappersConfig: {
     name: string;
-    component: typeof FormlyFieldWrapperComponent;
+    component: typeof MngFormlyFieldWrapperComponent;
 }[];
 export declare const formlyTypesConfig: any[];
+export declare function getRequiredValidationMessage(translate: TranslateService): (error: any, field: FormlyFieldConfig) => Observable<string>;
+export declare function getMinLengthValidationMessage(translate: TranslateService): (error: any, field: FormlyFieldConfig) => Observable<string> | undefined;
+export declare function getMaxLengthValidationMessage(translate: TranslateService): (error: any, field: FormlyFieldConfig) => Observable<string> | undefined;
+export declare function getTextPatternValidationMessage(translate: TranslateService): (error: any, field: FormlyFieldConfig) => Observable<string> | undefined;
 export declare const getFormlyValidationMessages: (translate: TranslateService) => any[];

package/lib/config/models/mng-config.model.d.ts

@@ -0,0 +1,34 @@
+import { TranslateService } from '@ngx-translate/core';
+import { MenuItem } from 'primeng/api';
+export interface MngModuleConfig {
+    app?: {
+        name?: string;
+        owner?: string;
+        logoPath?: string;
+        logoPathLight?: string;
+        logoPathDark?: string;
+        logoNamePath?: string;
+        logoNamePathLight?: string;
+        logoNamePathDark?: string;
+        languages?: string[];
+        colorScheme?: 'light' | 'dark';
+    };
+    menu?: {
+        mode?: 'static' | 'sidebar' | 'slim' | 'overlay';
+        menuItems?: MenuItem[];
+        pinEnabled?: boolean;
+    };
+    configuration?: {
+        projectEnvironment?: any;
+        jsonSource?: string;
+        skipJsonSourceInit?: boolean;
+    };
+    formly?: {
+        skip?: boolean;
+        merge?: boolean;
+        types?: any[];
+        wrappers?: any[];
+        validators?: any[];
+        getValidationMessages?: (translate: TranslateService) => any[];
+    };
+}

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

@@ -0,0 +1,17 @@
+import { Type } from '@angular/core';
+import { ClassType } from '../types';
+export interface IDataProvider<T, S> {
+    modelType: ClassType<T> | null;
+    serviceType?: Type<S>;
+}
+export declare class DataProvider<T, S> {
+    protected _modelType: ClassType<T> | null;
+    protected _serviceType?: Type<S>;
+    protected _enumName?: string;
+    constructor(modelType: ClassType<T> | null, serviceType?: Type<S>);
+    get serviceType(): Type<S> | undefined;
+    get modelType(): ClassType<T> | null;
+    get enumName(): string | undefined;
+    withServiceType(type: Type<S>): this;
+    withEnumName(enumName: string): this;
+}

package/lib/data-providers/editor.data-provider.d.ts

@@ -0,0 +1,25 @@
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ClassType, IdType } from '../types';
+import { DataProvider, IDataProvider } from './base.data-provider';
+export interface IEditorDataProvider<T, S> extends IDataProvider<T, S> {
+    fetch: (id: IdType, service?: S) => Observable<T>;
+    create?: (item?: T, service?: S) => Observable<T>;
+    update?: (id: IdType, item?: T, service?: S) => Observable<T>;
+    delete?: (id: IdType, item?: T, service?: S) => Observable<T>;
+}
+export declare class EditorDataProvider<T, S> extends DataProvider<T, S> implements IEditorDataProvider<T, S> {
+    protected _fetch: (id: IdType, service?: S) => Observable<T>;
+    protected _create?: (item?: T, service?: S) => Observable<T>;
+    protected _update?: (id: IdType, item?: T, service?: S) => Observable<T>;
+    protected _delete?: (id: IdType, item?: T, service?: S) => Observable<T>;
+    constructor(modelType: ClassType<T>, serviceType?: Type<S>);
+    get fetch(): (id: IdType, service?: S | undefined) => Observable<T>;
+    get create(): ((item?: T | undefined, service?: S | undefined) => Observable<T>) | undefined;
+    get update(): ((id: IdType, item?: T | undefined, service?: S | undefined) => Observable<T>) | undefined;
+    get delete(): ((id: IdType, item?: T | undefined, service?: S | undefined) => Observable<T>) | undefined;
+    withFetch(fetch: (id: IdType, service?: S) => Observable<T>): this;
+    withCreate(create: (item?: T, service?: S) => Observable<T>): this;
+    withUpdate(update: (id: IdType, item?: T, service?: S) => Observable<T>): this;
+    withDelete(deleteFn: (id: IdType, item?: T, service?: S) => Observable<T>): this;
+}

package/lib/data-providers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base.data-provider';
+export * from './editor.data-provider';
+export * from './lookup.data-provider';
+export * from './table.data-provider';
+export * from './tableview.data-provider';

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

@@ -0,0 +1,14 @@
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { MediusQueryParam } from '../api/models';
+import { ClassType } from '../types';
+import { DataProvider, IDataProvider } from './base.data-provider';
+export interface ILookupDataProvider<T, S> extends IDataProvider<T, S> {
+    lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>;
+}
+export declare class LookupDataProvider<T, S> extends DataProvider<T, S> implements ILookupDataProvider<T, S> {
+    protected _lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>;
+    constructor(modelType: ClassType<T> | null, serviceType?: Type<S>);
+    get lookup(): (queryParam?: MediusQueryParam | undefined, service?: S | undefined, search?: string | undefined) => Observable<T[]>;
+    withLookup(lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>): this;
+}

package/lib/data-providers/table.data-provider.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from 'rxjs';
+import { MediusQueryParam, MediusQueryResult } from '../api/models';
+import { IDataProvider } from './base.data-provider';
+export interface ITableDataProvider<T, S> extends IDataProvider<T, S> {
+    getAll: (queryParam: MediusQueryParam, service?: S) => Observable<MediusQueryResult<T>>;
+}

package/lib/data-providers/tableview.data-provider.d.ts

@@ -0,0 +1,15 @@
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { MediusQueryParam, MediusQueryResult } from '../api/models';
+import { ClassType } from '../types';
+import { EditorDataProvider, IEditorDataProvider } from './editor.data-provider';
+import { ITableDataProvider } from './table.data-provider';
+export interface ITableviewDataProvider<T, S> extends IEditorDataProvider<T, S> {
+    getAll: (queryParam: MediusQueryParam, service?: S) => Observable<MediusQueryResult<T>>;
+}
+export declare class TableviewDataProvider<T, S> extends EditorDataProvider<T, S> implements ITableviewDataProvider<T, S>, ITableDataProvider<T, S>, IEditorDataProvider<T, S> {
+    protected _getAll: (queryParam: MediusQueryParam, service?: S) => Observable<MediusQueryResult<T>>;
+    constructor(modelType: ClassType<T>, serviceType?: Type<S>);
+    get getAll(): (queryParam: MediusQueryParam, service?: S | undefined) => Observable<MediusQueryResult<T>>;
+    withGetAll(getAll: (queryParam: MediusQueryParam, service?: S) => Observable<MediusQueryResult<T>>): this;
+}