@dflat-core/web 1.0.0-beta

package/core-ux/lib/v2/models/contexts/layout-context.d.ts

@@ -0,0 +1,57 @@
+import { LayoutPreferences, LayoutService } from "../../services/layout.service";
+import { SelectionContext } from "./selection-context";
+export declare class LayoutContext {
+    private entityKey;
+    private selection;
+    layoutService: LayoutService;
+    private _propertyPanelState$;
+    propertyPanelVisible$: import("rxjs").Observable<boolean>;
+    setShowPropertyPanel(visible: boolean): void;
+    enablePropertyPanel(): void;
+    disablePropertyPanel(): void;
+    private _showActionTitle$;
+    showActionTitle$: import("rxjs").Observable<boolean>;
+    private _editModeEnabled$;
+    editModeEnabled$: import("rxjs").Observable<boolean>;
+    private _showFilterButton$;
+    showFilterButton$: import("rxjs").Observable<boolean>;
+    private _showFilterSummary$;
+    showFilterSummary$: import("rxjs").Observable<boolean>;
+    private _showSearchButton$;
+    showSearchButton$: import("rxjs").Observable<boolean>;
+    private _showPaginator$;
+    showPaginator$: import("rxjs").Observable<boolean>;
+    private _showActionBar$;
+    showActionBar$: import("rxjs").Observable<boolean>;
+    private _showActionSearchBar$;
+    showActionSearchBar$: import("rxjs").Observable<boolean>;
+    private _isMainComponent$;
+    isMainComponent$: import("rxjs").Observable<boolean>;
+    private _applyFilterParams$;
+    applyFilterParams$: import("rxjs").Observable<boolean>;
+    private _entityKey$;
+    entityKey$: import("rxjs").Observable<string>;
+    private _isSection$;
+    isSection$: import("rxjs").Observable<boolean>;
+    private _defaultPreferences$;
+    defaultPreferences$: import("rxjs").Observable<LayoutPreferences>;
+    constructor(entityKey: string, selection: SelectionContext<any>, layoutService: LayoutService);
+    setEditModeEnabled(v: boolean): void;
+    setShowFilterButton(v: boolean): void;
+    setShowFilterSummary(v: boolean): void;
+    setShowSearchButton(v: boolean): void;
+    setShowPaginator(v: boolean): void;
+    setShowActionTitle(v: boolean): void;
+    setShowActionBar(v: boolean): void;
+    setShowActionSearchBar(v: boolean): void;
+    setIsMainComponent(v: boolean): void;
+    setIsSection(v: boolean): void;
+    setApplyFilterParams(v: boolean): void;
+    togglePropertyPanel(): void;
+    /**
+     * Sets fixed layout preferences from component/facade (not persisted to localStorage)
+     * Priority: Fixed > User > Default
+     * @param preferences Fixed layout preferences to apply
+     */
+    setFixedLayout(preferences: LayoutPreferences): void;
+}

package/core-ux/lib/v2/models/contexts/logger-context.d.ts

@@ -0,0 +1,5 @@
+export declare class LoggerContext {
+    debugModeEnabled: boolean;
+    constructor();
+    debug(s: any): void;
+}

package/core-ux/lib/v2/models/contexts/section-context.d.ts

