@acorex/platform 20.3.0-next.14 → 20.3.0-next.16

package/layout/builder/index.d.ts

@@ -1,13 +1,148 @@
 import * as i0 from '@angular/core';
-import { OnInit } from '@angular/core';
+import { OnInit, EventEmitter } from '@angular/core';
 import * as i1 from '@angular/common';
-import { AXPWidgetRenderMode, AXPWidgetNode } from '@acorex/platform/layout/widget-core';
-import { AXPGridLayoutOptions } from '@acorex/platform/core';
+import { AXPWidgetNode, AXPWidgetCoreContextChangeEvent, AXPWidgetContainerComponent, AXPWidgetRenderMode } from '@acorex/platform/layout/widget-core';
+import { AXFormComponent } from '@acorex/components/form';
+import { AXPDynamicFormDefinition, AXPDynamicFormLook, AXPDynamicFormMode, AXPDialogRef } from '@acorex/platform/layout/components';
+import { AXValidationSummary } from '@acorex/core/validation';
+import { AXDataSource } from '@acorex/cdk/common';
+import { AXPopupSizeType } from '@acorex/components/popup';
+import { AXPExpression, AXPGridLayoutOptions, AXPValidationRules, AXPActionMenuItem, AXPOptionsData } from '@acorex/platform/core';
+import { AXBasePageComponent } from '@acorex/components/page';
 
