@acorex/platform 20.3.0-next.1 → 20.3.0-next.10

package/layout/components/index.d.ts

@@ -1,16 +1,24 @@
 import * as _angular_core from '@angular/core';
-import { Signal, InjectionToken, InputSignal, TemplateRef, ElementRef, OnInit, OnDestroy, Type, ViewContainerRef, ModuleWithProviders, QueryList } from '@angular/core';
+import { Signal, InjectionToken, InputSignal, TemplateRef, ElementRef, OnInit, OnDestroy, Type, ViewContainerRef, ModuleWithProviders, WritableSignal, QueryList, EventEmitter } from '@angular/core';
 import * as _acorex_platform_core from '@acorex/platform/core';
-import { AXPActivityLog, AXPSystemActionType, AXPContextData, AXPFilterDefinition, AXPFilterQuery } from '@acorex/platform/core';
+import { AXPActivityLog, AXPSystemActionType, AXPCategoryEntity, AXPColumnQuery, AXPContextData, AXPOptionsData, AXPActionMenuItem, AXPExecuteCommand, AXPValidationRules, AXPFilterDefinition, AXPFilterQuery, AXPSortDefinition, AXPSortQuery, AXPMetaData, AXPViewQuery } from '@acorex/platform/core';
 import { AXPMenuItem } from '@acorex/platform/common';
-import { AXPWidgetNode, AXPLayoutContextChangeEvent } from '@acorex/platform/layout/builder';
+import * as _acorex_cdk_common from '@acorex/cdk/common';
+import { AXValueChangedEvent, AXClickEvent, AXDataSource, AXDataSourceFilterOption, AXOrientation, AXHtmlEvent, AXEvent } from '@acorex/cdk/common';
+import { AXTreeViewComponent, AXTreeItemClickBaseEvent } from '@acorex/components/tree-view';
+import { AXTranslationService } from '@acorex/core/translation';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { AXPWidgetNode, AXPLayoutContextChangeEvent, AXPWidgetProperty, AXPWidgetConfig } from '@acorex/platform/layout/builder';
 import * as _ngrx_signals from '@ngrx/signals';
+import { AXDataTableComponent, AXDataTableRowDbClick, AXDataTableRowClick } from '@acorex/components/data-table';
+import { AXBasePageComponent } from '@acorex/components/page';
+import { AXPopupSizeType, AXPopupService } from '@acorex/components/popup';
+import * as _acorex_platform_layout_components from '@acorex/platform/layout/components';
 import { AXFormComponent } from '@acorex/components/form';
-import { AXHtmlEvent, AXValueChangedEvent, AXEvent } from '@acorex/cdk/common';
 import { AXPopoverComponent } from '@acorex/components/popover';
 import { AXTagBoxComponent } from '@acorex/components/tag-box';
 import { AXCalendarService } from '@acorex/core/date-time';
-import { AXTranslationService } from '@acorex/core/translation';
+import { AXTabStripChangedEvent, AXTabsComponent } from '@acorex/components/tabs';
 import { Observable } from 'rxjs';
 
 declare class AXPActivityLogComponent {
@@ -199,6 +207,93 @@ declare class AXPThemeLayoutContainerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutContainerComponent, "axp-layout-container", never, {}, {}, never, ["*"], true, never>;
 }
 