@@ -0,0 +1,73 @@
+import { EntityViewModel, EntityViewModelWithFields, ExtendedProperty, FilterViewModel } from '@dflat-core/web/core-model';
+import { TemplateRef, Type, ViewContainerRef } from '@angular/core';
+import type { BaseComponent } from '../../components/base-component/base-component';
+import { EditorTabSetComponent } from '../../components/editor-tabset/editor-tabset.component';
+import { EntityFacade } from '../entity-facade';
+import { ActionContext } from './action-context';
+import { EntityConfigContext } from './entity-config-context';
+import { SelectionContext } from './selection-context';
+export interface ISectionComponent<T extends EntityViewModel> {
+    isSection?: boolean;
+    facade?: EntityFacade<T>;
+}
+export interface ISectionConfig<T extends EntityViewModel, F extends FilterViewModel, P extends EntityViewModel> {
+    initOverride?: (component: ISectionComponent<T>) => void;
+    layoutOverride?: (component: ISectionComponent<T>) => void;
+    filterOverride?: (selected: P[]) => F;
+    selectionOverride?: (component: ISectionComponent<T>, selected: P[]) => void;
+    show?: (context: any[] | ISectionComponent<T> | any) => boolean;
+    afterInitOverride?: (component: ISectionComponent<T>) => void;
+}
+export declare function filterFromId<TData extends EntityViewModel, F extends FilterViewModel>(key: keyof F): (selected: TData[]) => F;
+export interface ISpecificSectionContext<T extends EntityViewModel, F extends FilterViewModel, P extends EntityViewModel> {
+    Name?: string;
+    IconUrl?: string;
+    Template?: Type<any> | TemplateRef<any> | any;
+    Config?: ISectionConfig<T, F, P>;
+    IsVisible?: boolean;
+}
+export interface ISectionContext {
+    sectionName: string;
+    log: any;
+}
+export declare class SectionContext<P extends EntityViewModel> {
+    private selection;
+    private config;
+    private actions;
+    constructor(selection: SelectionContext<P>, config: EntityConfigContext<P, any>, actions: ActionContext<P>);
+    private componentRefs;
+    private activeTabIndex;
+    private sections;
+    private sectionsSubject;
+    readonly sections$: import("rxjs").Observable<ISpecificSectionContext<any, any, P>[]>;
+    private destroy$;
+    private viewModel?;
+    private tabset?;
+    registerTabset(tabset: EditorTabSetComponent): void;
+    private dynamicContainers;
+    registerDynamicContainers(containers: ViewContainerRef[]): void;
+    private defaultLayoutOverride;
+    registerSection<F extends FilterViewModel, T extends EntityViewModel>(name: string, template: Type<ISectionComponent<T>>, config?: ISectionConfig<T, F, P>): ISpecificSectionContext<T, F, P>;
+    getActiveTab(): number;
+    renderSection(section: ISpecificSectionContext<any, any, P>, container: ViewContainerRef): void;
+    private attachComponentOverrides;
+    setViewModel(vm: EntityViewModelWithFields<any>): void;
+    private renderedSections;
+    lastSelected: P[];
+    private handleSelectionChanged;
+    private updateSectionVisibility;
+    applyFilterOnSection<F extends FilterViewModel, T extends EntityViewModel>(component: ISectionComponent<T>, cfg: ISectionConfig<T, F, P>, selected: P[], init?: boolean): void;
+    private extendedPropertiesSubject;
+    extendedProperties$: import("rxjs").Observable<ExtendedProperty[]>;
+    loadExtendedProperties(selected: P[]): void;
+    reset(): void;
+    destroy(): void;
+    changeActiveSection(tabIndex: number): void;
+    setSectionDirty(sectionName?: string): void;
+    refreshSection(sectionName: string): void;
+    private activateTab;
+    private readonly FIELD_TAB_COUNT;
+    private findFirstVisibleSectionIndex;
+    setLog(context: ISectionContext): void;
+    getBaseSectionComponent<TFilter extends FilterViewModel, TData extends EntityViewModel>(sectionName: string): BaseComponent<TFilter, TData> | null;
+}

package/core-ux/lib/v2/models/contexts/selection-context.d.ts

@@ -0,0 +1,45 @@
+import { EntityViewModel, EntityViewModelWithFields, Section } from '@dflat-core/web/core-model';
+import { DataContext } from './data-context';
+import { SelectionType } from '@swimlane/ngx-datatable';
+import { Observable } from 'rxjs';
+export declare class SelectionContext<TData extends EntityViewModel> {
+    private data;
+    private selected;
+    private selectedSubject;
+    private clearedSubject;
+    cleared$: Observable<void>;
+    readonly selected$: Observable<TData[]>;
+    readonly hasSelection$: Observable<boolean>;
+    private lastSelected;
+    private viewModel?;
+    private currrentDatas;
+    private compareFn;
+    private selectionType;
+    constructor(data: DataContext<TData>);
+    setCurrentData(current: TData[]): void;
+    getCurrentData(): TData[];
+    get Selected(): TData[];
+    getSelected(): TData[];
+    setViewModel(vm: EntityViewModelWithFields<TData>): void;
+    select(items: TData[]): void;
+    /**
+     * Notify listeners that selection was cleared
+     */
+    clear(): void;
+    getOriginal(id: number): TData;
+    isMultiSelect(): boolean;
+    hasSelection(): boolean;
+    isNewEntity(): boolean;
+    getSelectedById$(id: number | string): Observable<TData>;
+    adaptSelectionToViewModel(selected: TData[], fieldSections: Section[]): TData;
+    private formatForViewModel;
+    private formatExtended;
+    private emit;
+    setSelectionType(type?: SelectionType): void;
+    setCompareFn(fn: (a: TData, b: TData) => boolean): void;
+    toggle(item: TData): void;
+    selectRange(item: TData): void;
+    private selectLastRow;
+    static nextUniqueId: number;
+    createNewEntity(initValue: Partial<TData>): void;
+}