-type AXPLayoutMode = AXPWidgetRenderMode;
-type AXPLayoutDirection = 'horizontal' | 'vertical';
-type AXPLayoutLook = 'normal' | 'borderless' | 'outlined';
-interface TextBoxOptions {
+declare class AXPLayoutRendererComponent implements OnInit {
+    #private;
+    private evaluatorService;
+    private conversionService;
+    /**
+     * Tracks the latest scheduled evaluation to ensure last-write-wins for async evaluate
+     */
+    private evaluationRunId;
+    /**
+     * RxJS subjects for context management
+     */
+    private contextUpdateSubject;
+    private contextChangeSubject;
+    /**
+     * Cache for expression evaluation results
+     */
+    private expressionCache;
+    /**
+     * Cache for widget tree comparisons
+     */
+    private widgetTreeCache;
+    /**
+     * Last layout hash for change detection
+     */
+    private lastLayoutHash;
+    /**
+     * Form definition containing groups and fields OR widget tree
+     */
+    layout: i0.InputSignal<AXPWidgetNode | AXPDynamicFormDefinition>;
+    /**
+     * Form context/model data
+     */
+    context: i0.ModelSignal<any>;
+    /**
+     * Form appearance and density styling (normal, compact, spacious)
+     */
+    look: i0.InputSignal<AXPDynamicFormLook>;
+    /**
+     * Default form mode. Can be overridden by section/group and field.
+     */
+    mode: i0.InputSignal<AXPDynamicFormMode>;
+    protected widgetTree: i0.WritableSignal<AXPWidgetNode | null>;
+    /**
+     * Convert and evaluate data when inputs change (optimized with RxJS)
+     */
+    conversionEffect: i0.EffectRef;
+    protected expressionEvaluator(expression: any, context: any): Promise<any>;
+    /**
+     * Emitted when context change is initiated
+     */
+    contextInitiated: i0.OutputEmitterRef<any>;
+    /**
+     * Emitted when form becomes valid/invalid
+     */
+    validityChange: i0.OutputEmitterRef<boolean>;
+    private form;
+    private container;
+    /**
+     * Internal context signal for reactivity
+     */
+    protected internalContext: i0.WritableSignal<any>;
+    ngOnInit(): void;
+    /**
+     * Handle context change events from widget container (optimized with RxJS)
+     */
+    protected handleContextChanged(event: AXPWidgetCoreContextChangeEvent): void;
+    /**
+     * Get the form component instance
+     */
+    getForm(): AXFormComponent | undefined;
+    /**
+     * Get the widget container component instance
+     */
+    getContainer(): AXPWidgetContainerComponent | undefined;
+    /**
+     * Get current form context
+     */
+    getContext(): any;
+    /**
+     * Update form context programmatically
+     */
+    updateContext(context: any): void;
+    /**
+     * Get the current widget tree
+     */
+    getWidgetTree(): AXPWidgetNode | null;
+    /**
+     * Validate the form
+     */
+    validate(): Promise<AXValidationSummary>;
+    /**
+     * Setup RxJS streams for context management
+     */
+    private setupContextStreams;
+    /**
+     * Type guard to check if the input is a form definition
+     */
+    private isFormDefinition;
+    /**
+     * Generate layout hash for change detection (short hash)
+     */
+    private generateLayoutHash;
+    /**
+     * Generate cache key for expression evaluation (short hash)
+     */
+    private generateCacheKey;
+    /**
+     * Generate a simple hash for context change detection
+     */
+    private generateContextHash;
+    /**
+     * Simple hash function for generating short keys
+     */
+    private simpleHash;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPLayoutRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPLayoutRendererComponent, "axp-layout-renderer", never, { "layout": { "alias": "layout"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "look": { "alias": "look"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "context": "contextChange"; "contextInitiated": "contextInitiated"; "validityChange": "validityChange"; }, never, never, true, never>;
+}
+
+declare class LayoutBuilderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutBuilderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LayoutBuilderModule, never, [typeof i1.CommonModule, typeof AXPLayoutRendererComponent], [typeof AXPLayoutRendererComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LayoutBuilderModule>;
+}
+
+interface LayoutWidgetOptions {
+    name?: string;
+}
+interface ValueWidgetOptions extends LayoutWidgetOptions {
+    path: string;
+    defaultValue?: any;
+    validations?: AXPValidationRules;
+}
+interface TextBoxOptions extends ValueWidgetOptions {
     placeholder?: string;
     maxLength?: number;
     minLength?: number;
@@ -15,23 +150,24 @@ interface TextBoxOptions {
     suffix?: string;
     clearButton?: boolean;
 }
-interface NumberBoxOptions {
+interface NumberBoxOptions extends ValueWidgetOptions {
     min?: number;
     max?: number;
     step?: number;
     placeholder?: string;
     format?: string;
 }
-interface SelectBoxOptions {
-    items: any[] | (() => any[]) | (() => Promise<any[]>);
+interface SelectBoxOptions extends ValueWidgetOptions {
+    dataSource: any[] | (() => any[]) | (() => Promise<any[]>) | AXDataSource<any>;
     valueField?: string;
     textField?: string;
     placeholder?: string;
     multiple?: boolean;
     searchable?: boolean;
     clearButton?: boolean;
+    allowSearch?: boolean;
 }
-interface DateTimeBoxOptions {
+interface DateTimeBoxOptions extends ValueWidgetOptions {
     type?: 'date' | 'time' | 'datetime';
     format?: string;
     min?: Date | string;
@@ -39,24 +175,24 @@ interface DateTimeBoxOptions {
     placeholder?: string;
     clearButton?: boolean;
 }
-interface ToggleSwitchOptions {
+interface ToggleSwitchOptions extends ValueWidgetOptions {
     label?: string;
     trueText?: string;
     falseText?: string;
 }
-interface LargeTextBoxOptions {
+interface LargeTextBoxOptions extends ValueWidgetOptions {
     rows?: number;
     maxLength?: number;
     minLength?: number;
     placeholder?: string;
     resizable?: boolean;
 }
-interface ColorBoxOptions {
+interface ColorBoxOptions extends ValueWidgetOptions {
     format?: 'hex' | 'rgb' | 'hsl';
     showAlpha?: boolean;
     showPalette?: boolean;
 }
-interface AXPFlexContainerOptions {
+interface AXPFlexContainerOptions extends LayoutWidgetOptions {
     flexDirection?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
     flexWrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
     justifyContent?: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
@@ -84,7 +220,7 @@ interface AXPFlexContainerOptions {
     minHeight?: string;
     maxHeight?: string;
 }
-interface AXPGridContainerOptions {
+interface AXPGridContainerOptions extends LayoutWidgetOptions {
     grid?: {
         default?: {
             columns?: number;
@@ -117,7 +253,7 @@ interface AXPGridContainerOptions {
     minHeight?: string;
     maxHeight?: string;
 }
-interface AXPPanelContainerOptions {
+interface AXPPanelContainerOptions extends LayoutWidgetOptions {
     caption?: string;
     icon?: string;
     look?: 'solid' | 'fill' | 'outline' | 'flat' | 'none';
@@ -125,7 +261,7 @@ interface AXPPanelContainerOptions {
     showHeader?: boolean;
     collapsed?: boolean;
 }
-interface AXPPageContainerOptions {
+interface AXPPageContainerOptions extends LayoutWidgetOptions {
     backgroundColor?: string;
     theme?: {
         id: string;
@@ -134,216 +270,198 @@ interface AXPPageContainerOptions {
     hasFooter?: boolean;
     direction?: string;
 }
-interface AXPTabsetContainerOptions {
+interface AXPTabsetContainerOptions extends LayoutWidgetOptions {
     look?: 'with-line' | 'with-line-color' | 'pills' | 'pills-color';
     orientation?: 'vertical' | 'horizontal';
     activeIndex?: number;
 }
-interface RichTextOptions {
+interface AXPFieldsetContainerOptions extends LayoutWidgetOptions {
+    title?: string;
+    description?: string;
+    icon?: string;
+    collapsible?: boolean;
+    isOpen?: boolean;
+    look?: 'fieldset' | 'card' | 'group';
+    disabled?: boolean;
+    showHeader?: boolean;
+    cols?: number;
+}
+interface AXPFormFieldOptions extends LayoutWidgetOptions {
+    label?: string;
+    showLabel?: boolean;
+}
+interface AXPDialogContainerOptions extends LayoutWidgetOptions {
+    title?: string;
+    message?: string;
+    size?: AXPopupSizeType;
+    closeButton?: boolean;
+    context?: any;
+}
+interface RichTextOptions extends ValueWidgetOptions {
     placeholder?: string;
     toolbar?: string[];
     readonly?: boolean;
 }
-interface PasswordBoxOptions {
+interface PasswordBoxOptions extends ValueWidgetOptions {
     placeholder?: string;
     revealToggle?: boolean;
     maxLength?: number;
 }
-interface LookupBoxOptions {
+interface LookupBoxOptions extends ValueWidgetOptions {
     dataSource?: any[] | (() => any[]) | (() => Promise<any[]>);
     valueField?: string;
     textField?: string;
     searchable?: boolean;
+    entity?: string;
+    look?: string;
+    columns?: any[];
+    expose?: any[];
+    multiple?: boolean;
+    allowClear?: boolean;
 }
-interface SelectionListOptions {
-    items: any[] | (() => any[]) | (() => Promise<any[]>);
+interface SelectionListOptions extends ValueWidgetOptions {
+    dataSource: any[] | (() => any[]) | (() => Promise<any[]>) | AXDataSource<any>;
     valueField?: string;
     textField?: string;
     multiple?: boolean;
     searchable?: boolean;
+    placeholder?: string;
 }
-interface AXPWidgetConfiguration {
-    type: string;
-    options?: any;
+interface AXPListWidgetColumn {
+    name: string;
+    title?: string;
+    visible?: boolean;
+    width?: string;
+    widget?: {
+        type: string;
+        path?: string;
+        options?: any;
+    };
 }
-interface AXPLayoutNodeDefinition {
-    id?: string;
-    name?: string;
-    widget?: AXPWidgetConfiguration;
-    children?: AXPLayoutNodeDefinition[];
-    layout?: AXPGridLayoutOptions;
-    mode?: AXPLayoutMode;
-    order?: number | string;
-    visible?: boolean | string;
+interface AXPListWidgetRowCommand {
+    title?: string;
+    icon?: string;
+    color?: string;
     disabled?: boolean | string;
-    readonly?: boolean | string;
+    hidden?: boolean | string;
+    command?: any;
+}
+interface AXPListWidgetOptions extends LayoutWidgetOptions {
+    dataSource?: any[] | AXDataSource;
+    columns?: AXPListWidgetColumn[];
+    onRowClick?: (row: any) => void;
+    onRowDoubleClick?: (row: any) => void;
+    onSelectionChange?: (selectedRows: any[]) => void;
+    onRowCommand?: (command: any, selectedRows: any[]) => void;
+    paging?: boolean;
+    showHeader?: boolean;
+    showFooter?: boolean;
+    fixHeader?: boolean;
+    fixFooter?: boolean;
+    fetchDataMode?: 'auto' | 'manual';
+    parentField?: string;
+    minHeight?: string | number;
+    showIndex?: boolean;
+    allowSelection?: boolean;
+    primaryCommands?: any[];
+    secondaryCommands?: AXPListWidgetRowCommand[];
+    loading?: {
+        enabled?: boolean;
+        animation?: boolean;
+    };
 }
-interface AXPLayoutDefinition {
-    nodes: AXPLayoutNodeDefinition[];
-    mode?: AXPLayoutMode;
-    direction?: AXPLayoutDirection;
-    look?: AXPLayoutLook;
-    layoutConfig?: AXPGridLayoutOptions;
-}
-interface LayoutBuilderState {
-    nodes: AXPLayoutNodeDefinition[];
-    mode: AXPLayoutMode;
-    direction: AXPLayoutDirection;
-    look: AXPLayoutLook;
-    layoutConfig: AXPGridLayoutOptions;
-}
-interface WidgetBuilderState {
-    id?: string;
-    name?: string;
-    type: 'widget';
-    widget?: AXPWidgetConfiguration;
-    children?: AXPLayoutNodeDefinition[];
-    layout?: AXPGridLayoutOptions;
-    mode?: AXPLayoutMode;
-    order?: number | string;
-    visible?: boolean | string;
+interface InheritanceContext {
+    mode?: AXPWidgetRenderMode;
     disabled?: boolean | string;
     readonly?: boolean | string;
+    direction?: 'rtl' | 'ltr';
+    visible?: boolean | string;
+}
+interface InheritedProperties {
+    mode: AXPWidgetRenderMode;
+    disabled: boolean | string | undefined;
+    readonly: boolean | string | undefined;
+    direction: 'rtl' | 'ltr' | undefined;
+    visible: boolean | string | undefined;
+}
+interface AXPWidgetConfiguration {
+    type: string;
+    options?: AXPOptionsData;
+}
+type LayoutBuilderState = AXPWidgetNode;
+type WidgetBuilderState = Omit<AXPWidgetNode, 'children'> & {
+    layout?: AXPGridLayoutOptions;
+};
+type FormFieldBuilderState = AXPWidgetNode & {
+    layout?: AXPGridLayoutOptions;
+};
+type DialogBuilderState = AXPWidgetNode & {
+    layout?: AXPGridLayoutOptions;
+    dialogOptions?: AXPDialogContainerOptions;
+    actions?: {
+        footer?: {
+            prefix?: AXPActionMenuItem[];
+            suffix?: AXPActionMenuItem[];
+        };
+    };
+};
+interface IActionBuilder {
+    cancel(text?: string): IActionBuilder;
+    submit(text?: string): IActionBuilder;
+    custom(action: AXPActionMenuItem): IActionBuilder;
 }
 interface ILayoutBuilder {
-    widget(name?: string, delegate?: (widget: IWidgetBuilder) => void): ILayoutBuilder;
     grid(delegate: (container: IGridContainerBuilder) => void): ILayoutBuilder;
     flex(delegate: (container: IFlexContainerBuilder) => void): ILayoutBuilder;
     panel(delegate: (container: IPanelContainerBuilder) => void): ILayoutBuilder;
     page(delegate: (container: IPageContainerBuilder) => void): ILayoutBuilder;
     tabset(delegate: (container: ITabsetContainerBuilder) => void): ILayoutBuilder;
-    textBox(options?: TextBoxOptions): ILayoutBuilder;
-    largeTextBox(options?: LargeTextBoxOptions): ILayoutBuilder;
-    richText(options?: RichTextOptions): ILayoutBuilder;
-    passwordBox(options?: PasswordBoxOptions): ILayoutBuilder;
-    numberBox(options?: NumberBoxOptions): ILayoutBuilder;
-    selectBox(options: SelectBoxOptions): ILayoutBuilder;
-    lookupBox(options: LookupBoxOptions): ILayoutBuilder;
-    selectionList(options: SelectionListOptions): ILayoutBuilder;
-    dateTimeBox(options?: DateTimeBoxOptions): ILayoutBuilder;
-    toggleSwitch(options?: ToggleSwitchOptions): ILayoutBuilder;
-    colorBox(options?: ColorBoxOptions): ILayoutBuilder;
-    customWidget(type: string, options?: any): ILayoutBuilder;
-    layout(config: Partial<AXPGridLayoutOptions>): ILayoutBuilder;
-    mode(mode: AXPLayoutMode): ILayoutBuilder;
-    direction(direction: AXPLayoutDirection): ILayoutBuilder;
-    look(look: AXPLayoutLook): ILayoutBuilder;
-    build(): AXPLayoutDefinition;
-    render(): AXPWidgetNode;
-}
-interface LayoutDefinition {
-    zones: {
-        [zoneId: string]: ZoneConfig;
-    };
-    styles?: {
-        [key: string]: any;
-    };
-    responsive?: ResponsiveConfig;
-}
-interface ZoneConfig {
-    layout?: LayoutTypeConfig;
-    styles?: {
-        [key: string]: any;
-    };
-    containers?: {
-        [containerId: string]: ContainerConfig;
-    };
-    order?: number;
-}
-interface ContainerConfig {
-    layout?: LayoutTypeConfig;
-    styles?: {
-        [key: string]: any;
-    };
-}
-interface LayoutTypeConfig {
-    type?: 'flex' | 'grid' | 'block';
-    flexDirection?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
-    justifyContent?: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
-    alignItems?: 'flex-start' | 'flex-end' | 'center' | 'baseline' | 'stretch';
-    gap?: string;
-    grid?: {
-        columns?: number;
-        rows?: number;
-        gap?: string;
-    };
-}
-interface LayoutNode {
-    id: string;
-    type: string;
-    zone: string;
-    container?: string;
-    path?: string;
-    options?: any;
-    formula?: string;
-    triggers?: any[];
-    defaultValue?: any;
-    mode?: AXPLayoutMode;
-    layout?: NodeLayoutConfig;
-}
-interface NodeLayoutConfig {
-    width?: string;
-    height?: string;
-    order?: number;
-    flex?: string;
-    gridArea?: string;
-}
-interface ResponsiveConfig {
-    breakpoints?: {
-        mobile?: number;
-        tablet?: number;
-        desktop?: number;
-    };
-}
-interface LayoutRenderContext {
-    data?: any;
-    variables?: {
-        [key: string]: any;
-    };
-    functions?: {
-        [key: string]: Function;
-    };
+    fieldset(delegate: (container: IFieldsetContainerBuilder) => void): ILayoutBuilder;
+    dialog(delegate: (container: IDialogBuilder) => void): IDialogBuilder;
+    build(): AXPWidgetNode;
 }
 interface IWidgetBuilder {
-    id(id: string): IWidgetBuilder;
+    name(name: string): IWidgetBuilder;
+    path(path: string): IWidgetBuilder;
+    type(type: string): IWidgetBuilder;
+    options(options: AXPOptionsData): IWidgetBuilder;
     layout(config: Partial<AXPGridLayoutOptions>): IWidgetBuilder;
     layout(colSpan: number): IWidgetBuilder;
-    mode(mode: AXPLayoutMode): IWidgetBuilder;
-    order(value: number | string): IWidgetBuilder;
+    mode(mode: AXPWidgetRenderMode): IWidgetBuilder;
     visible(condition: boolean | string): IWidgetBuilder;
     disabled(condition: boolean | string): IWidgetBuilder;
     readonly(condition: boolean | string): IWidgetBuilder;
-    grid(delegate: (container: IGridContainerBuilder) => void): IWidgetBuilder;
-    flex(delegate: (container: IFlexContainerBuilder) => void): IWidgetBuilder;
-    panel(delegate: (container: IPanelContainerBuilder) => void): IWidgetBuilder;
-    page(delegate: (container: IPageContainerBuilder) => void): IWidgetBuilder;
-    tabset(delegate: (container: ITabsetContainerBuilder) => void): IWidgetBuilder;
-    widget(name?: string, delegate?: (widget: IWidgetBuilder) => void): IWidgetBuilder;
-    textBox(options?: TextBoxOptions): IWidgetBuilder;
-    largeTextBox(options?: LargeTextBoxOptions): IWidgetBuilder;
-    richText(options?: RichTextOptions): IWidgetBuilder;
-    passwordBox(options?: PasswordBoxOptions): IWidgetBuilder;
-    numberBox(options?: NumberBoxOptions): IWidgetBuilder;
-    selectBox(options: SelectBoxOptions): IWidgetBuilder;
-    lookupBox(options: LookupBoxOptions): IWidgetBuilder;
-    selectionList(options: SelectionListOptions): IWidgetBuilder;
-    dateTimeBox(options?: DateTimeBoxOptions): IWidgetBuilder;
-    toggleSwitch(options?: ToggleSwitchOptions): IWidgetBuilder;
-    colorBox(options?: ColorBoxOptions): IWidgetBuilder;
-    customWidget<T>(type: string, options?: T): IWidgetBuilder;
-    build(): AXPLayoutNodeDefinition;
+    direction(direction: 'rtl' | 'ltr'): IWidgetBuilder;
+    withInheritanceContext(context: InheritanceContext): IWidgetBuilder;
+    getInheritanceContext(): InheritanceContext;
+    build(): AXPWidgetNode;
 }
 interface IBaseContainerBuilder<TContainer = any> {
-    id(id: string): TContainer;
+    name(name: string): TContainer;
+    path(path: string): TContainer;
+    mode(mode: AXPWidgetRenderMode): TContainer;
+    visible(condition: boolean | AXPExpression): TContainer;
+    disabled(condition: boolean | AXPExpression): TContainer;
+    readonly(condition: boolean | AXPExpression): TContainer;
+    direction(direction: 'rtl' | 'ltr'): TContainer;
+    withInheritanceContext(context: InheritanceContext): TContainer;
+    getInheritanceContext(): InheritanceContext;
+    build(): AXPWidgetNode;
+}
+interface ILayoutContainerBuilder<TContainer = any> {
     layout(config: Partial<AXPGridLayoutOptions>): TContainer;
     layout(colSpan: number): TContainer;
-    mode(mode: AXPLayoutMode): TContainer;
-    order(value: number | string): TContainer;
-    visible(condition: boolean | string): TContainer;
-    disabled(condition: boolean | string): TContainer;
-    readonly(condition: boolean | string): TContainer;
-    addContainer<T extends IBaseContainerBuilder>(name?: string, delegate?: (container: T) => void): TContainer;
-    addWidget(name?: string, delegate?: (widget: IWidgetBuilder) => void): TContainer;
+}
+interface IChildContainerBuilder<TContainer = any> {
+    grid(delegate: (container: IGridContainerBuilder) => void): TContainer;
+    flex(delegate: (container: IFlexContainerBuilder) => void): TContainer;
+    panel(delegate: (container: IPanelContainerBuilder) => void): TContainer;
+    page(delegate: (container: IPageContainerBuilder) => void): TContainer;
+    tabset(delegate: (container: ITabsetContainerBuilder) => void): TContainer;
+    fieldset(delegate: (container: IFieldsetContainerBuilder) => void): TContainer;
+    formField(label: string, delegate?: (field: IFormFieldBuilder) => void): TContainer;
+}
+interface IWidgetContainerBuilder<TContainer = any> {
     textBox(options?: TextBoxOptions): TContainer;
     largeTextBox(options?: LargeTextBoxOptions): TContainer;
     richText(options?: RichTextOptions): TContainer;
@@ -355,13 +473,13 @@ interface IBaseContainerBuilder<TContainer = any> {
     dateTimeBox(options?: DateTimeBoxOptions): TContainer;
     toggleSwitch(options?: ToggleSwitchOptions): TContainer;
     colorBox(options?: ColorBoxOptions): TContainer;
+    list(delegate: (container: IListWidgetBuilder) => void): TContainer;
     customWidget<T>(type: string, options?: T): TContainer;
-    build(): AXPLayoutNodeDefinition;
 }
-interface IFlexContainerBuilder extends IBaseContainerBuilder<IFlexContainerBuilder> {
+interface IFlexContainerBuilder extends IBaseContainerBuilder<IFlexContainerBuilder>, ILayoutContainerBuilder<IFlexContainerBuilder>, IChildContainerBuilder<IFlexContainerBuilder>, IWidgetContainerBuilder<IFlexContainerBuilder> {
     setOptions(options: AXPFlexContainerOptions): IFlexContainerBuilder;
-    setFlexDirection(direction: 'row' | 'column' | 'row-reverse' | 'column-reverse'): IFlexContainerBuilder;
-    setFlexWrap(wrap: 'nowrap' | 'wrap' | 'wrap-reverse'): IFlexContainerBuilder;
+    setDirection(direction: 'row' | 'column' | 'row-reverse' | 'column-reverse'): IFlexContainerBuilder;
+    setWrap(wrap: 'nowrap' | 'wrap' | 'wrap-reverse'): IFlexContainerBuilder;
     setJustifyContent(justify: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly'): IFlexContainerBuilder;
     setAlignItems(align: 'flex-start' | 'flex-end' | 'center' | 'baseline' | 'stretch'): IFlexContainerBuilder;
     setGap(gap: string): IFlexContainerBuilder;
@@ -369,7 +487,7 @@ interface IFlexContainerBuilder extends IBaseContainerBuilder<IFlexContainerBuil
     setPadding(padding: string): IFlexContainerBuilder;
     setMargin(margin: string): IFlexContainerBuilder;
 }
-interface IGridContainerBuilder extends IBaseContainerBuilder<IGridContainerBuilder> {
+interface IGridContainerBuilder extends IBaseContainerBuilder<IGridContainerBuilder>, ILayoutContainerBuilder<IGridContainerBuilder>, IChildContainerBuilder<IGridContainerBuilder>, IWidgetContainerBuilder<IGridContainerBuilder> {
     setOptions(options: AXPGridContainerOptions): IGridContainerBuilder;
     setColumns(columns: number): IGridContainerBuilder;
     setRows(rows: number): IGridContainerBuilder;
@@ -381,7 +499,7 @@ interface IGridContainerBuilder extends IBaseContainerBuilder<IGridContainerBuil
     setPadding(padding: string): IGridContainerBuilder;
     setMargin(margin: string): IGridContainerBuilder;
 }
-interface IPanelContainerBuilder extends IBaseContainerBuilder<IPanelContainerBuilder> {
+interface IPanelContainerBuilder extends IBaseContainerBuilder<IPanelContainerBuilder>, ILayoutContainerBuilder<IPanelContainerBuilder>, IChildContainerBuilder<IPanelContainerBuilder>, IWidgetContainerBuilder<IPanelContainerBuilder> {
     setOptions(options: AXPPanelContainerOptions): IPanelContainerBuilder;
     setCaption(caption: string): IPanelContainerBuilder;
     setIcon(icon: string): IPanelContainerBuilder;
@@ -389,7 +507,7 @@ interface IPanelContainerBuilder extends IBaseContainerBuilder<IPanelContainerBu
     setShowHeader(show: boolean): IPanelContainerBuilder;
     setCollapsed(collapsed: boolean): IPanelContainerBuilder;
 }
-interface IPageContainerBuilder extends IBaseContainerBuilder<IPageContainerBuilder> {
+interface IPageContainerBuilder extends IBaseContainerBuilder<IPageContainerBuilder>, ILayoutContainerBuilder<IPageContainerBuilder>, IChildContainerBuilder<IPageContainerBuilder>, IWidgetContainerBuilder<IPageContainerBuilder> {
     setOptions(options: AXPPageContainerOptions): IPageContainerBuilder;
     setBackgroundColor(color: string): IPageContainerBuilder;
     setTheme(theme: {
@@ -397,89 +515,192 @@ interface IPageContainerBuilder extends IBaseContainerBuilder<IPageContainerBuil
     }): IPageContainerBuilder;
     setHasHeader(hasHeader: boolean): IPageContainerBuilder;
     setHasFooter(hasFooter: boolean): IPageContainerBuilder;
-    setDirection(direction: string): IPageContainerBuilder;
+    setDirection(direction: 'rtl' | 'ltr'): IPageContainerBuilder;
 }
-interface ITabsetContainerBuilder extends IBaseContainerBuilder<ITabsetContainerBuilder> {
+interface ITabsetContainerBuilder extends IBaseContainerBuilder<ITabsetContainerBuilder>, ILayoutContainerBuilder<ITabsetContainerBuilder>, IChildContainerBuilder<ITabsetContainerBuilder>, IWidgetContainerBuilder<ITabsetContainerBuilder> {
     setOptions(options: AXPTabsetContainerOptions): ITabsetContainerBuilder;
     setLook(look: 'with-line' | 'with-line-color' | 'pills' | 'pills-color'): ITabsetContainerBuilder;
     setOrientation(orientation: 'vertical' | 'horizontal'): ITabsetContainerBuilder;
     setActiveIndex(index: number): ITabsetContainerBuilder;
 }
-
-declare class AXPLayoutRendererComponent implements OnInit {
-    builder?: AXPLayoutDefinition;
-    renderedNode: AXPWidgetNode;
-    ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPLayoutRendererComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AXPLayoutRendererComponent, "axp-layout-renderer", never, { "builder": { "alias": "builder"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-declare class LayoutBuilderModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutBuilderModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<LayoutBuilderModule, never, [typeof i1.CommonModule, typeof AXPLayoutRendererComponent], [typeof AXPLayoutRendererComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<LayoutBuilderModule>;
+interface IFormFieldBuilder extends IBaseContainerBuilder<IFormFieldBuilder>, ILayoutContainerBuilder<IFormFieldBuilder> {
+    setOptions(options: AXPFormFieldOptions): IFormFieldBuilder;
+    setLabel(label: string): IFormFieldBuilder;
+    setShowLabel(showLabel: boolean): IFormFieldBuilder;
+    textBox(options?: Omit<TextBoxOptions, 'path'>): IFormFieldBuilder;
+    largeTextBox(options?: Omit<LargeTextBoxOptions, 'path'>): IFormFieldBuilder;
+    richText(options?: Omit<RichTextOptions, 'path'>): IFormFieldBuilder;
+    passwordBox(options?: Omit<PasswordBoxOptions, 'path'>): IFormFieldBuilder;
+    numberBox(options?: Omit<NumberBoxOptions, 'path'>): IFormFieldBuilder;
+    selectBox(options: Omit<SelectBoxOptions, 'path'>): IFormFieldBuilder;
+    lookupBox(options: Omit<LookupBoxOptions, 'path'>): IFormFieldBuilder;
+    selectionList(options: Omit<SelectionListOptions, 'path'>): IFormFieldBuilder;
+    dateTimeBox(options?: Omit<DateTimeBoxOptions, 'path'>): IFormFieldBuilder;
+    toggleSwitch(options?: Omit<ToggleSwitchOptions, 'path'>): IFormFieldBuilder;
+    colorBox(options?: Omit<ColorBoxOptions, 'path'>): IFormFieldBuilder;
+    customWidget<T>(type: string, options?: Omit<T, 'path'>): IFormFieldBuilder;
+}
+interface IFieldsetContainerBuilder extends IBaseContainerBuilder<IFieldsetContainerBuilder>, ILayoutContainerBuilder<IFieldsetContainerBuilder> {
+    setOptions(options: AXPFieldsetContainerOptions): IFieldsetContainerBuilder;
+    setTitle(title: string): IFieldsetContainerBuilder;
+    setDescription(description: string): IFieldsetContainerBuilder;
+    setIcon(icon: string): IFieldsetContainerBuilder;
+    setCollapsible(collapsible: boolean): IFieldsetContainerBuilder;
+    setIsOpen(isOpen: boolean): IFieldsetContainerBuilder;
+    setLook(look: 'fieldset' | 'card' | 'group'): IFieldsetContainerBuilder;
+    setShowHeader(showHeader: boolean): IFieldsetContainerBuilder;
+    setCols(cols: number): IFieldsetContainerBuilder;
+    formField(label: string, delegate?: (field: IFormFieldBuilder) => void): IFieldsetContainerBuilder;
+}
+interface IDialogBuilder {
+    setOptions(options: AXPDialogContainerOptions): IDialogBuilder;
+    setTitle(title: string): IDialogBuilder;
+    setMessage(message?: string): IDialogBuilder;
+    setSize(size: AXPopupSizeType): IDialogBuilder;
+    setCloseButton(closeButton: boolean): IDialogBuilder;
+    setContext(context: any): IDialogBuilder;
+    content(delegate: (layoutBuilder: IFlexContainerBuilder) => void): IDialogBuilder;
+    setActions(delegate?: (actions: IActionBuilder) => void): IDialogBuilder;
+    show(): Promise<AXPDialogRef>;
+}
+interface IListWidgetBuilder extends IBaseContainerBuilder<IListWidgetBuilder>, ILayoutContainerBuilder<IListWidgetBuilder>, IChildContainerBuilder<IListWidgetBuilder>, IWidgetContainerBuilder<IListWidgetBuilder> {
+    setOptions(options: AXPListWidgetOptions): IListWidgetBuilder;
+    setDataSource(dataSource: any[] | AXDataSource): IListWidgetBuilder;
+    setColumns(columns: AXPListWidgetColumn[]): IListWidgetBuilder;
+    setOnRowClick(handler: (row: any) => void): IListWidgetBuilder;
+    setOnRowDoubleClick(handler: (row: any) => void): IListWidgetBuilder;
+    setOnSelectionChange(handler: (selectedRows: any[]) => void): IListWidgetBuilder;
+    setOnRowCommand(handler: (command: any, selectedRows: any[]) => void): IListWidgetBuilder;
+    setPaging(paging: boolean): IListWidgetBuilder;
+    setShowHeader(show: boolean): IListWidgetBuilder;
+    setShowFooter(show: boolean): IListWidgetBuilder;
+    setFixHeader(fix: boolean): IListWidgetBuilder;
+    setFixFooter(fix: boolean): IListWidgetBuilder;
+    setFetchDataMode(mode: 'auto' | 'manual'): IListWidgetBuilder;
+    setParentField(field: string): IListWidgetBuilder;
+    setMinHeight(height: string | number): IListWidgetBuilder;
+    setShowIndex(show: boolean): IListWidgetBuilder;
+    setAllowSelection(allow: boolean): IListWidgetBuilder;
+    setPrimaryCommands(commands: any[]): IListWidgetBuilder;
+    setSecondaryCommands(commands: AXPListWidgetRowCommand[]): IListWidgetBuilder;
+    setLoading(loading: {
+        enabled?: boolean;
+        animation?: boolean;
+    }): IListWidgetBuilder;
 }
 
 declare class AXPLayoutBuilderService {
+    private popupService;
     /**
      * Create a new layout builder
      */
     create(): ILayoutBuilder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPLayoutBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPLayoutBuilderService>;
+}
+
+declare class AXPLayoutConversionService {
+    private widgetTreeCache;
+    private formDefinitionCache;
     /**
-     * Convert Layout Builder definition to Layout Renderer format
-     * با processing و cleaning options
+     * Convert AXPDynamicFormDefinition to AXPWidgetNode tree structure
+     * Groups become Fieldset Layouts with Form Field widgets as children
+     * Fields become Form Field widgets with Editor widgets as children
      */
-    convertToLayoutRenderer(definition: AXPLayoutDefinition): {
-        layoutDefinition: LayoutDefinition;
-        layoutNodes: LayoutNode[];
-    };
+    convertFormDefinition(formDefinition: AXPDynamicFormDefinition): AXPWidgetNode;
     /**
-     * Convert grid layout options to CSS styles
+     * Convert AXPWidgetNode tree back to AXPDynamicFormDefinition
+     * Parses Fieldset Layouts back to Groups
+     * Parses Form Field widgets back to Fields
      */
-    private convertGridLayoutToStyles;
+    convertWidgetTreeToFormDefinition(widgetTree: AXPWidgetNode): AXPDynamicFormDefinition;
     /**
-     * Convert grid layout to node layout configuration
+     * Validate that a widget tree represents a valid dynamic form structure
      */
-    private convertToNodeLayout;
+    validateFormWidgetTree(widgetTree: AXPWidgetNode): boolean;
     /**
-     * Process widget options based on actual widget configurations
+     * Clear all caches
      */
-    private processWidgetOptions;
+    clearCaches(): void;
     /**
-     * Process text-block-layout content
+     * Get cache statistics
      */
-    private processTextBlockContent;
+    getCacheStats(): {
+        widgetTreeCacheSize: number;
+        formDefinitionCacheSize: number;
+    };
     /**
-     * Process grid-layout options
+     * Convert a single group to Fieldset widget structure
      */
-    private processGridOptions;
+    private createGroupAsFieldsetWidget;
     /**
-     * Process spacing options
+     * Convert fields to Form Field widgets
      */
-    private processSpacingOptions;
+    private createFieldWidgets;
     /**
-     * Process border options
+     * Convert a single field to Form Field widget with editor as child
      */
-    private processBorderOptions;
+    private createFormFieldWidget;
     /**
-     * Process flex-layout options
+     * Extract group information from Fieldset Layout widget
      */
-    private processFlexOptions;
+    private extractGroupFromFieldset;
     /**
-     * Process panel-layout options
+     * Extract field information from Form Field widget
      */
-    private processPanelOptions;
+    private extractFieldFromFormWidget;
     /**
-     * Process tag content
+     * Create cache key for form definition
      */
-    private processTagContent;
+    private createFormDefinitionCacheKey;
     /**
-     * Process generic content
+     * Create cache key for widget tree
      */
-    private processGenericContent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPLayoutBuilderService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPLayoutBuilderService>;
+    private createWidgetTreeCacheKey;
+    /**
+     * Create a simple hash from a string
+     */
+    private createSimpleHash;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPLayoutConversionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPLayoutConversionService>;
+}
+
+interface DialogRendererConfig {
+    title: string;
+    message?: string;
+    context: any;
+    definition: AXPWidgetNode;
+    actions?: {
+        footer?: {
+            prefix?: any[];
+            suffix?: any[];
+        };
+    };
+}
+interface DialogRendererResult {
+    context: any;
+    action?: string;
+}
+declare class AXPDialogRendererComponent extends AXBasePageComponent implements OnInit {
+    config: DialogRendererConfig;
+    result: EventEmitter<DialogRendererResult>;
+    private dialogResult?;
+    context: i0.WritableSignal<any>;
+    callBack: (dialogRef: AXPDialogRef) => void;
+    data: any;
+    private isDialogLoading;
+    ngOnInit(): void;
+    handleContextChanged(event: any): void;
+    handleContextInitiated(event: any): void;
+    visibleFooterPrefixActions(): any[];
+    visibleFooterSuffixActions(): any[];
+    isFormLoading(): boolean;
+    isSubmitting(): boolean;
+    executeAction(action: any): Promise<void>;
+    close(result?: DialogRendererResult): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDialogRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPDialogRendererComponent, "axp-dialog-renderer", never, { "config": { "alias": "config"; "required": false; }; }, { "result": "result"; }, never, never, true, never>;
 }
 
-export { AXPLayoutBuilderService, AXPLayoutRendererComponent, LayoutBuilderModule };
-export type { AXPFlexContainerOptions, AXPGridContainerOptions, AXPLayoutDefinition, AXPLayoutDirection, AXPLayoutLook, AXPLayoutMode, AXPLayoutNodeDefinition, AXPPageContainerOptions, AXPPanelContainerOptions, AXPTabsetContainerOptions, AXPWidgetConfiguration, ColorBoxOptions, ContainerConfig, DateTimeBoxOptions, IBaseContainerBuilder, IFlexContainerBuilder, IGridContainerBuilder, ILayoutBuilder, IPageContainerBuilder, IPanelContainerBuilder, ITabsetContainerBuilder, IWidgetBuilder, LargeTextBoxOptions, LayoutBuilderState, LayoutDefinition, LayoutNode, LayoutRenderContext, LayoutTypeConfig, LookupBoxOptions, NodeLayoutConfig, NumberBoxOptions, PasswordBoxOptions, ResponsiveConfig, RichTextOptions, SelectBoxOptions, SelectionListOptions, TextBoxOptions, ToggleSwitchOptions, WidgetBuilderState, ZoneConfig };
+export { AXPDialogRendererComponent, AXPLayoutBuilderService, AXPLayoutConversionService, AXPLayoutRendererComponent, LayoutBuilderModule };
+export type { AXPDialogContainerOptions, AXPFieldsetContainerOptions, AXPFlexContainerOptions, AXPFormFieldOptions, AXPGridContainerOptions, AXPListWidgetColumn, AXPListWidgetOptions, AXPListWidgetRowCommand, AXPPageContainerOptions, AXPPanelContainerOptions, AXPTabsetContainerOptions, AXPWidgetConfiguration, ColorBoxOptions, DateTimeBoxOptions, DialogBuilderState, DialogRendererConfig, DialogRendererResult, FormFieldBuilderState, IActionBuilder, IBaseContainerBuilder, IChildContainerBuilder, IDialogBuilder, IFieldsetContainerBuilder, IFlexContainerBuilder, IFormFieldBuilder, IGridContainerBuilder, ILayoutBuilder, ILayoutContainerBuilder, IListWidgetBuilder, IPageContainerBuilder, IPanelContainerBuilder, ITabsetContainerBuilder, IWidgetBuilder, IWidgetContainerBuilder, InheritanceContext, InheritedProperties, LargeTextBoxOptions, LayoutBuilderState, LayoutWidgetOptions, LookupBoxOptions, NumberBoxOptions, PasswordBoxOptions, RichTextOptions, SelectBoxOptions, SelectionListOptions, TextBoxOptions, ToggleSwitchOptions, ValueWidgetOptions, WidgetBuilderState };