@dflat-core/web 1.0.0-beta

package/core-ux/lib/model/tree.d.ts

@@ -0,0 +1,12 @@
+import { EntityViewModel } from "@dflat-core/web/core-model";
+export declare abstract class TreeItem<TData extends EntityViewModel> {
+    Id?: number;
+    Label?: string;
+    Item?: TData;
+    ParentItemId?: number;
+    SubItems?: TreeItem<TData>[];
+    OrderNumber?: number;
+    ShowSubItems?: boolean;
+    isEditing?: boolean;
+    RowVersion?: Date;
+}

package/core-ux/lib/pipes/euro.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class EuroPipe implements PipeTransform {
+    constructor();
+    transform(initial: string): string;
+    parse(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EuroPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EuroPipe, "euro", false>;
+}

package/core-ux/lib/pipes/todefine.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ToDefinePipe implements PipeTransform {
+    constructor();
+    transform(value: string, handleNull: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToDefinePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToDefinePipe, "todefine", false>;
+}

package/core-ux/lib/pipes/tofixedsizeinteger.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ToFixedSizeIntegerPipe implements PipeTransform {
+    constructor();
+    transform(value: string, character: any, size: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToFixedSizeIntegerPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToFixedSizeIntegerPipe, "tofixedsizeinteger", false>;
+}

package/core-ux/lib/services/action.service.d.ts

@@ -0,0 +1,42 @@
+import { ActionDescriptor, Notification } from '@dflat-core/web/core-model';
+import { NotificationMqService } from '@dflat-core/web/core-services';
+import type { LogsComponent } from '../components/logs/logs.component';
+import { ModalService } from './modal.service';
+import { ActionDataService, FileDataService } from '@dflat-core/web/system-data';
+import { Type } from '@angular/core';
+import { Guid } from 'guid-typescript';
+import { BsModalRef } from 'ngx-bootstrap/modal';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { LogService } from '../log.service';
+import type { ExtendedActionComponent } from '../components/actions/extended-action/extended-action.component';
+import * as i0 from "@angular/core";
+export declare class ActionService {
+    private modalService;
+    private actionDataService;
+    private mqService;
+    private fileService;
+    private logService;
+    private extendedActionComponentType;
+    isLoadingChanged: BehaviorSubject<boolean>;
+    _isLoading: import("rxjs").Observable<boolean>;
+    logsComponent?: LogsComponent;
+    constructor(modalService: ModalService, actionDataService: ActionDataService, mqService: NotificationMqService, fileService: FileDataService, logService: LogService, extendedActionComponentType: Type<ExtendedActionComponent>);
+    guid: Guid;
+    fileId: number;
+    firstModalRef: BsModalRef | undefined;
+    entityNotificationSubscription: Subscription | undefined;
+    requestNotificationSubscription: Subscription | undefined;
+    logmodal: BsModalRef | undefined;
+    setIsLoading(value: boolean): void;
+    executeExtendedAction(actionDescriptor: ActionDescriptor, entityKey: string, entityIds: number[]): void;
+    executeExtendedActionCallBack(component: ExtendedActionComponent): void;
+    logs: any[];
+    openLogModal(component: ExtendedActionComponent): void;
+    handleNotification(notif: Notification, component: ExtendedActionComponent): void;
+    subscribeEntityNotification(component: ExtendedActionComponent): void;
+    subscribeRequestNotification(component: ExtendedActionComponent): void;
+    unsubscribeNotificationSubscriptions(): void;
+    onDispose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionService>;
+}

package/core-ux/lib/services/alert.service.d.ts

@@ -0,0 +1,51 @@
+import { SaveResult } from '@dflat-core/web/core-model';
+import { Type } from '@angular/core';
+import { ActiveToast, IndividualConfig, ToastrService } from 'ngx-toastr';
+import { Observable } from 'rxjs';
+import { MessageSeverity } from '../model/model';
+import { ModalService } from './modal.service';
+import * as i0 from "@angular/core";
+export declare class AlertService {
+    private modalService;
+    private toastrService;
+    private lastInserted;
+    constructor(modalService: ModalService, toastrService: ToastrService);
+    success(message: string, override?: Partial<IndividualConfig>): void;
+    error(message: string, override?: Partial<IndividualConfig>): void;
+    warn(message: string, override?: Partial<IndividualConfig>): void;
+    showInformation(title: string, subtitle: string, message: string, componentType: Type<any>): void;
+    showDialog(message: string, type?: DialogType, okCallback?: (val?: any) => any, cancelCallback?: () => any, okLabel?: string, cancelLabel?: string, subtitle?: string, title?: string, severity?: MessageSeverity, componentType?: Type<any>): Observable<any>;
+    showMessage(summary: string, detail: string, severity: MessageSeverity, override?: Partial<IndividualConfig>): any;
+    private showMessageHelper;
+    showToast(message: AlertMessage, override: Partial<IndividualConfig>): ActiveToast<{}>;
+    logDebug(msg: any): void;
+    logError(msg: any): void;
+    logInfo(msg: any): void;
+    logMessage(msg: any): void;
+    logTrace(msg: any): void;
+    logWarning(msg: any): void;
+    handleSaveError(s: SaveResult): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertService>;
+}
+export declare class AlertDialog {
+    message: string;
+    type: DialogType;
+    okCallback: (val?: any) => any;
+    cancelCallback: () => any;
+    defaultValue: string;
+    okLabel: string;
+    cancelLabel: string;
+    constructor(message: string, type: DialogType, okCallback: (val?: any) => any, cancelCallback: () => any, defaultValue: string, okLabel: string, cancelLabel: string);
+}
+export declare enum DialogType {
+    Alert = 0,
+    Confirm = 1,
+    Prompt = 2
+}
+export declare class AlertMessage {
+    severity: MessageSeverity;
+    summary: string;
+    detail: string;
+    constructor(severity: MessageSeverity, summary: string, detail: string);
+}

package/core-ux/lib/services/application.service.d.ts

@@ -0,0 +1,73 @@
+import { DataService } from '@dflat-core/web/core-data';
+import { EntityViewModel } from '@dflat-core/web/core-model';
+import { AuthService, BreadcrumbService, FilterService, LocalStoreManager, NotificationMqService, UserService } from '@dflat-core/web/core-services';
+import { ActionDataService } from '@dflat-core/web/system-data';
+import { Location } from '@angular/common';
+import { InjectionToken } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { ToastrService } from 'ngx-toastr';
+import { TestService } from '../v2/services/test.service';
+import { LayoutService } from '../v2/services/layout.service';
+import { AlertService } from './alert.service';
+import { ModalService } from './modal.service';
+import { SelectorMapperServiceBase } from './selectorMapperBase.service';
+import { SelectionService } from '../v2/services/selection.service';
+import { ActionService } from './action.service';
+import { EntityFacadeRegistryService } from '../v2/services/entity-facade-registry.service';
+import * as i0 from "@angular/core";
+export interface NavigationDeps {
+    route: ActivatedRoute;
+    router: Router;
+    location: Location;
+}
+export interface UIDeps {
+    layout: LayoutService;
+    breadcrumb: BreadcrumbService;
+    toastr: ToastrService;
+    alert: AlertService;
+    modal: ModalService;
+}
+export interface DataDeps {
+    data: DataService;
+    filter: FilterService;
+    selector: SelectorMapperServiceBase;
+}
+export interface SecurityDeps {
+    auth: AuthService;
+    user: UserService;
+}
+export interface RootDeps {
+    nav: NavigationDeps;
+    ui: UIDeps;
+    data: DataDeps;
+    security: SecurityDeps;
+    selection: SelectionService<EntityViewModel>;
+    readonly test: TestService;
+}
+export declare const ROOT_DEPS: InjectionToken<RootDeps>;
+export declare class ApplicationService {
+    deps: RootDeps;
+    MQService: NotificationMqService;
+    LocalStorageService: LocalStoreManager;
+    ActionDataService: ActionDataService;
+    ExtendedActionService: ActionService;
+    EntityFacadeRegistryService: EntityFacadeRegistryService;
+    get DataService(): DataService;
+    get ActivatedRoute(): ActivatedRoute;
+    get Router(): Router;
+    get ToastrService(): ToastrService;
+    get Location(): Location;
+    get ModalService(): ModalService;
+    get AlertService(): AlertService;
+    get AuthService(): AuthService;
+    get FilterService(): FilterService;
+    get UserService(): UserService;
+    get LayoutService(): LayoutService;
+    get SelectionService(): SelectionService<EntityViewModel>;
+    get selectorMapperService(): SelectorMapperServiceBase;
+    get BreadcrumbService(): BreadcrumbService;
+    get TestService(): TestService;
+    constructor(deps: RootDeps, MQService: NotificationMqService, LocalStorageService: LocalStoreManager, ActionDataService: ActionDataService, ExtendedActionService: ActionService, EntityFacadeRegistryService: EntityFacadeRegistryService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationService>;
+}

package/core-ux/lib/services/can-deactivate-guard.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ConfirmOptions, DflatBaseComponent } from '../model/model';
+import { ModalService } from './modal.service';
+import * as i0 from "@angular/core";
+export declare class CanDeactivateGuard {
+    modalService: ModalService;
+    constructor(modalService: ModalService);
+    canDeactivate(component: DflatBaseComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Observable<ConfirmOptions> | Promise<ConfirmOptions> | boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanDeactivateGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CanDeactivateGuard>;
+}

package/core-ux/lib/services/drag.service.d.ts

@@ -0,0 +1,54 @@
+import { DroppableDirective } from '../directives/droppable.directive';
+import * as i0 from "@angular/core";
+export declare class DragService {
+    private zoneIDs;
+    private availableZones;
+    private availableZonesList;
+    /**
+     * @desc responsible for storing the draggable elements
+     * zone target.
+     * @param {Array<string>} zoneIDs - the zoneIDs
+     */
+    startDrag(zoneIDs: Array<string>): void;
+    /**
+     * @desc responsible for matching the droppable element
+     * with a draggable element
+     * @param {string} zoneID - the zone ID to search for
+     */
+    accepts(zoneID: string): boolean;
+    /**
+     * @desc responsible for removing highlighted available zones
+     * that a draggable element can be added too.
+     */
+    removeHighLightedAvailableZones(): void;
+    /**
+     * @desc responsible for adding an available zone
+     * @param {{ begin: Function, end: Function }} zoneID - zone key from DroppableOptions
+     * @param {string} obj - reference to a start and stop object
+     */
+    addAvailableZone(zoneID: string, obj: {
+        dropDirective: DroppableDirective;
+        zoneID: string;
+        element: any;
+        begin: Function;
+        end: Function;
+    }): void;
+    /**
+     * @desc responsible for removing an available zone
+     * @param {string} zoneID - the zone ID to search for
+     */
+    removeAvailableZone(zoneID: string): void;
+    /**
+     * @desc responsible for highlighting available zones
+     * that a draggable element can be added too.
+     */
+    private highLightAvailableZones;
+    /**
+     * Return the first zone that is a parent of the specified element.
+     * @param element an Html Element
+     */
+    getAvailableContainingZone(element: any): string;
+    getDroppable(zoneId: string): DroppableDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragService>;
+}

package/core-ux/lib/services/fire-authentication.service.d.ts

@@ -0,0 +1,13 @@
+import { AuthService } from "@dflat-core/web/core-services";
+import { Observable } from "rxjs";
+import { ILoginComponent } from "../model/model";
+import { ModalService } from "./modal.service";
+import * as i0 from "@angular/core";
+export declare class FireAuthService {
+    private modalService;
+    private authService;
+    constructor(modalService: ModalService, authService: AuthService);
+    ensureLogin(loginComponentClass: ILoginComponent): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FireAuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FireAuthService>;
+}

package/core-ux/lib/services/image.service.d.ts

@@ -0,0 +1,15 @@
+import { EnvironmentBase } from '@dflat-core/web/core';
+import { ColumnDescriptor } from '@dflat-core/web/core-model';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class ImageService {
+    env: EnvironmentBase;
+    private router;
+    [x: string]: any;
+    constructor(env: EnvironmentBase, router: Router);
+    getEnumImageUrl(obj: object, enumValue: any): string;
+    getImageUrl(imageUrl: string): string;
+    getEnumImageUrlForGrid(row: any, column: ColumnDescriptor): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImageService>;
+}

package/core-ux/lib/services/modal-state.service.d.ts

@@ -0,0 +1,26 @@
+import { BsModalRef } from 'ngx-bootstrap/modal';
+import { ComponentRef, TemplateRef, Type } from '@angular/core';
+import { IModalOptions } from '../model/model';
+import * as i0 from "@angular/core";
+/**
+ * An internal service allowing to access, from the confirm modal component, the options and the modal reference.
+ * It also allows registering the TemplateRef containing the confirm modal component.
+ *
+ * It must be declared in the providers of the NgModule, but is not supposed to be used in application code
+ */
+export declare class ModalStateService {
+    /**
+     * The last options passed ConfirmService.confirm()
+     */
+    options: IModalOptions;
+    /**
+     * The last opened confirmation modal
+     */
+    modal: BsModalRef;
+    /**
+     * The template containing the confirmation modal component
+     */
+    template: Type<any> | TemplateRef<any> | ComponentRef<any> | any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalStateService>;
+}

package/core-ux/lib/services/modal.service.d.ts

@@ -0,0 +1,30 @@
+import { BsModalRef, BsModalService, ModalOptions } from 'ngx-bootstrap/modal';
+import { Observable } from 'rxjs';
+import { Injector } from '@angular/core';
+import { DialogComponentParameter } from '../modals/dialog/dialog.component';
+import { ConfirmOptions, IDialogOptions, IModalOptions } from '../model/model';
+import { ModalStateService } from './modal-state.service';
+import * as i0 from "@angular/core";
+export declare class ModalService {
+    modalService: BsModalService;
+    private state;
+    injector: Injector;
+    modalConfig: {
+        class: string;
+        animated: boolean;
+        keyboard: boolean;
+        ignoreBackdropClick: boolean;
+    };
+    constructor(modalService: BsModalService, state: ModalStateService, injector: Injector);
+    openTemplate(options: IModalOptions): Promise<any>;
+    openComponent<TComponent>(component: any, modalConfig?: any): TComponent;
+    openComponentWithState(component: any, modalConfig?: any, initialState?: any): any;
+    openComponentCustomModal(modalConfig?: ModalOptions<DialogComponentParameter>, dialogOptions?: IDialogOptions, showButtons?: boolean, canClose?: boolean): BsModalRef;
+    openComponentCustom(modalConfig?: ModalOptions, dialogOptions?: IDialogOptions, showButtons?: boolean, canClose?: boolean): Observable<any>;
+    openComponentModal(modalConfig?: ModalOptions, dialogOptions?: IDialogOptions, showButtons?: boolean, canClose?: boolean): BsModalRef;
+    openComponentSimple(modalConfig?: any, dialogOptions?: IDialogOptions, showButtons?: boolean): BsModalRef;
+    confirmModal(text?: string, actionCallback?: () => any, isCancelVisible?: boolean): Observable<ConfirmOptions>;
+    close(modal?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
+}

package/core-ux/lib/services/presentation-profile.token.d.ts

@@ -0,0 +1,40 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ColumnDescriptor } from '@dflat-core/web/core-model';
+export interface IPpService {
+    /** Opens the column selector modal for Grid purpose. */
+    openColumnSelector(config: {
+        title: string;
+        metaEntityKey: string;
+        supplierId?: number | null;
+        roleId?: number | null;
+    }): void;
+    /** Opens the column selector modal for Export purpose. */
+    openExportSelector(config: {
+        title: string;
+        metaEntityKey: string;
+        supplierId?: number | null;
+        roleId?: number | null;
+    }): void;
+    /** Resolves the effective profile columns (default merged with user profile). */
+    resolveColumns(config: {
+        metaEntityKey: string;
+        supplierId?: number | null;
+        roleId?: number | null;
+    }): Observable<any[]>;
+    /** Converts resolved PP columns to ColumnDescriptors for the data grid. */
+    buildDescriptors(ppColumns: any[], backendDescriptors: ColumnDescriptor[]): ColumnDescriptor[];
+    /** Splits columns into standard keys and custom-field ids (for export payloads). */
+    splitForExport(columns: any[]): {
+        columns: string[];
+        customFieldIds: number[];
+    };
+    /** Emits on every confirmed selection (grid + export). */
+    selectionConfirmed$: Observable<{
+        purpose: number;
+        columns: any[];
+    }>;
+    /** Emits columns only when the user confirms a Grid selection. */
+    gridSelectionConfirmed$: Observable<any[]>;
+}
+export declare const PP_SERVICE: InjectionToken<IPpService>;

package/core-ux/lib/services/selectorMapperBase.service.d.ts

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import { Type } from '@angular/core';
+import { EntityViewModel, FilterViewModel } from '@dflat-core/web/core-model';
+import { BsModalRef, ModalOptions } from 'ngx-bootstrap/modal';
+import type { BaseEditorComponent } from '../components/base-editor/base-editor.component';
+import { DialogComponentParameter } from '../modals/dialog/dialog.component';
+import { ContextChoice, IDialogOptions, IInputSelectorContext, IIsCancel } from '../model/model';
+import { BaseComponent } from '../v2/components/base-component/base-component';
+import type { NewEditorComponent } from '../v2/components/new-editor/new-editor.component';
+import { ModalService } from './modal.service';
+export interface ModalConfig {
+    showButtons?: boolean;
+    canClose?: boolean;
+    cancelLabel?: string;
+    okLabel?: string;
+}
+export declare abstract class SelectorMapperServiceBase {
+    protected modalService: ModalService;
+    constructor(modalService: ModalService);
+    getInputSelectorContext(key: string, title: string, filter?: FilterViewModel, params?: any): IInputSelectorContext;
+    abstract getComponentParams(key: string, params?: any): {
+        selectionCompType: Type<any>;
+        selectionModalTitle?: string;
+        creationComType: Type<any>;
+        creationModalTitle?: string;
+        loadFunction: (filter: FilterViewModel) => Observable<any[]>;
+    };
+    getDialogOptions(context: IInputSelectorContext, choice: ContextChoice): IDialogOptions;
+    openSelectionModal(modalEntityKey: string, modalTitle: string, filter: FilterViewModel): Observable<any>;
+    openEditionModal<TData extends EntityViewModel>(modalEntityKey: string, modalTitle: string, dataInit?: TData, callBackAction?: ((component?: BaseEditorComponent<TData>) => void), forceDataInit?: boolean, modalConfig?: ModalOptions): Observable<BaseEditorComponent<TData>>;
+    openSelectorModal<TData, TFilter>(modalEntityKey: string, modalTitle: string, filter: FilterViewModel, initFn?: (component: BaseComponent<TData, TFilter>) => void, modalOptions?: ModalOptions, modalConfig?: ModalConfig): Observable<TData[]>;
+    openComponentModal<TData, TFilter>(selectionTitle?: string, selectionComponent?: Type<any>, // BaseComponent<any,any>,
+    initFn?: (component: BaseComponent<TData, TFilter>) => void, callback?: (component: IIsCancel | BaseComponent<TData, TFilter>) => void, modalOptions?: ModalOptions, modalConfig?: ModalConfig): Observable<any>;
+    openEditorModal<TData extends EntityViewModel>(creationTitle?: string, creationComponent?: Type<any>, initFn?: (comp: NewEditorComponent<TData>) => void, modalConfig?: ModalOptions): Observable<NewEditorComponent<TData>>;
+    getSelectorModal(modalOptions?: ModalOptions<DialogComponentParameter>, dialogOptions?: IDialogOptions, modalConfig?: ModalConfig): BsModalRef;
+}

package/core-ux/lib/v2/components/actions-panel/action-panel.component.d.ts

@@ -0,0 +1,48 @@
+import { EntityViewModel, FilterDescriptor } from '@dflat-core/web/core-model';
+import { AuthService } from '@dflat-core/web/core-services';
+import { OnDestroy, OnInit } from '@angular/core';
+import { Guid } from 'guid-typescript';
+import { Action } from '../../../model/model';
+import { ActionService } from '../../../services/action.service';
+import { ModalService } from '../../../services/modal.service';
+import { PropertyChangeBus } from '../../services/property-change-bus.service';
+import { ValidationService } from '../../services/validation.service';
+import { EntityFacadeRegistryService } from '../../services/entity-facade-registry.service';
+import { EntityFacade } from '../../models/entity-facade';
+import { FormWrapper } from '../../models/utilities/form-wrapper';
+import { FilterFormModalComponent } from '../filter-form/filter-form.component';
+import * as i0 from "@angular/core";
+export declare class ActionPanelComponent implements OnInit, OnDestroy {
+    private authSevice;
+    private actionService;
+    private modalService;
+    private bus;
+    private validationService;
+    private entityFacadeRegistryService;
+    searchText: string;
+    keyword: string;
+    handleKeywordsChanged(event: any): void;
+    actions: Action[];
+    title: string;
+    entityKey: string;
+    guid: Guid;
+    constructor(authSevice: AuthService, actionService: ActionService, modalService: ModalService, bus: PropertyChangeBus, validationService: ValidationService, entityFacadeRegistryService: EntityFacadeRegistryService);
+    enableActions(): boolean;
+    private destroy$;
+    ngOnDestroy(): void;
+    facade: EntityFacade<EntityViewModel>;
+    ngOnInit(): void;
+    protected wrapper: FormWrapper;
+    fields: FilterDescriptor[];
+    private suspendFilterApply;
+    private openFilterModal;
+    setFilterFromModal(component: FilterFormModalComponent): void;
+    private handleFilterEvent;
+    hasPermission(permission: string): boolean;
+    toggleFilterView(): void;
+    canExecute(a: Action): boolean;
+    getImageUrl(icon: string): string;
+    executeAction(a: Action): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionPanelComponent, "alg-action-panel", never, { "searchText": { "alias": "searchText"; "required": false; }; "title": { "alias": "title"; "required": false; }; "entityKey": { "alias": "entityKey"; "required": false; }; "guid": { "alias": "guid"; "required": false; }; }, {}, never, ["[actions-content]"], false, never>;
+}

package/core-ux/lib/v2/components/base-component/base-component.d.ts

@@ -0,0 +1,80 @@
+import { EntityViewModel, FilterViewModel, Notification } from '@dflat-core/web/core-model';
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
+import { ActivatedRoute } from '@angular/router';
+import { Guid } from 'guid-typescript';
+import { ApplicationService } from '../../../services/application.service';
+import type { EntityFacade } from '../../models/entity-facade';
+import type { NewEditorComponent } from '../new-editor/new-editor.component';
+import type { PropertyEditorComponent } from '../property-editor/property-editor-component';
+import { DflatBaseComponent } from './../../../../lib/model/model';
+import * as i0 from "@angular/core";
+export declare abstract class BaseComponent<TFilter extends FilterViewModel, TData extends EntityViewModel> extends DflatBaseComponent implements OnInit, OnDestroy, AfterViewInit {
+    protected app: ApplicationService;
+    protected route: ActivatedRoute;
+    abstract getEntityKey(): string;
+    abstract getTitle(): string;
+    abstract getPath(): string;
+    abstract get PermissionKey(): string;
+    sectionKey: string;
+    get layoutKey(): string;
+    notif: Subscription;
+    HasFilter: boolean;
+    loadDataOnNotification: boolean;
+    displayComponent: boolean;
+    IsTheMainComponent: boolean;
+    actionBarSearchText: string;
+    newEditor: NewEditorComponent<TData>;
+    actionTitle: string;
+    log: any;
+    loadDataOnInit?: boolean;
+    baseComponentClass: string;
+    propertyGridClass: string;
+    get Filter(): TFilter;
+    get DefaultFilter(): TFilter;
+    isCardVisible: boolean;
+    protected filterInUrl: boolean;
+    errorMessage: string;
+    protected guid: Guid;
+    destroy$: Subject<void>;
+    get propertyGridComponent(): PropertyEditorComponent<TData>;
+    FILE_SECTION: string;
+    facade: EntityFacade<TData>;
+    get selectedEntities(): TData[];
+    get modifiedEntities(): TData[];
+    filterFn?: (selected: TData[]) => FilterViewModel;
+    constructor(app: ApplicationService, route: ActivatedRoute);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    getIcon(): string;
+    subscribeEntityNotification(): void;
+    unsubscribeEntityNotification(): void;
+    onNotificationHandled(notif: Notification): void;
+    ngOnDestroy(): void;
+    private initBreadCrumb;
+    refresh(): void;
+    Search(filter?: any, resetPage?: boolean): void;
+    private CopyFilterProperties;
+    protected readonly ppService: import("../../../services/presentation-profile.token").IPpService;
+    private registerSelectColumnsAction;
+    protected openColumnSelector(): void;
+    protected getPpMetaEntityKey(): string | null;
+    protected getPpConfig(): {
+        metaEntityKey: string;
+        supplierId?: number | null;
+        roleId?: number | null;
+    };
+    protected applyProfileColumns(ppColumns: any[]): void;
+    loadData(): void;
+    performLoadData(): void;
+    loadActionDescriptors(): void;
+    initCurrentTab(filter: FilterViewModel): void;
+    onDispose(): void;
+    filterAction(actionName: string): void;
+    save(): void;
+    delete(): void;
+    add(param?: Partial<TData>): void;
+    setLog(log: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseComponent<any, any>, never, never, { "loadDataOnInit": { "alias": "loadDataOnInit"; "required": false; }; "baseComponentClass": { "alias": "baseComponentClass"; "required": false; }; "propertyGridClass": { "alias": "propertyGridClass"; "required": false; }; }, {}, never, never, true, never>;
+}

package/core-ux/lib/v2/components/cell-renderer/cell-renderer.component.d.ts

@@ -0,0 +1,11 @@
+import { ColumnDescriptor } from "@dflat-core/web/core-model";
+import * as i0 from "@angular/core";
+export declare class CellRendererComponent {
+    row: any;
+    column: ColumnDescriptor;
+    context: any;
+    isUndefined(value: any): boolean;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CellRendererComponent, "alg-cell-renderer", never, { "row": { "alias": "row"; "required": false; }; "column": { "alias": "column"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, false, never>;
+}