package/core-ux/lib/v2/models/entity-facade.d.ts

@@ -0,0 +1,35 @@
+import { EntityViewModel, FilterViewModel } from '@dflat-core/web/core-model';
+import { Observable } from 'rxjs';
+import { FacadeDeps } from '../services/entity-facade-registry.service';
+import { ActionContext } from './contexts/action-context';
+import { ChangeDetectionContext } from './contexts/change-detection-context';
+import { DataContext } from './contexts/data-context';
+import { DataGridStyleContext } from './contexts/data-grid-style-context';
+import { EditorContext } from './contexts/editor-context';
+import { EntityConfigContext } from './contexts/entity-config-context';
+import { FilterContext } from './contexts/filter-context';
+import { LayoutContext } from './contexts/layout-context';
+import { LoggerContext } from './contexts/logger-context';
+import { SectionContext } from './contexts/section-context';
+import { SelectionContext } from './contexts/selection-context';
+import { FacadeLoadGuard } from './guards/facade-load-guard';
+export declare class EntityFacade<TData extends EntityViewModel> {
+    private entityKey;
+    facadeDeps: FacadeDeps;
+    readonly filter: FilterContext<TData, any>;
+    readonly selection: SelectionContext<TData>;
+    readonly data: DataContext<TData>;
+    readonly change: ChangeDetectionContext<TData>;
+    readonly config: EntityConfigContext<TData, any>;
+    readonly editor: EditorContext;
+    readonly style: DataGridStyleContext;
+    readonly actions: ActionContext<TData>;
+    readonly layout: LayoutContext;
+    readonly sections: SectionContext<TData>;
+    readonly logger: LoggerContext;
+    readonly interceptor: FacadeLoadGuard;
+    readonly criteria$: Observable<FilterViewModel>;
+    constructor(entityKey: string, facadeDeps: FacadeDeps);
+    setReadOnlyMode(value: boolean): void;
+    reset(): void;
+}

package/core-ux/lib/v2/models/guards/facade-load-guard.d.ts

@@ -0,0 +1,35 @@
+export declare class FacadeLoadGuard {
+    private configLoaded;
+    private filterReady;
+    private dataReady;
+    private selectionReady;
+    private changeReady;
+    private actionsReady;
+    private sectionsReady;
+    private viewModelLoaded;
+    private layoutReady;
+    private facadeReady;
+    private componentInitReady;
+    configLoaded$: import("rxjs").Observable<void>;
+    filterReady$: import("rxjs").Observable<void>;
+    dataReady$: import("rxjs").Observable<void>;
+    selectionReady$: import("rxjs").Observable<void>;
+    changeReady$: import("rxjs").Observable<void>;
+    actionsReady$: import("rxjs").Observable<void>;
+    sectionsReady$: import("rxjs").Observable<void>;
+    viewModelLoaded$: import("rxjs").Observable<void>;
+    layoutReady$: import("rxjs").Observable<void>;
+    facadeReady$: import("rxjs").Observable<void>;
+    componentInitReady$: import("rxjs").Observable<void>;
+    markConfigLoaded(): void;
+    markFilterReady(): void;
+    markDataReady(): void;
+    markSelectionReady(): void;
+    markChangeReady(): void;
+    markActionsReady(): void;
+    markSectionsReady(): void;
+    markViewModelLoaded(): void;
+    markLayoutReady(): void;
+    markFacadeReady(): void;
+    markComponentInitReady(): void;
+}

package/core-ux/lib/v2/models/guards/filter-lifecycle-guard.d.ts

