@dflat-core/web 1.0.0-beta

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

@@ -0,0 +1,33 @@
+import { FieldDescriptor } from "@dflat-core/web/core-model";
+import { InputSelectorOptions } from "../../../model/model";
+import { SelectorMapperServiceBase } from "../../../services/selectorMapperBase.service";
+import { AfterViewInit, ChangeDetectorRef, EventEmitter } from "@angular/core";
+import { AbstractControl, FormControl } from "@angular/forms";
+import { Observable } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class SelectorComponent implements AfterViewInit {
+    private selectorMapperService;
+    private cd;
+    field: FieldDescriptor;
+    control: AbstractControl;
+    SupplierId: number;
+    get formControl(): FormControl;
+    private search$;
+    private page$;
+    items$: Observable<any[]>;
+    options: InputSelectorOptions;
+    private context;
+    constructor(selectorMapperService: SelectorMapperServiceBase, cd: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    onSearch(param: {
+        term: string;
+        items: any[];
+    }): void;
+    loadNextPage(): void;
+    openModal(): void;
+    createNewItem(searchTerm: string): void;
+    change: EventEmitter<any>;
+    onChanged(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectorComponent, "alg-selector", never, { "field": { "alias": "field"; "required": true; }; "control": { "alias": "control"; "required": true; }; "SupplierId": { "alias": "SupplierId"; "required": false; }; }, { "change": "change"; }, never, never, false, never>;
+}

package/core-ux/lib/v2/components/selector/selector.model.d.ts

@@ -0,0 +1,19 @@
+import { InputSelectorOptions } from "../../../model/model";
+import { Observable } from "rxjs";
+export interface SelectorConfig {
+    load: (req: SelectorRequest) => Observable<any[]>;
+    options: InputSelectorOptions;
+    pageSize: number;
+}
+export interface SelectorRequest {
+    term: string;
+    page: number;
+    pageSize: number;
+}
+export declare class SelectorDataSource {
+    private config;
+    private cache;
+    constructor(config: SelectorConfig);
+    load(term: string, page: number): Observable<any[]>;
+    clearCache(): void;
+}

package/core-ux/lib/v2/components/standard-page-layout/standard-page-layout.component.d.ts

@@ -0,0 +1,29 @@
+import { EntityViewModel } from '@dflat-core/web/core-model';
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { Guid } from 'guid-typescript';
+import { ApplicationService } from '../../../services/application.service';
+import { BaseShortcutsDirective } from '../../directives/base-shortcut.directive';
+import { LayoutHandlerDirective } from '../../directives/layout-handler.directive';
+import { EntityFacade } from '../../models/entity-facade';
+import * as i0 from "@angular/core";
+export declare class StandardPageLayoutComponent implements OnInit, OnDestroy {
+    private app;
+    layoutKey: string;
+    entityKey: string;
+    guid: Guid;
+    facade: EntityFacade<EntityViewModel>;
+    layoutHandlerDirective: LayoutHandlerDirective;
+    baseShortcutsDirective: BaseShortcutsDirective;
+    set rightPanelRef(ref: ElementRef<HTMLDivElement> | undefined);
+    set separatorRef(ref: ElementRef<HTMLDivElement> | undefined);
+    middlePanelRef: ElementRef<HTMLDivElement>;
+    constructor(app: ApplicationService);
+    private destroy$;
+    ngOnDestroy(): void;
+    onBeforeUnload(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    toggleLayout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StandardPageLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StandardPageLayoutComponent, "alg-standard-page-layout", never, { "layoutKey": { "alias": "layoutKey"; "required": false; }; "entityKey": { "alias": "entityKey"; "required": false; }; "guid": { "alias": "guid"; "required": false; }; }, {}, never, ["[actionsContent]", "[middleHeader]", "[middleContent]", "[middleFooter]", "[rightContent]"], false, never>;
+}

package/core-ux/lib/v2/directives/base-shortcut.directive.d.ts

@@ -0,0 +1,15 @@
+import { EntityFacade } from "../models/entity-facade";
+import { OnDestroy, ElementRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class BaseShortcutsDirective implements OnDestroy {
+    private el;
+    facade: EntityFacade<any>;
+    private destroy$;
+    isFocused: boolean;
+    constructor(el: ElementRef);
+    private handleKeydown;
+    private execute;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseShortcutsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseShortcutsDirective, "[baseShortcuts]", ["baseShortcuts"], { "facade": { "alias": "facade"; "required": false; }; }, {}, never, never, false, never>;
+}

package/core-ux/lib/v2/directives/hide-on-threshold.directive.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef, Renderer2, OnInit, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class HideOnThresholdDirective implements OnInit, OnDestroy {
+    private el;
+    private renderer;
+    minWidth: number;
+    minHeight: number | null;
+    minFlexGrow: number | null;
+    private resizeObserver;
+    /**
+     * Constructor injects required services
+     * @param el Reference to the host element
+     * @param renderer Service for safe DOM manipulation
+     */
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HideOnThresholdDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HideOnThresholdDirective, "[hideOnThreshold]", never, { "minWidth": { "alias": "minWidth"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "minFlexGrow": { "alias": "minFlexGrow"; "required": false; }; }, {}, never, never, false, never>;
+}

package/core-ux/lib/v2/directives/layout-handler.directive.d.ts

@@ -0,0 +1,54 @@
+import { LayoutContext } from '../models/contexts/layout-context';
+import { AfterViewInit, ElementRef, OnDestroy, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class LayoutHandlerDirective implements OnDestroy, AfterViewInit {
+    private renderer;
+    private elRef;
+    isVerticalLayout: boolean;
+    propertyflexGrow: number;
+    middlePanel: HTMLElement;
+    rightPanel?: HTMLElement;
+    _separator?: HTMLElement;
+    /**
+     * Constructor for the directive
+     * @param layoutService Layout management service
+     * @param renderer DOM rendering service
+     * @param elRef Reference to the DOM element
+     */
+    constructor(renderer: Renderer2, elRef: ElementRef);
+    ngAfterViewInit(): void;
+    scheduleLayout(): void;
+    entityKey: string;
+    isSection: boolean;
+    layoutContext: LayoutContext;
+    private destroy$;
+    ngOnDestroy(): void;
+    /**
+     * Toggles the property panel size
+     * @param event Click event
+     */
+    expandPropertyflexGrow(event: MouseEvent): void;
+    /**
+     * Retrieves an HTML element by its class
+     * @param className CSS class name
+     * @returns HTML Element
+     */
+    getHtmlElement(className: string): HTMLElement;
+    lastPropertyflexGrow: number;
+    hidePropertyGrid(): void;
+    showPropertyGrid(): void;
+    updateLayout(): void;
+    updateSeparator(): void;
+    private dragInProgress;
+    /**
+     * Starts the resizing process
+     * @param event Mouse event
+     */
+    startResizing(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    stopResizing(event: MouseEvent): void;
+    onBeforeUnload(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutHandlerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LayoutHandlerDirective, "[layoutHandler]", ["layoutHandler"], { "middlePanel": { "alias": "middlePanel"; "required": false; }; "entityKey": { "alias": "entityKey"; "required": false; }; "isSection": { "alias": "isSection"; "required": false; }; "layoutContext": { "alias": "layoutContext"; "required": false; }; }, {}, never, never, false, never>;
+}

package/core-ux/lib/v2/directives/row-ref.directive.d.ts

@@ -0,0 +1,21 @@
+import { AfterViewInit, ElementRef, OnDestroy } from "@angular/core";
+import { RowRegistry } from "../models/utilities/row-registry";
+import * as i0 from "@angular/core";
+/**
+ * Hôte d'une directive rowRef, fourni par DataGridComponent.
+ * La directive injecte ce jeton plutôt que DataGridComponent pour éviter un cycle d'imports
+ * entre les deux fichiers, non supporté en compilation partielle (librairie).
+ */
+export declare abstract class RowRefHost {
+    abstract readonly rowRegistry: RowRegistry;
+}
+export declare class RowRefDirective implements AfterViewInit, OnDestroy {
+    private el;
+    private dataGrid;
+    rowId: string;
+    constructor(el: ElementRef, dataGrid: RowRefHost);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowRefDirective, [null, { host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RowRefDirective, "[rowRef]", never, { "rowId": { "alias": "rowRef"; "required": false; }; }, {}, never, never, true, never>;
+}

package/core-ux/lib/v2/models/aggregation-model.d.ts

@@ -0,0 +1,8 @@
+import { AggregateFunction } from "@dflat-core/web/core-model";
+export interface AggregateRequest {
+    Aggregates?: AggregateDefinition[];
+}
+export interface AggregateDefinition {
+    Field?: string;
+    Function?: AggregateFunction;
+}

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

@@ -0,0 +1,66 @@
+import { EntityViewModel } from '@dflat-core/web/core-model';
+import { Action } from '../../../model/model';
+import { ActionDefinition } from '../utilities/action-definition';
+import { ActionHandlerContext } from './action-handler-context';
+import { ChangeDetectionContext } from './change-detection-context';
+import { EditorContext } from './editor-context';
+import { EntityConfigContext } from './entity-config-context';
+import { FacadeDeps } from '../../services/entity-facade-registry.service';
+import { FilterContext } from './filter-context';
+import { SectionContext } from './section-context';
+import { SelectionContext } from './selection-context';
+import { Observable } from 'rxjs';
+export interface ActionResult<TData> {
+    actionName?: string;
+    success: boolean;
+    affectedEntities?: TData[];
+    sectionName?: string;
+}
+export interface ActionExecutionContext {
+    sectionName?: string;
+    entityKey?: string;
+    source?: 'parent' | 'child';
+    isDefault?: boolean;
+    getParam?: () => any;
+}
+export declare class ActionContext<TData extends EntityViewModel> {
+    deps: FacadeDeps;
+    entityKey: string;
+    selection: SelectionContext<TData>;
+    change: ChangeDetectionContext<TData>;
+    filter: FilterContext<TData, any>;
+    section: SectionContext<TData>;
+    editor: EditorContext;
+    config: EntityConfigContext<TData, any>;
+    private readonly actionsMap;
+    private readonly actionsSubject;
+    readonly actions$: Observable<Action[]>;
+    readonly handler: ActionHandlerContext<TData>;
+    constructor(deps: FacadeDeps, entityKey: string, selection: SelectionContext<TData>, change: ChangeDetectionContext<TData>, filter: FilterContext<TData, any>, section: SectionContext<TData>, editor: EditorContext, config: EntityConfigContext<TData, any>);
+    private registerActions;
+    private bindActions;
+    private createAction;
+    emit(): void;
+    getAction(key: string): Action;
+    addAction(def: Action): void;
+    addActions(actionsToAdd: Action[]): void;
+    patch(name: string, patch: Partial<ActionDefinition>): void;
+    setHandlerPath(path: string): void;
+    hideAction(actionName: string): void;
+    hideActions(actionsName?: string[]): void;
+    clearActions(): void;
+    private static readonly READ_ONLY_HIDDEN_ACTIONS;
+    private readOnlyHiddenState;
+    setReadOnlyMode(v: boolean): void;
+    hasAction(key: string): boolean;
+    hasActions(): boolean;
+    executeAction(actionName: string, executeDefaultAction?: boolean, param?: any): Observable<ActionResult<TData>>;
+    showAction(actionName: string): void;
+    emitActionResult(result: ActionResult<TData>): void;
+    private readonly actionResultSubject;
+    readonly actionResult$: Observable<ActionResult<TData>>;
+    private executionContext?;
+    setExecutionContext(ctx: ActionExecutionContext): void;
+    private permissionKey?;
+    setPermissionKey(key: string): void;
+}

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

@@ -0,0 +1,49 @@
+import { EntityViewModel, SaveResults } from "@dflat-core/web/core-model";
+import { ActionResult } from "./action-context";
+import { ChangeDetectionContext } from "./change-detection-context";
+import { EditorContext } from "./editor-context";
+import { FacadeDeps } from "../../services/entity-facade-registry.service";
+import { FilterContext } from "./filter-context";
+import { SectionContext } from "./section-context";
+import { SelectionContext } from "./selection-context";
+import { Observable } from "rxjs";
+export declare class ActionHandlerContext<TData extends EntityViewModel> {
+    deps: FacadeDeps;
+    entityKey: string;
+    permissionKey: string;
+    selection: SelectionContext<TData>;
+    change: ChangeDetectionContext<TData>;
+    filter: FilterContext<TData, any>;
+    section: SectionContext<TData>;
+    editor: EditorContext;
+    private destroy$;
+    readonly state$: Observable<{
+        sel: TData[];
+        dirty: boolean;
+        valid: boolean;
+    }>;
+    constructor(deps: FacadeDeps, entityKey: string, permissionKey: string, selection: SelectionContext<TData>, change: ChangeDetectionContext<TData>, filter: FilterContext<TData, any>, section: SectionContext<TData>, editor: EditorContext);
+    path: string;
+    oldAdd(): void;
+    add(initValue: Partial<TData>): void;
+    canShowHistory(): boolean;
+    showHistory(): Observable<any>;
+    canSave(): boolean;
+    canAdd(): boolean;
+    canDelete(): boolean;
+    getActionPermissionKey(action: string): string;
+    export(): void;
+    exportXLSX(): void;
+    exportCSV(): void;
+    onSaveCompleted(): void;
+    edit(): void;
+    delete(deleteMessage?: string): Observable<ActionResult<TData>>;
+    removeFromResults<TData extends EntityViewModel>(d: TData): void;
+    performLoadData(): void;
+    handleDeleteFail(res: SaveResults<TData>): void;
+    save(): Observable<ActionResult<TData>>;
+    afterDelete(): void;
+    refresh(): void;
+    innerDelete(): Observable<ActionResult<TData>>;
+    reset(): void;
+}

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

@@ -0,0 +1,42 @@
+import { FieldDescriptor } from '@dflat-core/web/core-model';
+import { AbstractControl, FormBuilder, FormGroup } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { ValidationService } from '../../services/validation.service';
+export declare abstract class BaseFormContext<TDescriptor extends FieldDescriptor> {
+    private fb;
+    private validationService;
+    form: FormGroup;
+    entity: any;
+    fields: TDescriptor[];
+    constructor(fb: FormBuilder, validationService: ValidationService);
+    /** Initialize form from descriptors */
+    private initPropertyForm;
+    /** Called manually for initial load */
+    triggerField(desc: TDescriptor): void;
+    private setupCascade;
+    private setupConditional;
+    /** Single observable for all changes with debounce */
+    changes$(): Observable<any>;
+    /** Optional: trackBy helper for template loops */
+    trackByField: (_: number, d: TDescriptor) => string;
+    /** Patch form with an object */
+    patch(values: any): void;
+    /** Convert current form to plain object */
+    serialize(): any;
+    protected abstract applyCascadeRules(descriptors: TDescriptor[]): void;
+    protected abstract applyConditionalRules(descriptors: TDescriptor[]): void;
+    /** --------------------------
+     * CASCADE LOGIC
+     * -------------------------- */
+    protected handleCascade(field: TDescriptor): void;
+    /** --------------------------
+     * CONDITIONAL LOGIC
+     * conditional logic
+     * -------------------------- */
+    protected handleConditional(field: TDescriptor): void;
+    /** --------------------------
+     * RESET FIELD DATA LOGIC
+     * -------------------------- */
+    private resetFieldData;
+    protected updateControlValidators(ctrl: AbstractControl, validators: any[]): void;
+}

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

@@ -0,0 +1,41 @@
+import { EntityViewModel, PropertyEditorEvent } from '@dflat-core/web/core-model';
+import { FormGroup } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { SelectionContext } from './selection-context';
+export interface PropertyChangeInterceptor<TData extends EntityViewModel> {
+    beforeApply?(entity: TData, event: PropertyEditorEvent): TData;
+    afterApply?(entity: TData, event: PropertyEditorEvent): TData;
+}
+export declare class ChangeDetectionContext<TData extends EntityViewModel> {
+    private selection;
+    private modifiedEntities;
+    private propertyChangedSubject;
+    private buttonClickedSubject;
+    private styleUpdateSubject;
+    private pendingChange$;
+    readonly buttonClicked$: Observable<PropertyEditorEvent>;
+    private interceptor;
+    constructor(selection: SelectionContext<TData>);
+    setInterceptor(_interceptor: PropertyChangeInterceptor<TData>): void;
+    getPropertyChanged$(): Observable<PropertyEditorEvent>;
+    getStyleUpdated$(): Observable<TData[]>;
+    private compareToOriginal;
+    updateSelected(event: PropertyEditorEvent): void;
+    updateEntity(entity: TData, evt: PropertyEditorEvent): void;
+    emitUpdated(entities: TData[]): void;
+    private updateDataset;
+    private updateModified;
+    applyChangedValue(item: TData, evt: PropertyEditorEvent): void;
+    private serializeExtendedValue;
+    markPendingChange(evt: PropertyEditorEvent): void;
+    emitButtonClicked(evt: PropertyEditorEvent): void;
+    private correspondingForm;
+    setForm(form: FormGroup): void;
+    get isDirty(): boolean;
+    get isInvalid(): boolean;
+    get valid(): boolean;
+    reset(): void;
+    get Modified(): TData[];
+    getModified(id: number): TData;
+    hasPendingChanges(): boolean;
+}

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

@@ -0,0 +1,25 @@
+import { EntityViewModel, FilterViewModel, PagedList } from '@dflat-core/web/core-model';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { FacadeLoadGuard } from '../guards/facade-load-guard';
+import { FilterContext } from './filter-context';
+import { LoggerContext } from './logger-context';
+export declare class DataContext<TData extends EntityViewModel> {
+    private readonly filterContext;
+    private logger;
+    private interceptor;
+    private loadDataFn?;
+    data$: Observable<PagedList<TData>>;
+    readonly originalDataChange$: BehaviorSubject<TData>;
+    private originals;
+    constructor(filterContext: FilterContext<TData, any>, logger: LoggerContext, interceptor: FacadeLoadGuard);
+    loadData(filter: FilterViewModel): Observable<PagedList<TData>>;
+    setCriteriaSource(criteria$: Observable<FilterViewModel>): void;
+    getOriginal(id: number): TData;
+    setOriginal(newData: TData): void;
+    private readonly mutationsSubject;
+    readonly mutations$: Observable<TData>;
+    insertAtStart(entity: TData): void;
+    hasData(): boolean;
+    setloadDataFn(fn: (criteria: FilterViewModel) => Observable<PagedList<TData>>): void;
+    private resetResultsFlags;
+}

package/core-ux/lib/v2/models/contexts/data-grid-style-context.d.ts

@@ -0,0 +1,36 @@
+import { ColumnDescriptor, EntityViewModel } from "@dflat-core/web/core-model";
+export interface IDataGridStyleContext {
+    getAlternatingStyle?: (index: number, maxIndex: number, hasAggregates: boolean, row: EntityViewModel) => string;
+    getHeaderStyle?: (column: ColumnDescriptor) => string;
+    getColumnStyle?: (row: EntityViewModel, column: ColumnDescriptor) => string;
+    getRowStateStyle?: (row: EntityViewModel) => string;
+    getCellStyle?: (row: EntityViewModel, column: ColumnDescriptor, index: number, maxIndex: number, hasAggregates: boolean) => string;
+    canEditCell?: (row: EntityViewModel, column: ColumnDescriptor) => boolean;
+    showOnToolTip?: (row: EntityViewModel, column: ColumnDescriptor) => any;
+    enableLastColumnResize?: boolean;
+    displayDetail?: boolean;
+}
+export declare class DataGridStyleContext implements IDataGridStyleContext {
+    private readonly defaults;
+    private readonly patchContext;
+    constructor(defaults: IDataGridStyleContext);
+    patch(partial: Partial<IDataGridStyleContext>): void;
+    getAlternatingStyle(index: number, maxIndex: number, hasAggregates: boolean, row: EntityViewModel): string;
+    getHeaderStyle(column: ColumnDescriptor): string;
+    getColumnStyle(row: EntityViewModel, column: ColumnDescriptor): string;
+    getRowStateStyle(row: EntityViewModel): string;
+    getCellStyle(row: EntityViewModel, column: ColumnDescriptor, index: number, maxIndex: number, hasAggregates: boolean): string;
+    canEditCell(row: EntityViewModel, column: ColumnDescriptor): boolean;
+    showOnToolTip?(row: EntityViewModel, column: ColumnDescriptor): any;
+    get enableLastColumnResize(): boolean;
+    get displayDetail(): boolean;
+}
+export declare class DefaultDataGridStyleContext implements IDataGridStyleContext {
+    getAlternatingStyle(index: any, maxIndex: any, hasAggregates: any): string;
+    getHeaderStyle(column: ColumnDescriptor): string;
+    getColumnStyle(row: EntityViewModel, column: ColumnDescriptor): string;
+    getRowStateStyle(row: any): "mw-invalid" | "mw-modified" | "mw-warning" | "row-state";
+    getCellStyle(row: any, column: any, index: any, maxIndex: any, hasAggregates: any): string;
+    enableLastColumnResize: true;
+    displayDetail: false;
+}

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

@@ -0,0 +1,30 @@
+import { EntityViewModel, EntityViewModelWithFields, FieldDescriptor } from '@dflat-core/web/core-model';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ChangeDetectionContext } from './change-detection-context';
+import { DataGridStyleContext } from './data-grid-style-context';
+export declare class EditorContext {
+    private change?;
+    private ViewModel;
+    setViewModel(vm: EntityViewModelWithFields<EntityViewModel>): void;
+    readonly isValid$: BehaviorSubject<boolean>;
+    readonly isStandaloneMode$: BehaviorSubject<boolean>;
+    private readonly isDirtySubject;
+    readonly isDirty$: Observable<boolean>;
+    readonly readOnlyMode$: BehaviorSubject<boolean>;
+    private destroy$;
+    constructor(change?: ChangeDetectionContext<any>);
+    private bindChangeContext;
+    setStandaloneMode(value: boolean): void;
+    setReadOnlyMode(value: boolean): void;
+    get isReadOnlyMode(): boolean;
+    setIsDirty(value: boolean): void;
+    setIsValid(value: boolean): void;
+    reset(): void;
+    get Fields(): FieldDescriptor[];
+    getEditableContext(): Partial<DataGridStyleContext>;
+    enableEdit(prop: string, row: EntityViewModel): boolean;
+    isRowEditable(row: EntityViewModel): boolean;
+    isPropertyEditable(prop: string): boolean;
+    getField(prop?: string): FieldDescriptor;
+    destroy(): void;
+}

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

@@ -0,0 +1,49 @@
+import { DataService } from "@dflat-core/web/core-data";
+import { ColumnDescriptor, EntityViewModel, EntityViewModelWithFields, ExtendedProperty, FieldDescriptor, FilterDescriptor, FilterViewModel, Section } from "@dflat-core/web/core-model";
+import { BehaviorSubject, Observable } from "rxjs";
+export declare class EntityConfigContext<TData extends EntityViewModel, TFilter extends FilterViewModel> {
+    private dataService;
+    private entityKey;
+    private readonly columnSource$;
+    setColumnSource(factory: () => Observable<ColumnDescriptor[]>): void;
+    private readonly alteredColumns$;
+    readonly columns$: Observable<ColumnDescriptor[]>;
+    private readonly viewModelSource$;
+    setviewModelSource(factory: () => Observable<EntityViewModelWithFields<TData>>): void;
+    private readonly alteredViewModel$;
+    readonly viewModel$: Observable<any>;
+    updateFieldSections(newSections: Section[]): void;
+    readonly alteredDefaultFilter$: BehaviorSubject<((filter: TFilter) => TFilter)[]>;
+    readonly defaultFilter$: Observable<TFilter>;
+    readonly alteredFilterDescriptors$: BehaviorSubject<((fds: FilterDescriptor[]) => FilterDescriptor[])[]>;
+    readonly filterDescriptors$: Observable<FieldDescriptor[]>;
+    readonly actions$: Observable<import("@dflat-core/web/core-model").ActionDescriptor[]>;
+    readonly config$: Observable<{
+        columns: ColumnDescriptor[];
+        viewModel: any;
+        emptyFilter: TFilter;
+        filterDescriptors: FieldDescriptor[];
+        actions: import("@dflat-core/web/core-model").ActionDescriptor[];
+    }>;
+    /** Enable cell auto-focus on edit (accounting-data keyboard navigation). Set from the component TS. */
+    cellFocus: boolean;
+    constructor(dataService: DataService, entityKey: string);
+    getApiViewModel(id: number): Observable<EntityViewModelWithFields<TData>>;
+    getExtendedProperties(ids: number[]): Observable<ExtendedProperty[]>;
+    addAlterViewModelFunction(alterFunction: ((vm: EntityViewModelWithFields<TData>) => EntityViewModelWithFields<TData>)): void;
+    addAlterColumnsFunction(alterFunction: ((cols: ColumnDescriptor[]) => ColumnDescriptor[])): void;
+    /**
+     * Replaces the active column set with the given descriptors.
+     * This is the primary entry point for Presentation Profile integration:
+     * pass the result of PresentationProfileTransformer.buildDescriptors() here.
+     */
+    replaceColumns(descriptors: ColumnDescriptor[]): void;
+    /** Appends columns not already present (matched by Property). */
+    addColumns(descriptors: ColumnDescriptor[]): void;
+    /** Removes columns by Property name. */
+    removeColumns(propertyNames: string[]): void;
+    /** Patches a single column matched by Property name. */
+    updateColumn(propertyName: string, updates: Partial<ColumnDescriptor>): void;
+    addAlterDefaultFilterFunction<F extends TFilter>(alterFunction: ((filter: TFilter) => TFilter)): void;
+    addAlterFilterDescriptorsFunction(alterFunction: ((cols: FilterDescriptor[]) => FilterDescriptor[])): void;
+}

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

@@ -0,0 +1,49 @@
+import { EntityViewModel, FilterQuery, FilterViewModel } from '@dflat-core/web/core-model';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { FacadeLoadGuard } from '../guards/facade-load-guard';
+import { EntityConfigContext } from './entity-config-context';
+export declare class FilterContext<TData extends EntityViewModel, TFilter extends FilterViewModel> {
+    private config;
+    private interceptor;
+    forceRefresh: boolean;
+    defaultFilter: TFilter;
+    filterSnapshot?: TFilter;
+    defaultAdditionalQuery: FilterQuery;
+    readonly filter$: BehaviorSubject<TFilter>;
+    readonly additionalQuery$: BehaviorSubject<FilterQuery>;
+    readonly pageNumber$: BehaviorSubject<number>;
+    readonly rowsPerPage$: BehaviorSubject<number>;
+    readonly totalItems$: BehaviorSubject<number>;
+    readonly totalPages$: BehaviorSubject<number>;
+    readonly lastExecutionTime$: BehaviorSubject<string>;
+    readonly baseCriteria$: Observable<TFilter>;
+    readonly keyword$: BehaviorSubject<string>;
+    private columns;
+    constructor(config: EntityConfigContext<TData, TFilter>, interceptor: FacadeLoadGuard);
+    setDefaultFilter(df: TFilter): void;
+    private readonly openFilterRequest$;
+    readonly openFilter$: Observable<void>;
+    requestOpenFilter(): void;
+    private readonly filterReady$;
+    openFilterResolved$: Observable<void>;
+    markReady(): void;
+    _filterReady$(): Observable<void>;
+    private applyFilterUrl$;
+    readonly applyFilterUrlEnabled$: Observable<boolean>;
+    setApplyFilterUrl(enabled: boolean): void;
+    private refresh$;
+    triggerSearch(): void;
+    setFilter(filter: Partial<TFilter>, pageNumber?: number): void;
+    setKeyword(keyword: string): void;
+    isSorting(property?: string): boolean;
+    isAsc(property?: string): boolean;
+    isDesc(property?: string): boolean;
+    setSorting(property: keyof TData, dir?: 'asc' | 'desc'): void;
+    setPage(page: number): void;
+    setPageSize(ps: number): void;
+    updateStates(totalCount: number, execMs: number, take: number): void;
+    addNewQuery(): void;
+    removeQueryAtIndex(index: number): void;
+    applyAdditionalQuery(): void;
+    setAggregateClause(aggregationRequest: any): void;
+}