+interface AXPCategoryTreeNode extends AXPCategoryEntity {
+    children?: AXPCategoryTreeNode[];
+    expand?: boolean;
+    hasChild?: boolean;
+    [key: string]: any;
+}
+interface AXPCategoryTreeConfig {
+    textField?: string;
+    valueField?: string;
+    expandedField?: string;
+    showCheckbox?: boolean;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    emptyStateTitle?: string;
+    emptyStateDescription?: string;
+    emptyStateIcon?: string;
+}
+interface AXPCategoryTreeEvents {
+    onNodeClick?: (node: AXPCategoryEntity) => void;
+    onNodeSelect?: (node: AXPCategoryEntity) => void;
+    onNodeCreate?: (parentNode?: AXPCategoryEntity) => void;
+    onNodeUpdate?: (node: AXPCategoryEntity) => void;
+    onNodeDelete?: (node: AXPCategoryEntity) => void;
+    onSearchChange?: (searchValue: string) => void;
+    onCollapseChange?: (node: AXPCategoryEntity) => void;
+}
+interface AXPCategoryTreeActions {
+    canCreate?: boolean;
+    canUpdate?: boolean;
+    canDelete?: boolean;
+    canCreateChild?: boolean;
+    createLabel?: string;
+    updateLabel?: string;
+    deleteLabel?: string;
+    createChildLabel?: string;
+}
+interface AXPCategoryTreeDataSource {
+    loadRootNodes: () => Promise<AXPCategoryEntity[]>;
+    loadChildNodes?: (parentId: string) => Promise<AXPCategoryEntity[]>;
+    searchNodes?: (searchValue: string) => Promise<AXPCategoryEntity[]>;
+}
+
+declare class AXPCategoryTreeComponent {
+    protected readonly translationService: AXTranslationService;
+    dataSource: _angular_core.InputSignal<AXPCategoryTreeDataSource>;
+    config: _angular_core.InputSignal<AXPCategoryTreeConfig>;
+    actions: _angular_core.InputSignal<AXPCategoryTreeActions>;
+    events: _angular_core.InputSignal<AXPCategoryTreeEvents>;
+    nodeClick: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
+    nodeSelect: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
+    nodeCreate: _angular_core.OutputEmitterRef<AXPCategoryEntity<string> | undefined>;
+    nodeUpdate: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
+    nodeDelete: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
+    searchChange: _angular_core.OutputEmitterRef<string>;
+    collapseChange: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
+    tree: _angular_core.Signal<AXTreeViewComponent | undefined>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    searchValue: _angular_core.WritableSignal<string>;
+    protected treeItems: _angular_core.WritableSignal<AXPCategoryTreeNode[]>;
+    protected emptyStateTitle: _angular_core.Signal<string>;
+    protected emptyStateDescription: _angular_core.Signal<string>;
+    ngOnInit(): Promise<void>;
+    loadRootNodes(): Promise<void>;
+    loadChildNodes(parentId: string): Promise<void>;
+    searchNodes(searchValue: string): Promise<void>;
+    handleNodeClick(event: AXTreeItemClickBaseEvent): Promise<void>;
+    handleCollapseChanged(event: AXTreeItemClickBaseEvent): Promise<void>;
+    handleSearchChange(event: AXValueChangedEvent): Promise<void>;
+    handleCreateRootClick(event: AXClickEvent): Promise<void>;
+    handleCreateChildClick(node: AXPCategoryTreeNode, event: AXClickEvent): Promise<void>;
+    handleUpdateNodeClick(node: AXPCategoryTreeNode, event: AXClickEvent): Promise<void>;
+    handleDeleteNodeClick(node: AXPCategoryTreeNode, event: AXClickEvent): Promise<void>;
+    private convertEntitiesToTreeNodes;
+    private updateNodeChildren;
+    refreshTree(parentId?: string): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPCategoryTreeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPCategoryTreeComponent, "axp-category-tree", never, { "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; }, { "nodeClick": "nodeClick"; "nodeSelect": "nodeSelect"; "nodeCreate": "nodeCreate"; "nodeUpdate": "nodeUpdate"; "nodeDelete": "nodeDelete"; "searchChange": "searchChange"; "collapseChange": "collapseChange"; }, never, never, true, never>;
+}
+
+declare class AXPQueryColumnsComponent {
+    columns: _angular_core.ModelSignal<AXPColumnQuery[]>;
+    handleVisibilityChange(e: AXValueChangedEvent<boolean>, name: string): void;
+    protected drop(event: CdkDragDrop<unknown[]>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryColumnsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryColumnsComponent, "axp-query-columns", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, { "columns": "columnsChange"; }, never, never, true, never>;
+}
+
 interface AXPCompareViewField {
     path: string;
     title: string;
@@ -267,11 +362,7 @@ interface AXPComponentSlotConfig {
     component?: Type<any>;
     condition?: ((context?: AXPContextData) => (boolean | Promise<boolean>)) | string;
     loadComponent?: () => Type<any> | Promise<Type<any>>;
-    options?: {
-        [key: string]: unknown;
-    } | (() => {
-        [key: string]: unknown;
-    });
+    options?: AXPOptionsData | (() => AXPOptionsData) | (() => Promise<AXPOptionsData>);
 }
 interface AXPComponentSlotModuleConfigs {
     [slotName: string]: AXPComponentSlotConfig[];
@@ -294,8 +385,8 @@ declare class AXPComponentSlotDirective implements OnInit {
     contextStore: {
         data: _angular_core.Signal<AXPContextData>;
         state: _angular_core.Signal<_acorex_platform_core.AXPContextState>;
-        initialSnapshot: _ngrx_signals.DeepSignal<{}>;
-        previousSnapshot: _ngrx_signals.DeepSignal<{}>;
+        initialSnapshot: _angular_core.Signal<{}>;
+        previousSnapshot: _angular_core.Signal<{}>;
         lastChange: _ngrx_signals.DeepSignal<_acorex_platform_core.AXPContextChangeEvent>;
         isChanged: _angular_core.Signal<boolean>;
         isReset: _angular_core.Signal<boolean>;
@@ -349,21 +440,155 @@ declare class AXPComponentSlotModule {
     static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXPComponentSlotModule>;
 }
 
-type AXPDynamicFormLayoutStyle = 'normal' | 'compact' | 'vertical' | 'horizontal';
+interface AXPDataSelectorColumn {
+    name: string;
+    title: string;
+    visible: boolean;
+    widget: {
+        type: string;
+        options: any;
+    };
+}
+interface AXPDataSelectorConfig {
+    title: string;
+    dataSource: AXDataSource<any>;
+    columns: AXPDataSelectorColumn[];
+    selectionMode: 'single' | 'multiple';
+    searchFields?: string[];
+    parentField?: string;
+    allowCreate?: boolean;
+    categoryFilter?: {
+        enabled: boolean;
+        title: string;
+        dataSource: AXPCategoryTreeDataSource;
+        filterField: string;
+        filterOperator?: 'equal' | 'contains' | 'in';
+        width?: string;
+    };
+}
+declare class AXPDataSelectorComponent extends AXBasePageComponent {
+    protected config: _angular_core.WritableSignal<AXPDataSelectorConfig>;
+    protected searchTerm: string;
+    protected filter: AXDataSourceFilterOption;
+    protected grid: _angular_core.Signal<AXDataTableComponent | undefined>;
+    protected initialSelectedItems: any[];
+    protected selectedItems: _angular_core.WritableSignal<any[]>;
+    protected activeCategoryFilter: _angular_core.WritableSignal<{
+        node: AXPCategoryEntity;
+        filterValue: any;
+    } | null>;
+    protected allowSelect: _angular_core.Signal<boolean>;
+    protected hasSearch: _angular_core.Signal<boolean | undefined>;
+    protected searchPlaceholder: _angular_core.Signal<string>;
+    protected categoryTreeConfig: _angular_core.Signal<{
+        textField: string;
+        valueField: string;
+        showCheckbox: boolean;
+        searchable: boolean;
+        searchPlaceholder: string;
+        emptyStateTitle: string;
+        emptyStateDescription: string;
+        emptyStateIcon: string;
+    }>;
+    protected categoryTreeActions: _angular_core.Signal<{
+        canCreate: boolean;
+        canUpdate: boolean;
+        canDelete: boolean;
+        canCreateChild: boolean;
+    }>;
+    protected ngOnInit(): void;
+    protected ngAfterViewInit(): void;
+    protected handleRowDbClick(e: AXDataTableRowDbClick): void;
+    protected handleRowClick(e: AXDataTableRowClick): void;
+    protected handleSelectedRowsChange(rows: unknown[]): Promise<void>;
+    protected handleChangeSearchValue(e: AXValueChangedEvent): void;
+    protected handleCreateNewClick(): Promise<void>;
+    protected handleCloseClick(): void;
+    protected handleSelectClick(): void;
+    protected handleExpandRow(row: any): Promise<void>;
+    protected handleCategoryFilterClick(node: AXPCategoryEntity): void;
+    protected clearCategoryFilter(): void;
+    private applySearchFilter;
+    private applyFilterAndSort;
+    private applyCategoryFilter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDataSelectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDataSelectorComponent, "axp-data-selector", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPDataSelectorService {
+    private readonly popupService;
+    /**
+     * Open data selector popup
+     */
+    open(config: AXPDataSelectorConfig): Promise<{
+        items: any[];
+    } | null>;
+    /**
+     * Open data selector with category filter
+     */
+    openWithCategoryFilter(config: Omit<AXPDataSelectorConfig, 'categoryFilter'>, categoryFilterConfig: {
+        title: string;
+        dataSource: AXPCategoryTreeDataSource;
+        filterField: string;
+        filterOperator?: 'equal' | 'contains' | 'in';
+        width?: string;
+    }): Promise<{
+        items: any[];
+    } | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDataSelectorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPDataSelectorService>;
+}
+
+/**
+ * Form appearance and density styling
+ */
+type AXPDynamicFormLook = 'normal' | 'compact' | 'borderless';
+/**
+ * Form rendering mode
+ */
+type AXPDynamicFormMode = 'view' | 'edit';
+/**
+ * Form layout direction and flow
+ */
+type AXPDynamicFormDirection = 'vertical' | 'horizontal' | 'grid';
 interface AXPDynamicFormFieldDefinition {
     path: string;
     title?: string;
     description?: string;
     widget: AXPWidgetNode;
+    /**
+     * Optional per-field rendering mode. Takes precedence over section and form modes.
+     */
+    mode?: AXPDynamicFormMode;
+    /**
+     * Optional per-parameter layout override. Takes precedence over form layoutConfig.
+     * - number: colSpan for all breakpoints
+     * - object: colSpan per breakpoint
+     */
+    layout?: number | {
+        default?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+        xxl?: number;
+    };
 }
 interface AXPDynamicFormGroupDefinition {
     name: string;
     title?: string;
     description?: string;
     parameters: AXPDynamicFormFieldDefinition[];
+    /**
+     * Optional per-section rendering mode. Takes precedence over form mode and is overridden by field mode.
+     */
+    mode?: AXPDynamicFormMode;
 }
 interface AXPDynamicFormDefinition {
     groups: AXPDynamicFormGroupDefinition[];
+    /**
+     * Optional form-level rendering mode
+     */
+    mode?: AXPDynamicFormMode;
 }
 interface AXPDynamicFormLayoutConfig {
     positions: {
@@ -385,8 +610,370 @@ interface AXPDynamicFormLayoutConfig {
     };
 }
 
+/**
+ * Describes a single step of the dynamic form stepper.
+ * Each step contains one or more groups rendered by AXPDynamicFormComponent.
+ */
+interface AXPDynamicFormStepperStepDefinition {
+    /** Unique identifier for the step */
+    id: string;
+    /** Display title for the step */
+    title?: string;
+    /** Optional descriptive text for the step */
+    description?: string;
+    /** Optional icon name for the step header */
+    icon?: string;
+    /** Field groups to render in this step */
+    groups: AXPDynamicFormGroupDefinition[];
+    /** Optional layout direction override for this step's form */
+    formDirection?: AXPDynamicFormDirection;
+    /** Whether the user may skip this step (defaults to false) */
+    canSkip?: boolean;
+    /** Whether the user may navigate back from this step (defaults to true) */
+    canGoBack?: boolean;
+    /** Optional data path inside the shared context for this step's data */
+    dataPath?: string;
+}
+/**
+ * Root definition for the dynamic form stepper.
+ */
+interface AXPDynamicFormStepperDefinition {
+    /** Ordered collection of steps */
+    steps: AXPDynamicFormStepperStepDefinition[];
+    /** Enforce sequential navigation (no jumping to future steps) */
+    linear?: boolean;
+    /** Show progress indicator above the content */
+    showProgress?: boolean;
+    /** Show step numbers in the header */
+    showStepNumbers?: boolean;
+}
+
+declare class AXPDynamicFormStepperComponent {
+    #private;
+    /**
+     * Stepper definition providing steps metadata and behavior configuration
+     */
+    definition: _angular_core.InputSignal<AXPDynamicFormStepperDefinition>;
+    /**
+     * Shared root context for all steps
+     */
+    context: _angular_core.InputSignal<any>;
+    /**
+     * Optional pass-through layout props for inner forms
+     */
+    layoutLook: _angular_core.InputSignal<AXPDynamicFormLook>;
+    stepperDirection: _angular_core.InputSignal<AXOrientation>;
+    layoutConfig: _angular_core.InputSignal<AXPDynamicFormLayoutConfig | undefined>;
+    /**
+     * Optional guard that controls advancing to the next step (async only)
+     */
+    guardNext: _angular_core.InputSignal<((e: {
+        index: number;
+        id: string;
+        fullContext: any;
+    }) => Promise<boolean>) | undefined>;
+    /**
+     * Emits when the shared root context changes
+     */
+    contextChange: _angular_core.OutputEmitterRef<any>;
+    /**
+     * Emits when the active step changes
+     */
+    stepChange: _angular_core.OutputEmitterRef<{
+        index: number;
+        id: string;
+    }>;
+    /**
+     * Emits after successful finish
+     */
+    finished: _angular_core.OutputEmitterRef<any>;
+    /**
+     * Emits when cancelled by API
+     */
+    cancel: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emits when navigation is blocked by validation or policy
+     */
+    navigationBlocked: _angular_core.OutputEmitterRef<{
+        reason: "invalid" | "linear" | "cannot-skip" | "cannot-go-back";
+        stepId: string;
+        targetIndex?: number;
+    }>;
+    /**
+     * Internal reactive copy of the shared context
+     */
+    private internalContext;
+    /**
+     * Active step index
+     */
+    protected currentStepIndex: _angular_core.WritableSignal<number>;
+    /**
+     * Navigation lock while async guards are pending
+     */
+    private navigationLocked;
+    /**
+     * Reference to underlying step wizard to sync visual navigation
+     */
+    private readonly wizard;
+    /**
+     * References to rendered dynamic forms (usually one active)
+     */
+    private readonly forms;
+    protected steps: _angular_core.Signal<_acorex_platform_layout_components.AXPDynamicFormStepperStepDefinition[]>;
+    protected stepCount: _angular_core.Signal<number>;
+    protected currentStep: _angular_core.Signal<_acorex_platform_layout_components.AXPDynamicFormStepperStepDefinition>;
+    protected isFirstComputed: _angular_core.Signal<boolean>;
+    protected isLastComputed: _angular_core.Signal<boolean>;
+    /**
+     * Non-undefined layout config for inner dynamic forms
+     */
+    protected effectiveLayoutConfig: _angular_core.Signal<AXPDynamicFormLayoutConfig>;
+    /**
+     * Returns the current step pointer
+     */
+    getCurrentStep(): {
+        index: number;
+        id: string;
+    };
+    /**
+     * Public helpers for templates/consumers
+     */
+    isFirst(): boolean;
+    isLast(): boolean;
+    /**
+     * Returns the root context
+     */
+    getContext(): any;
+    /**
+     * Replaces the root context programmatically
+     */
+    setContext(ctx: any): void;
+    /**
+     * Validates the current step.
+     */
+    validateCurrentStep(): Promise<boolean>;
+    /**
+     * Attempts to advance to the next step applying validation and guard
+     */
+    next(): Promise<void>;
+    /**
+     * Goes back to the previous step if possible
+     */
+    previous(): Promise<void>;
+    /**
+     * Navigates to a specific step by id or index
+     */
+    goTo(stepIdOrIndex: string | number): Promise<void>;
+    /**
+     * Validates all steps and emits finished when successful
+     */
+    finish(): Promise<void>;
+    /**
+     * Emits cancel event without state changes
+     */
+    cancelFlow(): void;
+    /**
+     * Handle per-step context changes and keep internal root context in sync.
+     */
+    protected onStepContextChange(stepId: string, stepContext: any): void;
+    /**
+     * Exposes reading a step slice to the template
+     */
+    readStepSlice(path?: string): {
+        slice: any;
+        exists: boolean;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDynamicFormStepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDynamicFormStepperComponent, "axp-dynamic-form-stepper", never, { "definition": { "alias": "definition"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; "layoutLook": { "alias": "layoutLook"; "required": false; "isSignal": true; }; "stepperDirection": { "alias": "stepperDirection"; "required": false; "isSignal": true; }; "layoutConfig": { "alias": "layoutConfig"; "required": false; "isSignal": true; }; "guardNext": { "alias": "guardNext"; "required": false; "isSignal": true; }; }, { "contextChange": "contextChange"; "stepChange": "stepChange"; "finished": "finished"; "cancel": "cancel"; "navigationBlocked": "navigationBlocked"; }, never, never, true, never>;
+}
+
+interface AXPDynamicDialogConfig {
+    title: string;
+    message?: string;
+    /**
+     * Legacy: If provided, dialog renders only dynamic-form.
+     */
+    formDefinition?: AXPDynamicFormDefinition;
+    /**
+     * Preferred definition: dynamic form (no steps or single step) or a multi-step stepper definition.
+     */
+    definition?: AXPDynamicFormDefinition | AXPDynamicFormStepperDefinition;
+    /**
+     * Shared context passed to the rendered control
+     */
+    context: any;
+    /**
+     * Shared layout options applied to form/stepper unless overridden
+     */
+    layoutConfig?: AXPDynamicFormLayoutConfig;
+    layoutLook?: AXPDynamicFormLook;
+    mode?: AXPDynamicFormMode;
+    size?: AXPopupSizeType;
+    closeButton?: boolean;
+    /**
+     * Optional stepper-only options. Ignored when rendering dynamic-form.
+     */
+    stepper?: {
+        guardNext?: (e: {
+            index: number;
+            id: string;
+            fullContext: unknown;
+        }) => Promise<boolean>;
+        stepperDirection?: AXOrientation;
+    };
+    /**
+     * Footer actions. In stepper mode, footer is replaced by Prev/Next/Confirm.
+     */
+    actions?: {
+        footer?: {
+            prefix?: AXPActionMenuItem[];
+            suffix?: AXPActionMenuItem[];
+        };
+    };
+}
+interface AXPDynamicDialogResult {
+    context: any;
+    action?: string;
+}
+interface AXPDialogRef {
+    /**
+     * Manually close the dialog (optional - dialog closes automatically after user interaction)
+     */
+    close(): void;
+    /**
+     * Get the form data from the dialog
+     */
+    context(): any;
+    /**
+     * Get the action that was clicked by the user
+     */
+    action(): string | undefined;
+    /**
+     * Set the loading state of the dialog
+     */
+    setLoading(loading: boolean): void;
+}
+
+declare class AXPDynamicDialogComponent extends AXBasePageComponent {
+    config: AXPDynamicDialogConfig;
+    private readonly dynamicForm;
+    protected readonly stepper: _angular_core.Signal<AXPDynamicFormStepperComponent | undefined>;
+    isSubmitting: _angular_core.WritableSignal<boolean>;
+    private previousContext;
+    private formData;
+    dialogResult: AXPDynamicDialogResult | null;
+    isSubmittingFromDialog: boolean;
+    data: any;
+    callBack: (dialogRef: AXPDialogRef) => void;
+    /**
+     * Form context for widget container
+     */
+    protected formContext: _angular_core.Signal<Record<string, any>>;
+    /**
+     * Combined loading state from both signal and dialog
+     */
+    protected isFormLoading: _angular_core.Signal<boolean>;
+    protected defaultLayout: () => {
+        positions: {
+            default: {
+                colSpan: number;
+            };
+            md: {
+                colSpan: number;
+            };
+            lg: {
+                colSpan: number;
+            };
+            xl: {
+                colSpan: number;
+            };
+            xxl: {
+                colSpan: number;
+            };
+        };
+    };
+    /**
+     * Determine rendering mode and effective definitions
+     */
+    protected readonly hasLegacyForm: _angular_core.Signal<boolean>;
+    protected readonly providedDefinition: _angular_core.Signal<_acorex_platform_layout_components.AXPDynamicFormDefinition | _acorex_platform_layout_components.AXPDynamicFormStepperDefinition | undefined>;
+    protected readonly providedMode: _angular_core.Signal<_acorex_platform_layout_components.AXPDynamicFormMode>;
+    protected readonly isStepperDefinition: _angular_core.Signal<boolean>;
+    protected readonly shouldRenderForm: _angular_core.Signal<boolean>;
+    protected readonly effectiveFormDefinition: _angular_core.Signal<any>;
+    protected readonly resolvedFormDefinition: _angular_core.Signal<any>;
+    protected readonly effectiveLayoutLook: _angular_core.Signal<_acorex_platform_layout_components.AXPDynamicFormLook>;
+    protected readonly effectiveLayoutConfig: _angular_core.Signal<_acorex_platform_layout_components.AXPDynamicFormLayoutConfig>;
+    protected readonly stepperGuardNext: _angular_core.Signal<((e: {
+        index: number;
+        id: string;
+        fullContext: unknown;
+    }) => Promise<boolean>) | undefined>;
+    protected readonly stepperDirection: _angular_core.Signal<_acorex_cdk_common.AXOrientation>;
+    protected readonly stepperDefinition: _angular_core.Signal<any>;
+    stepperIsFirst: _angular_core.Signal<boolean>;
+    stepperIsLast: _angular_core.Signal<boolean>;
+    /**
+     * Effective form direction when rendering dynamic-form (single-step or legacy form).
+     * If a single-step definition is provided and that step specifies formDirection, use it.
+     */
+    protected readonly effectiveFormDirection: _angular_core.Signal<AXPDynamicFormDirection>;
+    /**
+     * Footer actions for dynamic button system
+     */
+    protected footerPrefixActions: _angular_core.Signal<AXPActionMenuItem[]>;
+    protected footerSuffixActions: _angular_core.Signal<AXPActionMenuItem[]>;
+    protected visibleFooterPrefixActions: _angular_core.Signal<AXPActionMenuItem[]>;
+    protected visibleFooterSuffixActions: _angular_core.Signal<AXPActionMenuItem[]>;
+    protected hasFooterActions: _angular_core.Signal<boolean>;
+    /** Stepper footer: choose a single confirm action from provided suffix actions (first visible). */
+    protected confirmAction: _angular_core.Signal<AXPActionMenuItem | undefined>;
+    protected confirmActionTitle: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    protected handleContextInitiated(context: any): void;
+    protected handleContextChanged(context: any): void;
+    /**
+     * Execute a dynamic action
+     */
+    protected executeAction(action: AXPActionMenuItem): Promise<void>;
+    /**
+     * Execute a command
+     */
+    protected executeCommand(command: AXPExecuteCommand): Promise<void>;
+    /**
+     * Check if form is valid
+     */
+    protected isFormValid(): Promise<boolean>;
+    /** Stepper navigation handlers */
+    protected goPrev(): void;
+    protected goNext(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDynamicDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDynamicDialogComponent, "axp-dynamic-dialog", never, { "config": { "alias": "config"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPDynamicDialogService {
+    private readonly popupService;
+    /**
+     * Show a dynamic dialog with the given configuration
+     * @param config Dialog configuration including fields, validation, and UI options
+     * @returns Promise resolving to dialog reference for controlling the dialog
+     */
+    showDialog(config: AXPDynamicDialogConfig): Promise<AXPDialogRef>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDynamicDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPDynamicDialogService>;
+}
+
 declare class AXPDynamicFormComponent implements OnInit {
     #private;
+    private evaluatorService;
+    /**
+     * Tracks the latest scheduled evaluation to ensure last-write-wins for async evaluate
+     */
+    private evaluationRunId;
+    /**
+     * Memoization cache for resolveParamLayout to keep stable object identities
+     */
+    private layoutCache;
     /**
      * Form definition containing groups and fields
      */
@@ -396,13 +983,27 @@ declare class AXPDynamicFormComponent implements OnInit {
      */
     context: _angular_core.InputSignal<any>;
     /**
-     * Layout style for the form (normal, compact, vertical, horizontal)
+     * Form appearance and density styling (normal, compact, spacious)
      */
-    layoutStyle: _angular_core.InputSignal<AXPDynamicFormLayoutStyle>;
+    layoutLook: _angular_core.InputSignal<AXPDynamicFormLook>;
+    /**
+     * Form layout direction and flow (vertical, horizontal, grid)
+     */
+    layoutDirection: _angular_core.InputSignal<AXPDynamicFormDirection>;
+    /**
+     * Default form mode. Can be overridden by section/group and field.
+     */
+    mode: _angular_core.InputSignal<AXPDynamicFormMode>;
     /**
      * Custom layout configuration for form fields
      */
     layoutConfig: _angular_core.InputSignal<AXPDynamicFormLayoutConfig>;
+    protected expressionEvaluator(expression: any, context: any): Promise<any>;
+    protected evaluatedFormDefinition: _angular_core.WritableSignal<any>;
+    /**
+     * Evaluate definition when inputs change with last-write-wins and deep-equality guard
+     */
+    eff: _angular_core.EffectRef;
     /**
      * Emitted when form context changes
      */
@@ -426,11 +1027,15 @@ declare class AXPDynamicFormComponent implements OnInit {
      */
     protected computedLayout: _angular_core.Signal<AXPDynamicFormLayoutConfig>;
     /**
-     * Computed form definition
+     * Resolve effective mode with precedence: field > group > form
      */
-    protected computedFormDefinition: _angular_core.Signal<AXPDynamicFormDefinition>;
+    protected resolveParamMode: (group: any, param: AXPDynamicFormFieldDefinition) => AXPDynamicFormMode;
     /**
-     * Host classes based on layout style
+     * Resolve effective grid layout for a specific parameter, merging per-parameter override with form layout.
+     */
+    protected resolveParamLayout(param: AXPDynamicFormFieldDefinition): AXPDynamicFormLayoutConfig;
+    /**
+     * Host classes based on layout look and direction
      */
     protected hostClasses: _angular_core.Signal<string>;
     ngOnInit(): void;
@@ -438,6 +1043,7 @@ declare class AXPDynamicFormComponent implements OnInit {
      * Handle context change events from widget container
      */
     protected handleContextChanged(event: AXPLayoutContextChangeEvent): void;
+    protected isRequired(param: AXPDynamicFormFieldDefinition): boolean;
     /**
      * Get the form component instance
      */
@@ -455,10 +1061,389 @@ declare class AXPDynamicFormComponent implements OnInit {
      */
     validate(): Promise<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDynamicFormComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDynamicFormComponent, "axp-dynamic-form", never, { "formDefinition": { "alias": "formDefinition"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; "layoutStyle": { "alias": "layoutStyle"; "required": false; "isSignal": true; }; "layoutConfig": { "alias": "layoutConfig"; "required": false; "isSignal": true; }; }, { "contextChange": "contextChange"; "contextInitiated": "contextInitiated"; "validityChange": "validityChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDynamicFormComponent, "axp-dynamic-form", never, { "formDefinition": { "alias": "formDefinition"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; "layoutLook": { "alias": "layoutLook"; "required": false; "isSignal": true; }; "layoutDirection": { "alias": "layoutDirection"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "layoutConfig": { "alias": "layoutConfig"; "required": false; "isSignal": true; }; }, { "contextChange": "contextChange"; "contextInitiated": "contextInitiated"; "validityChange": "validityChange"; }, never, never, true, never>;
+}
+
+interface TextBoxOptions {
+    placeholder?: string;
+    maxLength?: number;
+    minLength?: number;
+    mask?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    validations?: AXPValidationRules;
+}
+interface LargeTextBoxOptions {
+    placeholder?: string;
+    maxLength?: number;
+    minLength?: number;
+    rows?: number;
+    disabled?: boolean;
+    readonly?: boolean;
+    validations?: AXPValidationRules;
+}
+interface RichTextOptions {
+    placeholder?: string;
+    toolbar?: string[];
+    height?: number;
+    disabled?: boolean;
+    readonly?: boolean;
+    validations?: AXPValidationRules;
+}
+interface SelectBoxOptions<TItem extends Record<string, unknown> = Record<string, unknown>> {
+    valueField: keyof TItem & string;
+    textField: keyof TItem & string;
+    dataSource: TItem[];
+    multiple?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    allowSearch?: boolean;
+    validations?: AXPValidationRules;
+}
+interface LookupBoxOptions {
+    entity: string;
+    multiple?: boolean;
+    expose?: Array<{
+        source: string;
+        target: string;
+    }>;
+    placeholder?: string;
+    textField?: string;
+    valueField?: string;
+    look?: string;
+    columns?: string[];
+    allowClear?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    validations?: AXPValidationRules;
+}
+interface NumberBoxOptions {
+    minValue?: number;
+    maxValue?: number;
+    step?: number;
+    format?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    validations?: AXPValidationRules;
+}
+interface DateTimeBoxOptions {
+    format?: string;
+    min?: Date;
+    max?: Date;
+    showTime?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    validations?: AXPValidationRules;
+}
+interface ToggleSwitchOptions {
+    onText?: string;
+    offText?: string;
+    validations?: AXPValidationRules;
+}
+interface PasswordBoxOptions {
+    placeholder?: string;
+    maxLength?: number;
+    minLength?: number;
+    showToggle?: boolean;
+    validations?: AXPValidationRules;
+}
+interface SelectionListOptions<TItem extends Record<string, unknown> = Record<string, unknown>> {
+    valueField: keyof TItem & string;
+    textField: keyof TItem & string;
+    dataSource: TItem[];
+    multiple?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    validations?: AXPValidationRules;
+}
+interface ColorBoxOptions {
+    defaultColor?: string;
+    showAlpha?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    validations?: AXPValidationRules;
+}
+interface IFieldOptions {
+    hidden?: string | boolean;
+    readonly?: string | boolean;
+    disabled?: string | boolean;
+    defaultValue?: any;
+}
+interface IFieldBuilder {
+    title(title: string): IFieldBuilder;
+    description(description: string): IFieldBuilder;
+    mode(mode: AXPDynamicFormMode): IFieldBuilder;
+    options(values: IFieldOptions): IFieldBuilder;
+    layout(layout: AXPDynamicFormFieldDefinition['layout']): IFieldBuilder;
+    textBox(options?: TextBoxOptions): IFieldBuilder;
+    largeTextBox(options?: LargeTextBoxOptions): IFieldBuilder;
+    richText(options?: RichTextOptions): IFieldBuilder;
+    passwordBox(options?: PasswordBoxOptions): IFieldBuilder;
+    selectBox(options: SelectBoxOptions): IFieldBuilder;
+    lookupBox(options: LookupBoxOptions): IFieldBuilder;
+    selectionList(options: SelectionListOptions): IFieldBuilder;
+    numberBox(options?: NumberBoxOptions): IFieldBuilder;
+    dateTimeBox(options?: DateTimeBoxOptions): IFieldBuilder;
+    toggleSwitch(options?: ToggleSwitchOptions): IFieldBuilder;
+    colorBox(options?: ColorBoxOptions): IFieldBuilder;
+    widget(type: string, options?: unknown): IFieldBuilder;
+}
+interface IGroupBuilder {
+    title(title: string): IGroupBuilder;
+    description(description: string): IGroupBuilder;
+    mode(mode: AXPDynamicFormMode): IGroupBuilder;
+    field(path: string, delegate?: (field: IFieldBuilder) => void): IGroupBuilder;
+    group(name: string, delegate?: (group: IGroupBuilder) => void): IGroupBuilder;
+}
+interface IStepBuilder {
+    title(title: string): IStepBuilder;
+    description(description: string): IStepBuilder;
+    icon(icon: string): IStepBuilder;
+    direction(direction: AXPDynamicFormDirection): IStepBuilder;
+    group(name: string, delegate?: (group: IGroupBuilder) => void): IStepBuilder;
+}
+interface IFormBuilder {
+    group(name: string, delegate?: (group: IGroupBuilder) => void): IFormBuilder;
+    layout(config: Partial<AXPDynamicFormLayoutConfig>): IFormBuilder;
+    look(look: AXPDynamicFormLook): IFormBuilder;
+    direction(direction: AXPDynamicFormDirection): IFormBuilder;
+    mode(mode: AXPDynamicFormMode): IFormBuilder;
+    build(): AXPDynamicFormDefinition;
+}
+interface IActionBuilder {
+    cancel(text?: string): IActionBuilder;
+    submit(text?: string): IActionBuilder;
+    custom(action: AXPActionMenuItem): IActionBuilder;
+}
+interface IDialogBuilder extends IFormBuilder {
+    group(name: string, delegate?: (group: IGroupBuilder) => void): IDialogBuilder;
+    layout(config: Partial<AXPDynamicFormLayoutConfig>): IDialogBuilder;
+    look(look: AXPDynamicFormLook): IDialogBuilder;
+    direction(direction: AXPDynamicFormDirection): IDialogBuilder;
+    closeButton(closeButton: boolean): IDialogBuilder;
+    step(id: string, delegate?: (step: IStepBuilder) => void): IDialogBuilder;
+    stepperDirection(direction: AXOrientation): IDialogBuilder;
+    guardNext(guard: (e: {
+        index: number;
+        id: string;
+        fullContext: unknown;
+    }) => Promise<boolean>): IDialogBuilder;
+    title(title: string): IDialogBuilder;
+    message(message?: string): IDialogBuilder;
+    size(size: AXPopupSizeType): IDialogBuilder;
+    context(context: AXPContextData): IDialogBuilder;
+    actions(delegate?: (actions: IActionBuilder) => void): IDialogBuilder;
+    show(): Promise<AXPDialogRef>;
+}
+interface FormBuilderState {
+    groups: AXPDynamicFormGroupDefinition[];
+    layoutConfig: AXPDynamicFormLayoutConfig;
+    look: AXPDynamicFormLook;
+    direction: AXPDynamicFormDirection;
+    mode?: AXPDynamicFormMode;
+}
+interface DialogBuilderState extends FormBuilderState {
+    title?: string;
+    message?: string;
+    size?: AXPopupSizeType;
+    context?: AXPContextData;
+    steps: StepBuilderState[];
+    stepperDirection?: AXOrientation;
+    closeButton?: boolean;
+    guardNext?: (e: {
+        index: number;
+        id: string;
+        fullContext: unknown;
+    }) => Promise<boolean>;
+    actions?: {
+        footer?: {
+            prefix?: AXPActionMenuItem[];
+            suffix?: AXPActionMenuItem[];
+        };
+    };
+}
+interface FieldBuilderState {
+    path: string;
+    title?: string;
+    description?: string;
+    defaultValue?: any;
+    hidden?: string | boolean;
+    readonly?: string | boolean;
+    disabled?: string | boolean;
+    widget?: AXPWidgetNode;
+    layout?: AXPDynamicFormFieldDefinition['layout'];
+    mode?: AXPDynamicFormMode;
+}
+interface GroupBuilderState {
+    name: string;
+    title?: string;
+    description?: string;
+    parameters: AXPDynamicFormFieldDefinition[];
+    mode?: AXPDynamicFormMode;
+}
+interface StepBuilderState {
+    id: string;
+    title?: string;
+    description?: string;
+    icon?: string;
+    formDirection?: AXPDynamicFormDirection;
+    groups: AXPDynamicFormGroupDefinition[];
+}
+
+declare class AXPDynamicFormBuilderService {
+    private readonly dialogService;
+    /**
+     * Create a new form builder
+     */
+    form(): IFormBuilder;
+    /**
+     * Create a new dialog builder
+     */
+    dialog(): IDialogBuilder;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDynamicFormBuilderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPDynamicFormBuilderService>;
+}
+
+type StateMode = 'empty' | 'error' | 'loading' | 'warning' | 'info' | 'success';
+declare class AXPStateMessageComponent {
+    mode: _angular_core.InputSignal<StateMode>;
+    icon: _angular_core.InputSignal<string>;
+    title: _angular_core.InputSignal<string>;
+    description: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<"default" | "compact" | "minimal">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPStateMessageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPStateMessageComponent, "axp-state-message", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["[slot=actions]"], true, never>;
+}
+
+/**
+ * Describes a schema-only definition for an extra property (no value).
+ */
+interface AXPExtraPropertySchemaItem {
+    /** Unique key for the property (used as identifier) */
+    key: string;
+    /** Human-readable title/label */
+    title: string;
+    /** Widget name/id to render (e.g., 'text-editor', 'checkbox-editor') */
+    type: string;
+    /** Optional widget-specific options */
+    options?: AXPOptionsData;
+}
+/**
+ * Describes a single extra property row.
+ */
+interface AXPExtraPropertyItem extends AXPExtraPropertySchemaItem {
+    /** Current value bound to the rendered widget */
+    value: unknown;
 }
+/**
+ * Describes an available extra property type that user can select when adding rows.
+ */
+interface AXPExtraPropertyType {
+    /** Unique id for the type (it should be the same as the widget name) */
+    id: string;
+    /** UI title for selection dropdown */
+    title: string;
+    /** Default widget options applied on create */
+    defaultOptions?: AXPOptionsData;
+}
+/**
+ * Injection token to provide available extra property types.
+ */
+declare const AXP_EXTRA_PROPERTY_TYPES: InjectionToken<AXPExtraPropertyType[]>;
 
-declare class AXPLayoutFiltersComponent {
+declare class AXPExtraPropertiesComponent {
+    items: _angular_core.InputSignal<AXPExtraPropertyItem[]>;
+    mode: _angular_core.InputSignal<"view" | "edit">;
+    protected onContextChanged(event: AXPLayoutContextChangeEvent): void;
+    itemsChange: _angular_core.OutputEmitterRef<AXPExtraPropertyItem[]>;
+    private readonly providedTypes;
+    private readonly translationService;
+    protected newKey: WritableSignal<string>;
+    protected newTitle: WritableSignal<string>;
+    protected newTypeId: WritableSignal<string>;
+    protected newValue: WritableSignal<any>;
+    /** Local, ephemeral context for widget rendering */
+    protected internalContext: WritableSignal<Record<string, any>>;
+    private lastTypeByKey;
+    protected draftVersion: WritableSignal<number>;
+    protected draftKey: _angular_core.Signal<string>;
+    protected typeOptions: _angular_core.Signal<AXPExtraPropertyType[]>;
+    protected presetTypes: _angular_core.Signal<AXPExtraPropertyType[]>;
+    protected canAdd: _angular_core.Signal<boolean>;
+    /** Sync incoming items' values into internal context for rendering */
+    private readonly syncContextFromItems;
+    /**
+     * Clear item values when their widget type changes to avoid incompatible stale values
+     */
+    private readonly clearValueOnTypeChange;
+    protected handleAddItem(): void;
+    protected handleRemoveItem(key: string): void;
+    protected handleDrop(event: CdkDragDrop<AXPExtraPropertyItem[]>): void;
+    protected selectPreset(id: string): void;
+    private nodeCache;
+    private draftNodeCache?;
+    protected getNode(item: AXPExtraPropertyItem): AXPWidgetNode;
+    protected draftNode(): AXPWidgetNode;
+    protected newTypeChanged(val: string): void;
+    protected ngOnInit(): void;
+    protected handleTitleChange(val: string): void;
+    protected sanitizeKey(input: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPExtraPropertiesComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPExtraPropertiesComponent, "axp-extra-properties", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "itemsChange": "itemsChange"; }, never, never, true, never>;
+}
+
+declare class AXPExtraPropertiesSchemaComponent {
+    schema: _angular_core.InputSignal<AXPExtraPropertySchemaItem[]>;
+    mode: _angular_core.InputSignal<"view" | "edit">;
+    schemaChange: _angular_core.OutputEmitterRef<AXPExtraPropertySchemaItem[]>;
+    private readonly providedTypes;
+    private readonly translationService;
+    protected newTitle: WritableSignal<string>;
+    protected newTypeId: WritableSignal<string>;
+    protected typeOptions: _angular_core.Signal<AXPExtraPropertyType[]>;
+    protected canAdd: _angular_core.Signal<boolean>;
+    protected selectedKey: WritableSignal<string | null>;
+    protected selectedItem: _angular_core.Signal<AXPExtraPropertySchemaItem | null>;
+    constructor();
+    protected handleAdd(): void;
+    protected handleRemove(key: string): void;
+    protected handleDrop(event: CdkDragDrop<AXPExtraPropertySchemaItem[]>): void;
+    protected handleUpdateTitle(key: string, title: string): void;
+    protected handleUpdateType(key: string, typeId: string): void;
+    protected newTypeChanged(val: string): void;
+    protected handleTitleChange(val: string): void;
+    protected handleSelect(key: string): void;
+    protected handleViewerChanged(e: {
+        values: any;
+        mode: 'init' | 'update';
+    }): void;
+    protected deriveKey(input: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPExtraPropertiesSchemaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPExtraPropertiesSchemaComponent, "axp-extra-properties-schema", never, { "schema": { "alias": "schema"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "schemaChange": "schemaChange"; }, never, never, true, never>;
+}
+
+declare class AXPExtraPropertiesValuesComponent {
+    schema: _angular_core.InputSignal<AXPExtraPropertySchemaItem[]>;
+    values: _angular_core.InputSignal<Record<string, any>>;
+    mode: _angular_core.InputSignal<"view" | "edit">;
+    valuesChange: _angular_core.OutputEmitterRef<Record<string, any>>;
+    isRequired: (item: AXPExtraPropertySchemaItem) => any;
+    protected internalContext: _angular_core.WritableSignal<Record<string, any>>;
+    private nodeCache;
+    private lastTypeByKey;
+    protected onContextChanged(event: AXPLayoutContextChangeEvent): void;
+    private readonly syncContextFromInputs;
+    private readonly clearOnSchemaTypeChange;
+    protected getNode(item: AXPExtraPropertySchemaItem): AXPWidgetNode;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPExtraPropertiesValuesComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPExtraPropertiesValuesComponent, "axp-extra-properties-values", never, { "schema": { "alias": "schema"; "required": false; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "valuesChange": "valuesChange"; }, never, never, true, never>;
+}
+
+declare class AXPQueryFiltersComponent {
     #private;
     protected translate: AXTranslationService;
     protected calendarService: AXCalendarService;
@@ -496,8 +1481,113 @@ declare class AXPLayoutFiltersComponent {
     handlePopoverClosed(e: AXEvent): void;
     protected onPopoverOpened(e: AXEvent): void;
     protected deactivateAllListItems(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLayoutFiltersComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPLayoutFiltersComponent, "axp-layout-filters", never, { "filtersDefinitions": { "alias": "filtersDefinitions"; "required": false; "isSignal": true; }; "initialFilters": { "alias": "initialFilters"; "required": false; "isSignal": true; }; }, { "onFiltersChanged": "onFiltersChanged"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryFiltersComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryFiltersComponent, "axp-query-filters", never, { "filtersDefinitions": { "alias": "filtersDefinitions"; "required": false; "isSignal": true; }; "initialFilters": { "alias": "initialFilters"; "required": false; "isSignal": true; }; }, { "onFiltersChanged": "onFiltersChanged"; }, never, never, true, never>;
+}
+
+interface AXPWidgetPropertyTab {
+    name: string;
+    title: string;
+    groups: {
+        name: string;
+        title: string;
+        isCollapsed: boolean;
+        props: AXPWidgetProperty[];
+    }[];
+}
+interface AXPWidgetPropertiesChangedEvent {
+    values: any;
+    mode: 'init' | 'update';
+}
+declare class AXPWidgetPropertyViewerComponent {
+    widget: _angular_core.InputSignal<AXPWidgetNode>;
+    mode: _angular_core.InputSignal<"simple" | "advanced">;
+    private widgetRegistryService;
+    protected currentTabIndex: WritableSignal<number>;
+    protected config: WritableSignal<AXPWidgetConfig<any> | null>;
+    protected allPoperties: AXPWidgetProperty[];
+    protected tabs: WritableSignal<AXPWidgetPropertyTab[]>;
+    protected groups: _angular_core.Signal<{
+        name: string;
+        title: string;
+        isCollapsed: boolean;
+        props: AXPWidgetProperty[];
+    }[]>;
+    protected groupCollapsedStates: Map<string, boolean>;
+    onChanged: EventEmitter<AXPWidgetPropertiesChangedEvent>;
+    protected context: WritableSignal<any>;
+    protected initialContext: any;
+    constructor();
+    update(values: any): void;
+    private fillTabs;
+    protected handleContextChange(e: AXPLayoutContextChangeEvent): void;
+    protected handleTabChange(event: AXTabStripChangedEvent): void;
+    protected handleCollapsedChange(group: string, collapsed: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetPropertyViewerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetPropertyViewerComponent, "axp-widget-property-viewer", never, { "widget": { "alias": "widget"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "onChanged": "onChanged"; }, never, never, true, never>;
+}
+
+declare class AXPQuerySortsComponent {
+    sortDefinitions: _angular_core.ModelSignal<AXPSortDefinition[]>;
+    sortQueries: _angular_core.WritableSignal<AXPSortQuery[]>;
+    initialSortQueries: _angular_core.InputSignal<AXPSortQuery[]>;
+    sortQueriesChange: _angular_core.OutputEmitterRef<AXPSortQuery[]>;
+    constructor();
+    protected drop(event: CdkDragDrop<unknown[]>): void;
+    getSortDirection(item: AXPSortDefinition): "desc" | "asc" | undefined;
+    protected changeItemSort(item: AXPSortDefinition): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQuerySortsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQuerySortsComponent, "axp-query-sorts", never, { "sortDefinitions": { "alias": "sortDefinitions"; "required": false; "isSignal": true; }; "initialSortQueries": { "alias": "initialSortQueries"; "required": false; "isSignal": true; }; }, { "sortDefinitions": "sortDefinitionsChange"; "sortQueriesChange": "sortQueriesChange"; }, never, never, true, never>;
+}
+
+interface AXPTemplateViewerConfig {
+    template: AXPWidgetNode | string;
+    title?: string;
+    size?: AXPopupSizeType;
+    context?: any;
+    metadata?: AXPMetaData;
+    readOnly?: boolean;
+    showActions?: boolean;
+}
+interface AXPTemplateViewerResult {
+    context: any;
+    cancelled: boolean;
+    metadata?: AXPMetaData;
+}
+
+declare class AXPTemplateViewerComponent extends AXBasePageComponent {
+    set config(value: AXPTemplateViewerConfig | undefined);
+    get config(): AXPTemplateViewerConfig | undefined;
+    protected context: any;
+    protected readonly document: _angular_core.WritableSignal<AXPWidgetNode>;
+    protected readonly currentPageIndex: _angular_core.WritableSignal<number>;
+    protected readonly _config: _angular_core.WritableSignal<AXPTemplateViewerConfig | undefined>;
+    protected readonly currentPage: _angular_core.Signal<AXPWidgetNode>;
+    protected ngOnInit(): Promise<void>;
+    private loadTemplate;
+    protected handleContextChanged(e: AXPLayoutContextChangeEvent): void;
+    protected handleSubmit(form: AXFormComponent): Promise<void>;
+    protected handleCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTemplateViewerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTemplateViewerComponent, "axp-template-viewer", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPTemplateViewerService {
+    private readonly popupService;
+    /**
+     * Show a template viewer dialog with the given configuration
+     * @param config Template viewer configuration including template, title, and UI options
+     * @returns Promise resolving to viewer result with form values and cancellation status
+     */
+    showTemplate(config: AXPTemplateViewerConfig): Promise<AXPTemplateViewerResult>;
+    /**
+     * Show a template viewer in read-only mode
+     * @param config Template viewer configuration
+     * @returns Promise resolving to viewer result
+     */
+    showTemplateReadOnly(config: Omit<AXPTemplateViewerConfig, 'readOnly' | 'showActions'>): Promise<AXPTemplateViewerResult>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTemplateViewerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTemplateViewerService>;
 }
 
 type AXPUserAvatarSize = 'small' | 'medium' | 'large';
@@ -591,6 +1681,21 @@ declare class AXPUserAvatarComponent implements OnInit, OnDestroy {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPUserAvatarComponent, "axp-user-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "userId": { "alias": "userId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+declare class AXPQueryViewsComponent {
+    #private;
+    protected popupService: AXPopupService;
+    protected translate: AXTranslationService;
+    protected tabs: _angular_core.Signal<AXTabsComponent | undefined>;
+    views: _angular_core.ModelSignal<AXPViewQuery[]>;
+    selectedView: _angular_core.ModelSignal<AXPViewQuery>;
+    protected isMounted: _angular_core.WritableSignal<boolean>;
+    ngAfterViewInit(): void;
+    setView(view: AXPViewQuery): void;
+    handleActiveChange(e: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryViewsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryViewsComponent, "axp-query-views", never, { "views": { "alias": "views"; "required": false; "isSignal": true; }; "selectedView": { "alias": "selectedView"; "required": true; "isSignal": true; }; }, { "views": "viewsChange"; "selectedView": "selectedViewChange"; }, never, never, true, never>;
+}
+
 /**
  * Generic interface for widget item data
  */
@@ -651,5 +1756,5 @@ declare class AXPWidgetItemComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetItemComponent, "axp-widget-item", never, { "widget": { "alias": "widget"; "required": true; "isSignal": true; }; "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "showPinButton": { "alias": "showPinButton"; "required": false; "isSignal": true; }; "customClasses": { "alias": "customClasses"; "required": false; "isSignal": true; }; }, { "onWidgetClick": "onWidgetClick"; "onPinClick": "onPinClick"; }, never, never, true, never>;
 }
 
-export { AXPActivityLogComponent, AXPCompareViewComponent, AXPComponentSlot, AXPComponentSlotDirective, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPDynamicFormComponent, AXPLayoutFiltersComponent, AXPMenuBadgeHelper, AXPTaskBadgeDirective, AXPTaskBadgeProvider, AXPTaskBadgeService, AXPThemeLayoutActionsComponent, AXPThemeLayoutBlockComponent, AXPThemeLayoutContainerComponent, AXPThemeLayoutEndSideComponent, AXPThemeLayoutFooterComponent, AXPThemeLayoutHeaderComponent, AXPThemeLayoutListComponent, AXPThemeLayoutListItemComponent, AXPThemeLayoutListItemsGroupComponent, AXPThemeLayoutPageHeaderComponent, AXPThemeLayoutPagePrimaryActionsComponent, AXPThemeLayoutPageSecondaryActionsComponent, AXPThemeLayoutSectionComponent, AXPThemeLayoutStartSideComponent, AXPThemeLayoutToolbarComponent, AXPUserAvatarComponent, AXPUserAvatarService, AXPWidgetItemComponent, AXP_TASK_BADGE_PROVIDERS, AXP_USER_AVATAR_PROVIDER };
-export type { AXPCompareViewField, AXPCompareViewInputs, AXPCompareViewMode, AXPCompareViewObject, AXPComponentSlotConfig, AXPComponentSlotModuleConfigs, AXPDynamicFormDefinition, AXPDynamicFormFieldDefinition, AXPDynamicFormGroupDefinition, AXPDynamicFormLayoutConfig, AXPDynamicFormLayoutStyle, AXPUserAvatarData, AXPUserAvatarProvider, AXPUserAvatarSize, AXPUserAvatarStatus, AXPWidgetItemClickEvent, AXPWidgetItemData };
+export { AXPActivityLogComponent, AXPCategoryTreeComponent, AXPCompareViewComponent, AXPComponentSlot, AXPComponentSlotDirective, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPDataSelectorComponent, AXPDataSelectorService, AXPDynamicDialogComponent, AXPDynamicDialogService, AXPDynamicFormBuilderService, AXPDynamicFormComponent, AXPDynamicFormStepperComponent, AXPExtraPropertiesComponent, AXPExtraPropertiesSchemaComponent, AXPExtraPropertiesValuesComponent, AXPMenuBadgeHelper, AXPQueryColumnsComponent, AXPQueryFiltersComponent, AXPQuerySortsComponent, AXPQueryViewsComponent, AXPStateMessageComponent, AXPTaskBadgeDirective, AXPTaskBadgeProvider, AXPTaskBadgeService, AXPTemplateViewerComponent, AXPTemplateViewerService, AXPThemeLayoutActionsComponent, AXPThemeLayoutBlockComponent, AXPThemeLayoutContainerComponent, AXPThemeLayoutEndSideComponent, AXPThemeLayoutFooterComponent, AXPThemeLayoutHeaderComponent, AXPThemeLayoutListComponent, AXPThemeLayoutListItemComponent, AXPThemeLayoutListItemsGroupComponent, AXPThemeLayoutPageHeaderComponent, AXPThemeLayoutPagePrimaryActionsComponent, AXPThemeLayoutPageSecondaryActionsComponent, AXPThemeLayoutSectionComponent, AXPThemeLayoutStartSideComponent, AXPThemeLayoutToolbarComponent, AXPUserAvatarComponent, AXPUserAvatarService, AXPWidgetItemComponent, AXPWidgetPropertyViewerComponent, AXP_EXTRA_PROPERTY_TYPES, AXP_TASK_BADGE_PROVIDERS, AXP_USER_AVATAR_PROVIDER };
+export type { AXPCategoryTreeActions, AXPCategoryTreeConfig, AXPCategoryTreeDataSource, AXPCategoryTreeEvents, AXPCategoryTreeNode, AXPCompareViewField, AXPCompareViewInputs, AXPCompareViewMode, AXPCompareViewObject, AXPComponentSlotConfig, AXPComponentSlotModuleConfigs, AXPDataSelectorColumn, AXPDataSelectorConfig, AXPDialogRef, AXPDynamicDialogConfig, AXPDynamicDialogResult, AXPDynamicFormDefinition, AXPDynamicFormDirection, AXPDynamicFormFieldDefinition, AXPDynamicFormGroupDefinition, AXPDynamicFormLayoutConfig, AXPDynamicFormLook, AXPDynamicFormMode, AXPDynamicFormStepperDefinition, AXPDynamicFormStepperStepDefinition, AXPExtraPropertyItem, AXPExtraPropertySchemaItem, AXPExtraPropertyType, AXPTemplateViewerConfig, AXPTemplateViewerResult, AXPUserAvatarData, AXPUserAvatarProvider, AXPUserAvatarSize, AXPUserAvatarStatus, AXPWidgetItemClickEvent, AXPWidgetItemData, AXPWidgetPropertiesChangedEvent, AXPWidgetPropertyTab, ColorBoxOptions, DateTimeBoxOptions, DialogBuilderState, FieldBuilderState, FormBuilderState, GroupBuilderState, IActionBuilder, IDialogBuilder, IFieldBuilder, IFieldOptions, IFormBuilder, IGroupBuilder, IStepBuilder, LargeTextBoxOptions, LookupBoxOptions, NumberBoxOptions, PasswordBoxOptions, RichTextOptions, SelectBoxOptions, SelectionListOptions, StateMode, StepBuilderState, TextBoxOptions, ToggleSwitchOptions };