@@ -0,0 +1,29 @@
+import { FilterDescriptor, FilterViewModel } from "@dflat-core/web/core-model";
+import { ActionContext } from "../contexts/action-context";
+import { ChangeDetectionContext } from "../contexts/change-detection-context";
+import { FilterContext } from "../contexts/filter-context";
+import { ModalService } from "../../../services/modal.service";
+import { Router } from "@angular/router";
+import { Observable } from "rxjs";
+export declare class FilterLifecycleGuard {
+    private readonly router;
+    private readonly change;
+    private readonly actions;
+    private readonly modal;
+    private readonly filter;
+    constructor(router: Router, change: ChangeDetectionContext<any>, actions: ActionContext<any>, modal: ModalService, filter: FilterContext<any, any>);
+    private msg;
+    private readonly suspendFilterApply$;
+    resolveOpenFilter$(openFilter$: Observable<void>, filterReady$: Observable<void>): Observable<void>;
+    private initialized;
+    private readonly filterReady$;
+    markFilterReady(): void;
+    intercept$(baseCriteria$: Observable<FilterViewModel>, urlEnabled$: Observable<boolean>, filterDescriptors$: Observable<FilterDescriptor[]>): Observable<FilterViewModel>;
+    private resolveInitialCriteria$;
+    guardCriteria$(criteria$: Observable<FilterViewModel>): Observable<FilterViewModel>;
+    private syncUrl$;
+    private confirmModification$;
+    private readFilterFromUrl;
+    private CopyFilterProperties;
+    private syncUrl;
+}

package/core-ux/lib/v2/models/states/sorting-state.d.ts

@@ -0,0 +1,14 @@
+import { EntityViewModel } from "@dflat-core/web/core-model";
+import { ISorting } from "../../../model/datagrid";
+import { BehaviorSubject, Observable } from "rxjs";
+export declare class SortingState<TData extends EntityViewModel> {
+    readonly entityKey: string;
+    readonly property$: BehaviorSubject<keyof TData>;
+    readonly direction$: BehaviorSubject<"asc" | "desc">;
+    constructor(entityKey: string);
+    get changes$(): Observable<ISorting<TData>>;
+    private snapshot;
+    updateProperty(property: keyof TData): void;
+    private toggleDirection;
+    reset(): void;
+}

package/core-ux/lib/v2/models/utilities/action-definition.d.ts

@@ -0,0 +1,38 @@
+import type { ActionResult } from "../contexts/action-context";
+import { Observable } from "rxjs";
+export type FacadeAction = ((param?: any) => void) | ((param?: any) => Observable<ActionResult<any>>);
+export declare class ActionDefinition {
+    readonly name: string;
+    readonly title: string;
+    readonly showTitle: boolean;
+    readonly selectionNeeded: boolean;
+    readonly multiSelection: boolean;
+    readonly icon: string;
+    readonly cssClass: string;
+    action: FacadeAction;
+    isActive: () => boolean;
+    getParameter?: () => any;
+    permission?: string;
+    isVisible: boolean;
+    disabled: boolean;
+    private readonly enabledSubject;
+    readonly enabled$: Observable<boolean>;
+    constructor(init: {
+        name: string;
+        title: string;
+        showTitle: boolean;
+        selectionNeeded: boolean;
+        multiSelection: boolean;
+        icon: string;
+        cssClass: string;
+        action?: FacadeAction;
+        permission?: string;
+        isActive?: () => boolean;
+        isVisible: boolean;
+        getParameter?: () => any;
+    });
+    updateEnabled(enabled: boolean): void;
+    execute(): void;
+    hide(): void;
+    show(): void;
+}

package/core-ux/lib/v2/models/utilities/change-utilities.d.ts

@@ -0,0 +1,11 @@
+export declare class ChangeUtilities {
+    private static excludedKeys;
+    static isComparableProperty(key: string, additionalExcludedKeys?: string[]): boolean;
+    static deepComparer(current: any, original: any, depth?: number, maxDepth?: number): boolean;
+    private static compareArrays;
+    private static compareDates;
+    private static toMomentDate;
+    private static isObject;
+    private static isDate;
+    private static isBoolean;
+}

package/core-ux/lib/v2/models/utilities/entity-updater.d.ts

@@ -0,0 +1,11 @@
+import { EntityViewModel, PagedList } from "@dflat-core/web/core-model";
+import { SelectionContext } from "../contexts/selection-context";
+export declare class EntityUpdater<TData extends EntityViewModel> {
+    private selection;
+    private datas;
+    constructor(selection: SelectionContext<TData>, datas: PagedList<TData>);
+    applyUpdates(updated: TData[]): void;
+    insertEntity(newEntity: TData, autoSelect?: boolean): void;
+    private updateDataset;
+    private updateSelection;
+}

package/core-ux/lib/v2/models/utilities/form-wrapper.d.ts

@@ -0,0 +1,30 @@
+import { EntityViewModel, FieldDescriptor, FieldValidators, FilterDescriptor, PropertyEditorEvent } from "@dflat-core/web/core-model";
+import { FormControl, FormGroup } from "@angular/forms";
+import { PropertyChangeBus } from "../../services/property-change-bus.service";
+import { ValidationService } from "../../services/validation.service";
+export declare class FormWrapper {
+    private validationService;
+    private bus;
+    private validateAfterEachChange;
+    private destroy$;
+    private change$;
+    readonly changes$: import("rxjs").Observable<PropertyEditorEvent>;
+    readonly form: FormGroup<{}>;
+    constructor(validationService: ValidationService, bus: PropertyChangeBus, validateAfterEachChange?: boolean);
+    private Fields;
+    private initializing;
+    private initialized;
+    initialize(fields: FieldDescriptor[]): void;
+    hookFormEntity(vm: EntityViewModel): void;
+    patch(vm: EntityViewModel): void;
+    reset(vm: EntityViewModel): void;
+    destroy(): void;
+    updateFields(field?: FilterDescriptor): void;
+    applyCascadeFrom(field: FieldDescriptor): void;
+    private recalculateAllCascades;
+    alterFieldCascadeData(field: FieldDescriptor, reset?: boolean): void;
+    handleCascadeFilters(field: FieldDescriptor): void;
+    resetFieldData(field: FilterDescriptor): void;
+    handleConditionalField(_field: FilterDescriptor): void;
+    addValidators(control: FormControl, validators: FieldValidators): void;
+}

package/core-ux/lib/v2/models/utilities/row-registry.d.ts

@@ -0,0 +1,15 @@
+export declare class RowRegistry {
+    private readySubject;
+    private map;
+    private registeredCount;
+    private expectedCount;
+    ready$: import("rxjs").Observable<boolean>;
+    unregisterRow(id: string): void;
+    get(id: string): HTMLElement | undefined;
+    setExpectedCount(count: number): void;
+    registerRow(id: string, el: HTMLElement): void;
+    clear(): void;
+    notifyReady(): void;
+    notifyNotReady(): void;
+    isReady(): boolean;
+}

package/core-ux/lib/v2/models/utilities/selection-styler.d.ts

@@ -0,0 +1,15 @@
+import { EntityViewModel } from '@dflat-core/web/core-model';
+import { Renderer2 } from '@angular/core';
+import { RowRegistry } from './row-registry';
+export declare class SelectionStyler<TData extends EntityViewModel> {
+    private renderer;
+    private registry;
+    constructor(renderer: Renderer2, registry: RowRegistry);
+    private lastStyled;
+    applySelected(rows: TData[], guid: string): void;
+    updateRowState(row: TData, guid: string): void;
+    isNew(row: TData): boolean;
+    isModified(row: TData): boolean;
+    isInvalid(row: TData): boolean;
+    isWarning(row: TData): boolean;
+}

package/core-ux/lib/v2/pipes/gridstyle.pipe.d.ts

@@ -0,0 +1,15 @@
+import { ColumnDescriptor, EntityViewModel } from '@dflat-core/web/core-model';
+import { PipeTransform } from '@angular/core';
+import { DataGridStyleContext } from '../models/contexts/data-grid-style-context';
+import * as i0 from "@angular/core";
+export declare class GridStylePipe implements PipeTransform {
+    transform(type: 'cell' | 'column' | 'header' | 'alternating' | 'rowstate', context: DataGridStyleContext, args?: {
+        row?: EntityViewModel;
+        column?: ColumnDescriptor;
+        index?: number;
+        maxIndex?: number;
+        hasAggregates?: boolean;
+    }): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridStylePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GridStylePipe, "gridStyle", true>;
+}

package/core-ux/lib/v2/services/app-config.service.d.ts

@@ -0,0 +1,22 @@
+import { EntityConfig } from '@dflat-core/web/core-model';
+import { Observable } from 'rxjs';
+import { ApplicationService } from '../../services/application.service';
+import * as i0 from "@angular/core";
+export declare class AppConfigService {
+    private app;
+    private memoryCache;
+    private readonly ttl;
+    private readonly storagePrefix;
+    constructor(app: ApplicationService);
+    private initializeFromLocalStorage;
+    private loadConfig;
+    private saveToLocalStorage;
+    resetConfig(entityKey?: string): void;
+    getAllConfigs(): Map<string, Observable<EntityConfig>>;
+    private configSubjects;
+    getConfig$(entityKey: string): Observable<EntityConfig>;
+    /** Manual reload (e.g. after save or refresh) */
+    reloadConfig(entityKey: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppConfigService>;
+}

package/core-ux/lib/v2/services/entity-facade-registry.service.d.ts

@@ -0,0 +1,28 @@
+import { DataService } from '@dflat-core/web/core-data';
+import { EntityViewModel } from '@dflat-core/web/core-model';
+import { Router } from '@angular/router';
+import { Guid } from 'guid-typescript';
+import type { AlertService } from '../../services/alert.service';
+import { RootDeps } from '../../services/application.service';
+import { ModalService } from '../../services/modal.service';
+import type { SelectorMapperServiceBase } from '../../services/selectorMapperBase.service';
+import { EntityFacade } from '../models/entity-facade';
+import { LayoutService } from './layout.service';
+import * as i0 from "@angular/core";
+export interface FacadeDeps {
+    alert: AlertService;
+    modal: ModalService;
+    data: DataService;
+    selector: SelectorMapperServiceBase;
+    router: Router;
+    layout: LayoutService;
+}
+export declare class EntityFacadeRegistryService {
+    private readonly root;
+    private facades;
+    constructor(root: RootDeps);
+    buildFacade<TData extends EntityViewModel>(key: string, id: Guid): EntityFacade<TData>;
+    getFacade<TData extends EntityViewModel>(key: string, id: Guid): EntityFacade<TData>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityFacadeRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityFacadeRegistryService>;
+}

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

@@ -0,0 +1,21 @@
+import { EntityViewModel } from '@dflat-core/web/core-model';
+import { Type } from '@angular/core';
+import { BsModalRef, BsModalService, ModalOptions } from 'ngx-bootstrap/modal';
+import { Observable } from 'rxjs';
+import { DialogComponentParameter } from '../../modals/dialog/dialog.component';
+import { IDialogOptions, IIsCancel } from '../../model/model';
+import { ModalConfig } from '../../services/selectorMapperBase.service';
+import { BaseComponent } from '../components/base-component/base-component';
+import type { NewEditorComponent } from '../components/new-editor/new-editor.component';
+import * as i0 from "@angular/core";
+export declare class FacadeModalService {
+    private modalService;
+    constructor(modalService: BsModalService);
+    openSelectorModal<TData, TFilter>(selectionTitle?: string, selectionComponent?: Type<any>, initFn?: (component: BaseComponent<TData, TFilter> | NewEditorComponent<TData>) => void, modalOptions?: ModalOptions, modalConfig?: ModalConfig): Observable<TData[]>;
+    openComponentModal<TData, TFilter>(selectionTitle?: string, selectionComponent?: Type<any>, // BaseComponent<any,any>,
+    initFn?: (component: BaseComponent<TData, TFilter> | NewEditorComponent<TData>) => 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FacadeModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FacadeModalService>;
+}

package/core-ux/lib/v2/services/layout.service.d.ts

@@ -0,0 +1,93 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface LayoutEntityPreferences {
+    Preferences: LayoutPreferences;
+    EntityKey: string;
+    EnableHandling: boolean;
+}
+/**
+ * Interface defining the structure of layout preferences
+ */
+export interface LayoutPreferences {
+    IsVerticalLayout: boolean;
+    PropertyFlexGrow?: number;
+    isFixed?: boolean;
+    source?: 'default' | 'user' | 'fixed';
+}
+export interface LayoutKey {
+    entityKey: string;
+    sectionKey?: string;
+}
+export declare function layoutKeyToString(k: LayoutKey): string;
+export declare class LayoutService {
+    private readonly LAYOUT_PREFERENCES_KEY;
+    private layoutPreferences$;
+    private preferencesMap;
+    private fixedLayoutMap;
+    private resizeSubject;
+    resize$: Observable<void>;
+    private _defaultPreferences;
+    constructor();
+    private loadPreferencesOnInit;
+    /**
+     * Gets preferences for a specific entity with resolution logic:
+     * Priority: Fixed Layout (facade defined) > User Layout (persisted) > Default Layout
+     * @param entityKey Unique identifier for the entity
+     * @returns Observable of LayoutPreferences
+     */
+    getPreferencesByEntityKey(id: string): Observable<LayoutPreferences>;
+    /**
+     * Resolves layout preferences with priority: Fixed > User > Default
+     * @param entityKey Unique identifier for the entity
+     * @returns Resolved LayoutPreferences
+     */
+    private resolveLayout;
+    saveLayoutPreferences(): void;
+    /**
+     * Saves preferences for a specific entity
+     * @param entityKey Unique identifier for the entity
+     * @param preferences Layout preferences to save
+     */
+    savePreferences(id: string, preferences: LayoutPreferences): void;
+    /**
+     * Sets fixed layout preferences (defined by facade/code, not persisted)
+     * @param entityKey Unique identifier for the entity
+     * @param preferences Fixed layout preferences
+     */
+    setFixedLayoutPreferences(entityKey: string, preferences: LayoutPreferences): void;
+    /**
+     * Clears fixed layout preferences for an entity
+     * @param entityKey Unique identifier for the entity
+     */
+    clearFixedLayoutPreference(entityKey: string): void;
+    /**
+     * Gets the fixed layout preferences for an entity
+     * @param entityKey Unique identifier for the entity
+     * @returns Fixed layout preferences or undefined if not set
+     */
+    getFixedLayoutPreferences(entityKey: string): LayoutPreferences | undefined;
+    /**
+     * Updates the vertical layout setting for an entity
+     * @param entityKey Unique identifier for the entity
+     * @param value New vertical layout value
+     */
+    setIsVerticalLayout(layoutKey: string, value: boolean): void;
+    expandPropertyflexGrow(key: string, flexGrow: number): void;
+    /**
+     * @returns default layout preferences
+     */
+    getDefaultPreferences(): LayoutPreferences;
+    /**
+     * Set default layout preferences
+     * @param value Layout preferences to set as default
+     */
+    setDefaultPreferences(value: LayoutPreferences): void;
+    /**
+     * Stops the resizing operation and saves preferences
+     * @param layoutKey Entity identifier
+     * @param flexGrowValue Flex grow value to save
+     */
+    stopResizing(layoutKey: string, flexGrowValue?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
+}

package/core-ux/lib/v2/services/property-change-bus.service.d.ts

@@ -0,0 +1,9 @@
+import { PropertyEditorEvent } from "@dflat-core/web/core-model";
+import * as i0 from "@angular/core";
+export declare class PropertyChangeBus {
+    private subject;
+    readonly events$: import("rxjs").Observable<PropertyEditorEvent>;
+    emit(evt: PropertyEditorEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyChangeBus, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyChangeBus>;
+}

package/core-ux/lib/v2/services/selection.service.d.ts

@@ -0,0 +1,23 @@
+import { EntityViewModel, EntityViewModelWithFields, ExtendedProperty, Section } from '@dflat-core/web/core-model';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SelectionService<TData extends EntityViewModel> {
+    private selectedMap;
+    private selectionSubjects;
+    getSelected(entityKey: string): TData[];
+    adaptSelectionToViewModel(selected: TData[], fieldSections: Section[]): TData;
+    setSelected(entityKey: string, data: TData[], viewModel: EntityViewModelWithFields<TData>): void;
+    formatData(data: TData[], viewModel: EntityViewModelWithFields<TData>): void;
+    getFormattedValue(p: ExtendedProperty): any;
+    getSelectionSubject(entityKey: string): BehaviorSubject<TData[]>;
+    clearSelection(entityKey: string): void;
+    isSelected(entityKey: string, item: TData): boolean;
+    private originalMap;
+    setOriginals(entityKey: string, data: TData[]): void;
+    getOriginals(entityKey: string): TData[];
+    isMultiSelect(entityKey: string): boolean;
+    haseSelection(entityKey: string): boolean;
+    getSelectedById$(entityKey: string, id: number | string): Observable<TData>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionService<any>>;
+}