@acorex/platform 20.3.0-next.9 → 20.4.1

package/layout/builder/index.d.ts

@@ -1,908 +1,775 @@
-import * as _angular_core from '@angular/core';
-import { Signal, InjectionToken, ComponentRef, OnInit, EventEmitter, TemplateRef, Injector, WritableSignal, SimpleChanges, ModuleWithProviders } from '@angular/core';
-import * as _acorex_platform_core from '@acorex/platform/core';
-import { AXPDataType, AXPOptionsData, AXPValidationRules, AXPWidgetTriggers, AXPMetaData, AXPValueTransformerFunctions, AXPPartialNested, AXPExpressionEvaluatorService } from '@acorex/platform/core';
-import * as _ngrx_signals from '@ngrx/signals';
-import * as _acorex_platform_layout_builder from '@acorex/platform/layout/builder';
-import { AXValueChangedEvent, AXDataSource } from '@acorex/cdk/common';
-import { Subject, BehaviorSubject } from 'rxjs';
-import { AXDataTableColumnComponent } from '@acorex/components/data-table';
-import * as i7 from '@acorex/core/translation';
-import { AXTranslationService } from '@acorex/core/translation';
-import { AXUnsubscriber } from '@acorex/core/utils';
-import * as i4 from '@angular/common';
-import * as i5 from '@angular/cdk/portal';
-import * as i6 from '@acorex/components/skeleton';
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter } from '@angular/core';
+import * as i1 from '@angular/common';
+import { AXFormComponent } from '@acorex/components/form';
+import { AXValidationSummary } from '@acorex/core/validation';
+import { AXPWidgetNode, AXPWidgetRenderMode, AXPWidgetCoreContextChangeEvent, AXPWidgetContainerComponent } from '@acorex/platform/layout/widget-core';
+import { AXDataSource } from '@acorex/cdk/common';
+import { AXPopupSizeType } from '@acorex/components/popup';
+import { AXPGridLayoutOptions, AXPExpression, AXPValidationRules, AXPActionMenuItem, AXPOptionsData } from '@acorex/platform/core';
+import { AXBasePageComponent } from '@acorex/components/page';
 
-declare enum AXPPageStatus {
-    Idle = "idle",// The page is idle.
-    Rendering = "rendering",// The page is being rendered.
-    Rendered = "rendered",// The rendering process is complete. should be renamed to idle
-    Processing = "processing",// The page is performing a task or interaction.
-    Submitting = "submitting",// The form is being submitted.
-    Submitted = "submitted",// Submission is completed.
-    Validating = "validating",// The form is being validated.
-    Validated = "validated",// Validation is completed.  
-    Error = "error"
-}
-declare enum AXPWidgetStatus {
-    Rendering = "rendering",// The widget is being rendered.
-    Rendered = "rendered",// The rendering process is complete.
-    Processing = "processing",// The widget is performing a task or interaction.
-    Error = "error"
-}
-
-type AXPLayoutElementAPI = {
-    [name: string]: Subject<any> | Function;
-};
-declare abstract class AXPLayoutElement {
-    abstract get id(): string | null;
-    abstract get status(): Signal<AXPWidgetStatus>;
-    api(): AXPLayoutElementAPI;
-}
-declare class AXPLayoutBuilderService {
-    private readonly variables$;
-    private readonly functions$;
-    readonly onRefresh: Subject<void>;
-    private widgets;
-    private readonly onWidgetRegistered;
-    private readonly status$;
-    readonly status: Signal<AXPPageStatus>;
-    readonly isBusy: Signal<boolean>;
-    get variables(): any;
-    get functions(): {
-        [key: string]: Function;
-    };
-    updateStatus(): void;
-    private detectStatus;
-    refresh(): void;
-    setStatus(status: AXPPageStatus): void;
-    setVariables(keysValues: any): void;
-    setVariables(key: string, value: any): void;
-    setFunctions(keysValues: any): void;
-    setFunctions(key: string, value: any): void;
-    registerWidget(id: string, widget: AXPLayoutElement): void;
-    getWidget(id: string): AXPLayoutElement | undefined;
-    /**
-     * Waits until a widget with the given id is registered, then resolves with it.
-     * If the widget is already registered, resolves immediately.
-     * Optionally accepts a timeout (in ms) after which it resolves with undefined.
-     */
-    waitForWidget(id: string, timeoutMs?: number): Promise<AXPLayoutElement | undefined>;
-    ngOnDestroy(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLayoutBuilderService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPLayoutBuilderService>;
+/**
+ * Form appearance and density styling (using fieldset widget look)
+ */
+type AXPDynamicFormLook = 'fieldset' | 'card' | 'group' | 'container';
+/**
+ * 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;
+    layout?: AXPGridLayoutOptions;
 }
-
-interface AXPWidgetCategory {
+interface AXPDynamicFormGroupDefinition {
     name: string;
-    title: string;
-    order: number;
+    title?: string;
+    description?: string;
+    parameters: AXPDynamicFormFieldDefinition[];
+    /**
+     * Optional per-section rendering mode. Takes precedence over form mode and is overridden by field mode.
+     */
+    mode?: AXPDynamicFormMode;
 }
-declare const AXP_WIDGETS_LAYOUT_CATEGORY: AXPWidgetCategory;
-declare const AXP_WIDGETS_EDITOR_CATEGORY: AXPWidgetCategory;
-declare const AXP_WIDGETS_ACTION_CATEGORY: AXPWidgetCategory;
-declare const AXP_WIDGETS_ADVANCE_CATEGORY: AXPWidgetCategory;
-declare const AXP_WIDGETS_CATEGORIES: AXPWidgetCategory[];
-
-type AXPWidgetGroup = 'form-element' | 'dashboard-widget' | 'form-template' | 'property-editor' | 'meta-data' | 'setting-widget' | 'entity-widget';
-declare enum AXPWidgetGroupEnum {
-    FormElement = "form-element",
-    DashboardWidget = "dashboard-widget",
-    FormTemplate = "form-template",
-    PropertyEditor = "property-editor",
-    MetaData = "meta-data",
-    SettingWidget = "setting-widget",
-    EntityWidget = "entity-widget"
+interface AXPDynamicFormDefinition {
+    groups: AXPDynamicFormGroupDefinition[];
+    /**
+     * Optional form-level rendering mode
+     */
+    mode?: AXPDynamicFormMode;
 }
-
-interface AXPWidgetTypesMap {
-    timeDuration: 'time-duration';
-    checkbox: 'checkbox-editor';
-    color: 'color-editor';
-    contact: 'contact-editor';
-    dateTime: 'date-time-editor';
-    largeText: 'large-text-editor';
-    number: 'number-editor';
-    numberUnit: 'number-unit-editor';
-    password: 'password-editor';
-    richText: 'rich-text-editor';
-    select: 'select-editor';
-    selectionList: 'selection-list-editor';
-    text: 'text-editor';
-    table: 'table-editor';
-    toggle: 'toggle-editor';
-    blockLayout: 'block-layout';
-    pageLayout: 'page-layout';
-    repeaterLayout: 'repeater-layout';
-    textBlockLayout: 'text-block-layout';
-    fileUploader: 'file-uploader';
-    fileTypeExtension: 'file-type-extension';
-    map: 'map';
-    imageMarker: 'image-marker';
-    image: 'image';
-    gallery: 'gallery';
-    signature: 'signature';
-    buttonAction: 'button-action';
-    document: 'document-layout';
-    lookup: 'lookup-editor';
-    formField: 'form-field';
-    advancedGrid: 'advanced-grid-layout';
-    advancedGridItem: 'advanced-grid-item-layout';
-    grid: 'grid-layout';
-    gridItem: 'grid-item-layout';
-    qrcode: 'qrcode';
-    widgetSelector: 'widget-selector';
-    template: 'template';
-    templateDesigner: 'template-designer';
-    cronJob: 'cron-job';
-    spacing: 'spacing';
-    border: 'border';
-    direction: 'direction';
-    flexLayout: 'flex-layout';
-    flexItem: 'flex-item-layout';
-    tableLayout: 'table-layout';
-    tableItem: 'table-item-layout';
-    avatar: 'avatar';
-    stringFilter: 'string-filter';
-    numberFilter: 'number-filter';
-    dateTimeFilter: 'datetime-filter';
-    booleanFilter: 'boolean-filter';
-    lookupFilter: 'lookup-filter';
-    flexOptions: 'flex-options';
-    flexItemOptions: 'flex-item-options';
-    gridOptions: 'grid-options';
-    gridItemOptions: 'grid-item-options';
-    advancedGridOptions: 'advanced-grid-options';
-    selectFilter: 'select-filter';
-    requiredValidation: 'required-validation';
-    regularExpressionValidation: 'regular-expression-validation';
-    minLengthValidation: 'min-length-validation';
-    maxLengthValidation: 'max-length-validation';
-    lessThanValidation: 'less-than-validation';
-    greaterThanValidation: 'greater-than-validation';
-    betweenValidation: 'between-validation';
-    equalValidation: 'equal-validation';
-    callbackValidation: 'callback-validation';
-    donutChart: 'donut-chart';
-    barChart: 'bar-chart';
-    lineChart: 'line-chart';
-    gaugeChart: 'gauge-chart';
-    stickyNote: 'sticky-note';
-    clockCalendar: 'clock-calendar';
-    analogClock: 'analog-clock';
-    weather: 'weather';
-    minimalWeather: 'minimal-weather';
-    advancedWeather: 'advanced-weather';
-    metaData: 'meta-data-editor';
-    tagable: 'tagable-editor';
-    templateEditor: 'template-box-editor';
-    themePaletteChooser: 'theme-palette-chooser';
-    themeModeChooser: 'theme-mode-chooser';
-    menuOrientationChooser: 'menu-orientation-chooser';
-    fontStyleChooser: 'font-style-chooser';
-    fontSizeChooser: 'font-size-chooser';
-    iconChooser: 'icon-chooser';
-    themeColorChooser: 'theme-color-chooser';
-    panel: 'panel';
-    notification: 'notification';
-    taskBoard: 'task-board';
-    comment: 'comment';
-    list: 'list';
-    listToolbar: 'list-toolbar';
-    entityList: 'entity-list';
-    documentUploader: 'document-uploader';
+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;
 }
-
-interface AXPWidgetPropertyGroup {
-    name: string;
-    title: string;
-    order: number;
+interface LayoutWidgetOptions {
+    name?: string;
 }
-interface AXPWidgetProperty {
-    name: string;
-    title: string;
-    description?: string;
-    group: AXPWidgetPropertyGroup;
-    order?: number;
-    schema: {
-        dataType: AXPDataType;
-        nullable?: boolean;
-        defaultValue?: any | string | ((context: any | null) => any);
-        interface: Required<Pick<AXPWidgetNode, 'path'>> & Omit<AXPWidgetNode, 'path'>;
-    };
-    options?: AXPOptionsData;
+interface ValueWidgetOptions extends LayoutWidgetOptions {
+    path: string;
+    defaultValue?: any;
     validations?: AXPValidationRules;
-    visible: boolean;
 }
-declare function cloneProperty(property: AXPWidgetProperty, values: AXPPartialNested<AXPWidgetProperty>): AXPWidgetProperty;
-declare function createStringProperty(ctor: {
-    defaultValue?: string;
-    name: string;
-    title: string;
-    path?: string;
-    group: AXPWidgetPropertyGroup;
-    visible?: boolean;
-}): AXPWidgetProperty;
-declare function createNumberProperty(ctor: {
-    defaultValue?: number;
-    name: string;
-    title: string;
-    path?: string;
-    group: AXPWidgetPropertyGroup;
-    visible?: boolean;
-    options?: {
-        minValue?: number;
-        maxValue?: number;
-        decimals?: number;
+interface TextBoxOptions extends ValueWidgetOptions {
+    placeholder?: string;
+    maxLength?: number;
+    minLength?: number;
+    prefix?: string;
+    suffix?: string;
+    clearButton?: boolean;
+}
+interface NumberBoxOptions extends ValueWidgetOptions {
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: string;
+    format?: string;
+}
+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 extends ValueWidgetOptions {
+    type?: 'date' | 'time' | 'datetime';
+    format?: string;
+    min?: Date | string;
+    max?: Date | string;
+    placeholder?: string;
+    clearButton?: boolean;
+}
+interface ToggleSwitchOptions extends ValueWidgetOptions {
+    label?: string;
+    trueText?: string;
+    falseText?: string;
+}
+interface LargeTextBoxOptions extends ValueWidgetOptions {
+    rows?: number;
+    maxLength?: number;
+    minLength?: number;
+    placeholder?: string;
+    resizable?: boolean;
+}
+interface ColorBoxOptions extends ValueWidgetOptions {
+    format?: 'hex' | 'rgb' | 'hsl';
+    showAlpha?: boolean;
+    showPalette?: boolean;
+}
+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';
+    alignItems?: 'flex-start' | 'flex-end' | 'center' | 'baseline' | 'stretch';
+    gap?: string;
+    spacing?: {
+        padding?: string;
+        margin?: string;
     };
-}): AXPWidgetProperty;
-declare function createBooleanProperty(ctor: {
-    defaultValue?: boolean;
-    name: string;
-    title: string;
-    path?: string;
-    group: AXPWidgetPropertyGroup;
-    visible?: boolean;
-}): AXPWidgetProperty;
-declare function createSelectProperty<T = string | {
-    id: string;
-    title: string;
-}>(ctor: {
-    defaultValue: T | T[] | any;
-    dataSource: T[];
+    border?: {
+        radius?: string;
+        width?: string;
+        color?: string;
+        style?: string;
+    };
+    backgroundColor?: string;
+    direction?: string;
+    overflow?: string;
+    overflowX?: string;
+    overflowY?: string;
+    width?: string;
+    minWidth?: string;
+    maxWidth?: string;
+    height?: string;
+    minHeight?: string;
+    maxHeight?: string;
+}
+interface AXPGridContainerOptions extends LayoutWidgetOptions {
+    grid?: {
+        default?: {
+            columns?: number;
+            rows?: number;
+            gap?: string;
+            justifyItems?: string;
+            alignItems?: string;
+            autoFlow?: string;
+        };
+    };
+    spacing?: {
+        padding?: string;
+        margin?: string;
+    };
+    border?: {
+        radius?: string;
+        width?: string;
+        color?: string;
+        style?: string;
+    };
+    backgroundColor?: string;
+    direction?: string;
+    overflow?: string;
+    overflowX?: string;
+    overflowY?: string;
+    width?: string;
+    minWidth?: string;
+    maxWidth?: string;
+    height?: string;
+    minHeight?: string;
+    maxHeight?: string;
+}
+interface AXPPanelContainerOptions extends LayoutWidgetOptions {
+    caption?: string;
+    icon?: string;
+    look?: 'solid' | 'fill' | 'outline' | 'flat' | 'none';
+    disabled?: boolean;
+    showHeader?: boolean;
+    collapsed?: boolean;
+}
+interface AXPPageContainerOptions extends LayoutWidgetOptions {
+    backgroundColor?: string;
+    theme?: {
+        id: string;
+    };
+    hasHeader?: boolean;
+    hasFooter?: boolean;
+    direction?: string;
+}
+interface AXPTabsetContainerOptions extends LayoutWidgetOptions {
+    look?: 'with-line' | 'with-line-color' | 'pills' | 'pills-color';
+    orientation?: 'vertical' | 'horizontal';
+    activeIndex?: number;
+}
+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 extends ValueWidgetOptions {
+    placeholder?: string;
+    revealToggle?: boolean;
+    maxLength?: number;
+}
+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 extends ValueWidgetOptions {
+    dataSource: any[] | (() => any[]) | (() => Promise<any[]>) | AXDataSource<any>;
+    valueField?: string;
+    textField?: string;
+    multiple?: boolean;
+    searchable?: boolean;
+    placeholder?: string;
+}
+interface AXPListWidgetColumn {
     name: string;
-    title: string;
-    path?: string;
-    group: AXPWidgetPropertyGroup;
+    title?: string;
     visible?: boolean;
-}): AXPWidgetProperty;
-interface AXPWidgetNode {
-    type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | keyof AXPWidgetTypesMap | string;
+    width?: string;
+    widget?: {
+        type: string;
+        path?: string;
+        options?: any;
+    };
+}
+interface AXPListWidgetRowCommand {
+    title?: string;
+    icon?: string;
+    color?: string;
+    disabled?: 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 InheritanceContext {
     mode?: AXPWidgetRenderMode;
-    path?: string;
-    name?: string;
-    defaultValue?: any;
-    formula?: string;
-    children?: AXPWidgetNode[];
-    options?: AXPOptionsData;
-    triggers?: AXPWidgetTriggers;
-    meta?: AXPMetaData;
-    valueTransforms?: AXPValueTransformerFunctions;
+    disabled?: boolean | string;
+    readonly?: boolean | string;
+    direction?: 'rtl' | 'ltr';
+    visible?: boolean | string;
 }
-interface AXPWidgetNodeToken {
-    defaultValue?: any;
-    config: AXPWidgetConfig;
-    node: AXPWidgetNode;
-    options?: AXPOptionsData;
+interface InheritedProperties {
+    mode: AXPWidgetRenderMode;
+    disabled: boolean | string | undefined;
+    readonly: boolean | string | undefined;
+    direction: 'rtl' | 'ltr' | undefined;
+    visible: boolean | string | undefined;
 }
-interface AXPWidgetColumnNode {
+interface AXPWidgetConfiguration {
     type: string;
-    path: string;
     options?: AXPOptionsData;
 }
-interface AXPWidgetColumnNodeToken extends AXPWidgetColumnNode {
-    config: AXPWidgetConfig;
-}
-declare const AXP_WIDGET_TOKEN: InjectionToken<AXPWidgetNodeToken>;
-declare const AXP_WIDGET_COLUMN_TOKEN: InjectionToken<AXPWidgetColumnNodeToken>;
-interface AXPWidgetComponentConfig {
-    component: () => Promise<any>;
-    properties?: AXPWidgetProperty[];
-}
-interface AXPWidgetConfigComponents {
-    designer?: AXPWidgetComponentConfig;
-    view?: AXPWidgetComponentConfig;
-    edit?: AXPWidgetComponentConfig;
-    print?: AXPWidgetComponentConfig;
-    column?: AXPWidgetComponentConfig;
-    filter?: AXPWidgetComponentConfig;
-}
-type AXPWidgetViewType = 'container' | 'editor' | 'action' | 'view' | 'filter' | 'validation' | 'dashboard';
-type AXPWidgetDesignerOptionsMap = {
-    container: {
-        canInsert: boolean;
-    };
-    editor: {
-        needLabel: boolean;
-    };
-    action: {};
-    view: {};
+type LayoutBuilderState = AXPWidgetNode;
+type WidgetBuilderState = Omit<AXPWidgetNode, 'children'> & {
+    layout?: AXPGridLayoutOptions;
 };
-type AXPExtractWidgetConfig<T> = {
-    type: AXPWidgetViewType;
-    designer: T extends {
-        type: infer V;
-    } ? V extends keyof AXPWidgetDesignerOptionsMap ? AXPWidgetDesignerOptionsMap[V] : any : any;
+type FormFieldBuilderState = AXPWidgetNode & {
+    layout?: AXPGridLayoutOptions;
 };
-interface AXPWidgetConfig<T = any> {
-    name: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | keyof AXPWidgetTypesMap | string;
-    alias?: string | string[];
-    title: string;
-    icon?: string;
-    description?: string;
-    categories?: AXPWidgetCategory | AXPWidgetCategory[];
-    groups?: AXPWidgetGroup[];
-    properties?: AXPWidgetProperty[];
-    components: AXPWidgetConfigComponents;
-    meta?: AXPMetaData;
-    type: AXPExtractWidgetConfig<T>['type'];
-    designer?: AXPExtractWidgetConfig<T>['designer'];
-    options?: Record<string, any>;
-    defaultFilterWidgetName?: 'string-filter' | 'number-filter' | 'datetime-filter' | 'boolean-filter' | 'select-filter' | 'lookup-filter';
-}
-interface extendedWidget {
-    widget: AXPWidgetConfig;
-    parentName: string;
-}
-type AXPWidgetRenderMode = keyof AXPWidgetConfigComponents;
-interface AXPLayoutBuilderStatusChangedEvent {
-    status: AXPPageStatus;
+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 {
+    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;
+    fieldset(delegate: (container: IFieldsetContainerBuilder) => void): ILayoutBuilder;
+    dialog(delegate: (container: IDialogBuilder) => void): IDialogBuilder;
+    build(): AXPWidgetNode;
+}
+interface 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: AXPWidgetRenderMode): IWidgetBuilder;
+    visible(condition: boolean | string): IWidgetBuilder;
+    disabled(condition: boolean | string): IWidgetBuilder;
+    readonly(condition: boolean | string): IWidgetBuilder;
+    direction(direction: 'rtl' | 'ltr'): IWidgetBuilder;
+    withInheritanceContext(context: InheritanceContext): IWidgetBuilder;
+    getInheritanceContext(): InheritanceContext;
+    build(): AXPWidgetNode;
+}
+interface IBaseContainerBuilder<TContainer = any> {
+    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;
+}
+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;
+    passwordBox(options?: PasswordBoxOptions): TContainer;
+    numberBox(options?: NumberBoxOptions): TContainer;
+    selectBox(options: SelectBoxOptions): TContainer;
+    lookupBox(options: LookupBoxOptions): TContainer;
+    selectionList(options: SelectionListOptions): TContainer;
+    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;
+}
+interface IFlexContainerBuilder extends IBaseContainerBuilder<IFlexContainerBuilder>, ILayoutContainerBuilder<IFlexContainerBuilder>, IChildContainerBuilder<IFlexContainerBuilder>, IWidgetContainerBuilder<IFlexContainerBuilder> {
+    setOptions(options: AXPFlexContainerOptions): 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;
+    setBackgroundColor(color: string): IFlexContainerBuilder;
+    setPadding(padding: string): IFlexContainerBuilder;
+    setMargin(margin: string): IFlexContainerBuilder;
+}
+interface IGridContainerBuilder extends IBaseContainerBuilder<IGridContainerBuilder>, ILayoutContainerBuilder<IGridContainerBuilder>, IChildContainerBuilder<IGridContainerBuilder>, IWidgetContainerBuilder<IGridContainerBuilder> {
+    setOptions(options: AXPGridContainerOptions): IGridContainerBuilder;
+    setColumns(columns: number): IGridContainerBuilder;
+    setRows(rows: number): IGridContainerBuilder;
+    setGap(gap: string): IGridContainerBuilder;
+    setJustifyItems(justify: 'start' | 'end' | 'center' | 'stretch'): IGridContainerBuilder;
+    setAlignItems(align: 'start' | 'end' | 'center' | 'stretch'): IGridContainerBuilder;
+    setAutoFlow(flow: 'row' | 'column' | 'row dense' | 'column dense'): IGridContainerBuilder;
+    setBackgroundColor(color: string): IGridContainerBuilder;
+    setPadding(padding: string): IGridContainerBuilder;
+    setMargin(margin: string): IGridContainerBuilder;
+}
+interface IPanelContainerBuilder extends IBaseContainerBuilder<IPanelContainerBuilder>, ILayoutContainerBuilder<IPanelContainerBuilder>, IChildContainerBuilder<IPanelContainerBuilder>, IWidgetContainerBuilder<IPanelContainerBuilder> {
+    setOptions(options: AXPPanelContainerOptions): IPanelContainerBuilder;
+    setCaption(caption: string): IPanelContainerBuilder;
+    setIcon(icon: string): IPanelContainerBuilder;
+    setLook(look: 'solid' | 'fill' | 'outline' | 'flat' | 'none'): IPanelContainerBuilder;
+    setShowHeader(show: boolean): IPanelContainerBuilder;
+    setCollapsed(collapsed: boolean): IPanelContainerBuilder;
+}
+interface IPageContainerBuilder extends IBaseContainerBuilder<IPageContainerBuilder>, ILayoutContainerBuilder<IPageContainerBuilder>, IChildContainerBuilder<IPageContainerBuilder>, IWidgetContainerBuilder<IPageContainerBuilder> {
+    setOptions(options: AXPPageContainerOptions): IPageContainerBuilder;
+    setBackgroundColor(color: string): IPageContainerBuilder;
+    setTheme(theme: {
+        id: string;
+    }): IPageContainerBuilder;
+    setHasHeader(hasHeader: boolean): IPageContainerBuilder;
+    setHasFooter(hasFooter: boolean): IPageContainerBuilder;
+    setDirection(direction: 'rtl' | 'ltr'): IPageContainerBuilder;
+}
+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;
+}
+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;
 }
 
-type AXPClassMap = Readonly<Record<string, boolean>>;
-type AXPStyleMap = Readonly<Record<string, string | number>>;
-declare abstract class AXPBaseWidgetComponent extends AXPLayoutElement {
+declare class AXPLayoutRendererComponent implements OnInit {
     #private;
-    protected readonly token: _acorex_platform_layout_builder.AXPWidgetNodeToken;
-    readonly host: HTMLDivElement;
-    protected readonly layoutService: AXPLayoutBuilderService;
-    protected readonly contextService: {
-        data: _angular_core.Signal<{}>;
-        state: _angular_core.Signal<_acorex_platform_layout_builder.AXPLayoutContextState>;
-        initialSnapshot: _angular_core.Signal<{}>;
-        previousSnapshot: _angular_core.Signal<{}>;
-        lastChange: _ngrx_signals.DeepSignal<_acorex_platform_layout_builder.AXPLayoutContextChangeEvent>;
-        isChanged: _angular_core.Signal<boolean>;
-        isReset: _angular_core.Signal<boolean>;
-        isInitiated: _angular_core.Signal<boolean>;
-        isEmpty: _angular_core.Signal<boolean>;
-        isDirty: _angular_core.Signal<boolean>;
-        snapshot: _angular_core.Signal<{}>;
-        initial: _angular_core.Signal<{}>;
-        previous: _angular_core.Signal<{}>;
-        changeEvent: _angular_core.Signal<_acorex_platform_layout_builder.AXPLayoutContextChangeEvent>;
-        update: (path: string, value: any) => void;
-        patch: (context: {}) => void;
-        reset: () => void;
-        set: (initialData: any) => void;
-        getValue: (path: string) => any;
-    } & _ngrx_signals.StateSource<{
-        data: {};
-        state: _acorex_platform_layout_builder.AXPLayoutContextState;
-        initialSnapshot: {};
-        previousSnapshot: {};
-        lastChange: _acorex_platform_layout_builder.AXPLayoutContextChangeEvent;
-    }>;
-    readonly config: _acorex_platform_layout_builder.AXPWidgetConfig<any>;
-    readonly node: AXPWidgetNode;
-    protected readonly name: string | undefined;
-    protected component: this;
-    protected _id: string | null;
-    get id(): string | null;
-    protected _options: _angular_core.WritableSignal<_acorex_platform_core.AXPOptionsData>;
-    options: _angular_core.Signal<_acorex_platform_core.AXPOptionsData>;
-    onOptionsChanged: Subject<{
-        sender: AXPBaseWidgetComponent;
-    }>;
-    private _status;
-    status: _angular_core.Signal<AXPWidgetStatus>;
-    readonly onStatusChanged: BehaviorSubject<AXPWidgetStatus>;
-    isBusy: _angular_core.Signal<boolean>;
-    parent: AXPLayoutBaseWidgetComponent | null | undefined;
-    parentComponent: ComponentRef<any> | null | undefined;
-    parentElement: HTMLElement | null | undefined;
-    index: number | null | undefined;
-    mode: AXPWidgetRenderMode;
-    locked: boolean;
-    protected outputs(): (string | {
-        [name: string]: unknown;
-    })[];
-    ngOnInit(): void;
-    setStatus(status: AXPWidgetStatus): void;
-    setOptions(values: any): void;
-    output<T = any>(name: string): T;
-    call(name: string, ...args: any[]): void;
-    protected readonly _children: _angular_core.WritableSignal<AXPWidgetNode[]>;
-    protected children: _angular_core.Signal<AXPWidgetNode[]>;
-    setChildren(children: AXPWidgetNode[]): void;
-    onAdded(): void;
-    hostClass?(): AXPClassMap;
-    hostStyle?(): AXPStyleMap;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPBaseWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPBaseWidgetComponent>;
-}
-declare abstract class AXPLayoutBaseWidgetComponent extends AXPBaseWidgetComponent {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLayoutBaseWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPLayoutBaseWidgetComponent>;
-}
-declare abstract class AXPValueWidgetComponent<T = any | null> extends AXPLayoutBaseWidgetComponent implements OnInit {
-    protected readonly path: string | undefined;
-    protected readonly defaultValue: any;
-    private _isValueWidget;
-    private isValueWidget;
-    onValueChanged: Subject<{
-        sender: AXPBaseWidgetComponent;
-    }>;
-    fullPath: _angular_core.WritableSignal<string | null>;
-    parentPath: _angular_core.WritableSignal<string | null>;
+    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>;
+    /**
+     * Initial context for reset functionality
+     */
+    private initialContext;
     ngOnInit(): void;
-    getValue: _angular_core.Signal<T>;
-    protected validationRules: _angular_core.Signal<AXPValidationRules>;
-    protected extractValue(path: string): any;
-    setValue(value: T | null | undefined): void;
-    private detectFullPath;
-    protected handleValueChanged(e: AXValueChangedEvent<T>): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPValueWidgetComponent<any>, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPValueWidgetComponent<any>>;
-}
-declare abstract class AXPDataListWidgetComponent extends AXPValueWidgetComponent<any> {
-    private dataService;
-    protected textField: _angular_core.Signal<string>;
-    protected valueField: _angular_core.Signal<string>;
-    protected dataSource: _angular_core.WritableSignal<AXDataSource<any>>;
-    protected isReady: _angular_core.Signal<boolean>;
-    selectedItems: _angular_core.WritableSignal<any[]>;
-    private rf;
-    protected extractItem(item: unknown): Promise<any>;
-    private effect2;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDataListWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPDataListWidgetComponent>;
-}
-declare abstract class AXPColumnWidgetComponent<T = any | null | void> {
-    private readonly token;
-    protected readonly path: string;
-    protected readonly options: _acorex_platform_core.AXPOptionsData;
-    protected readonly rawValue: T;
-    protected readonly rowData: any;
-    protected readonly nullText: any;
-    protected readonly nullValue: T;
-    protected value: _angular_core.Signal<T>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPColumnWidgetComponent<any>, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPColumnWidgetComponent<any>>;
-}
-
-declare abstract class AXPBoxModelLayoutWidgetComponent extends AXPLayoutBaseWidgetComponent {
-    hostBoxStyle: _angular_core.Signal<Readonly<Record<string, string | number>>>;
-    protected blockStyle: _angular_core.Signal<Readonly<Record<string, string | number>>>;
-    protected inlineStyle: _angular_core.Signal<Readonly<Record<string, string | number>>>;
-    protected blockClass: _angular_core.Signal<Readonly<Record<string, boolean>>>;
-    protected inlineClass: _angular_core.Signal<Readonly<Record<string, boolean>>>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPBoxModelLayoutWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPBoxModelLayoutWidgetComponent>;
+    /**
+     * 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>;
+    /**
+     * Clear the form context
+     */
+    clear(): void;
+    /**
+     * Reset the form to its initial state
+     */
+    reset(): void;
+    /**
+     * 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 abstract class AXPBlockBaseLayoutWidgetComponent extends AXPBoxModelLayoutWidgetComponent {
-    hostClass: _angular_core.Signal<Readonly<Record<string, boolean>>>;
-    hostStyle: _angular_core.Signal<Readonly<Record<string, string | number>>>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPBlockBaseLayoutWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPBlockBaseLayoutWidgetComponent>;
+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>;
 }
 
-type AXPPropertyEditorSideValues = 'top' | 'left' | 'bottom' | 'right';
-type AXPPropertyEditorCornerValues = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
-type AXPPropertyEditorSideGeneric<T extends string, U extends string | number = string> = Record<T, U>;
-type AXPPropertySides<T extends string | number = string> = AXPPropertyEditorSideGeneric<AXPPropertyEditorSideValues, T>;
-type AXPPropertyCorners<T extends string | number = string> = AXPPropertyEditorSideGeneric<AXPPropertyEditorCornerValues, T>;
-interface AXPSpacingBox<T extends string | number = string> {
-    margin: AXPPropertySides<T>;
-    padding: AXPPropertySides<T>;
-}
-interface AXPBorderBox<T extends string | number = string> {
-    width: AXPPropertySides<T>;
-    radius: AXPPropertyCorners<T>;
-    color: AXPPropertySides<T>;
-    style: AXPPropertySides<T>;
-}
-interface AXPSpacingBoxString {
-    margin: string;
-    padding: string;
-}
-interface AXPBorderBoxString {
-    width: string;
-    radius: string;
-    color: string;
-    style: string;
-}
-interface AXPFlexBoxString {
-    flexDirection?: 'row' | 'row-reverse' | 'column' | 'column-reverse';
-    flexWrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
-    justifyContent?: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around';
-    alignItems?: 'stretch' | 'flex-start' | 'flex-end' | 'center' | 'baseline';
-    gap?: string;
-}
-interface AXPFlexItemBoxString {
-    order?: string;
-    grow?: string;
-    shrink?: string;
-    basis?: string;
-    alignSelf?: string;
+declare class AXPLayoutBuilderService {
+    private popupService;
+    /**
+     * Create a new layout builder
+     */
+    create(): ILayoutBuilder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPLayoutBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPLayoutBuilderService>;
 }
-interface AXPGridBoxString {
-    columns?: number;
-    rows?: number;
-    gap?: string;
-    justifyItems?: 'start' | 'end' | 'center' | 'stretch';
-    alignItems?: 'start' | 'end' | 'center' | 'stretch';
-    autoFlow?: 'row' | 'column' | 'dense' | 'row dense' | 'column dense';
-}
-interface AXPGridItemBoxString {
-    colSpan?: string | number;
-    colStart?: string | number;
-    colEnd?: string | number;
-    rowSpan?: string | number;
-    rowStart?: string | number;
-    rowEnd?: string | number;
-    alignSelf?: 'start' | 'end' | 'center' | 'stretch';
-    justifySelf?: 'start' | 'end' | 'center' | 'stretch';
-}
-type AXPGridBreakpointValues = AXPBreakpointValues<AXPGridBoxString>;
-type AXPBreakpoints = 'default' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
-type AXPBreakpointValues<T> = {
-    [key in AXPBreakpoints]?: T;
-};
 
-declare class AXPPropertyEditorHelper {
-    private static expandShorthand;
-    private static condenseShorthand;
-    private static parseSides;
-    private static parseSidesWithUnits;
-    private static parseCorners;
-    static parseSpacingBox(input: AXPSpacingBoxString): AXPSpacingBox<number>;
-    static parseBorderBox(input: AXPBorderBoxString): AXPBorderBox<number | string>;
-    static parseSpacingBoxReverse(input: AXPSpacingBox<number>, units: AXPSpacingBox<string>): AXPSpacingBoxString;
-    static parseBorderBoxReverse(input: AXPBorderBox<number | string>, units: AXPBorderBox<string>): AXPBorderBoxString;
-    static getValueWithUnit(input: string | number): {
-        value: number;
-        unit: string;
-    };
-    static getValueFromUnit(value: number, unit: string): string;
-    static parseGap(gap: string): {
-        values: Record<'x' | 'y', number>;
-        unit: string;
+declare class AXPLayoutConversionService {
+    private widgetTreeCache;
+    private formDefinitionCache;
+    /**
+     * 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
+     */
+    convertFormDefinition(formDefinition: AXPDynamicFormDefinition): AXPWidgetNode;
+    /**
+     * Convert AXPWidgetNode tree back to AXPDynamicFormDefinition
+     * Parses Fieldset Layouts back to Groups
+     * Parses Form Field widgets back to Fields
+     */
+    convertWidgetTreeToFormDefinition(widgetTree: AXPWidgetNode): AXPDynamicFormDefinition;
+    /**
+     * Validate that a widget tree represents a valid dynamic form structure
+     */
+    validateFormWidgetTree(widgetTree: AXPWidgetNode): boolean;
+    /**
+     * Clear all caches
+     */
+    clearCaches(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        widgetTreeCacheSize: number;
+        formDefinitionCacheSize: number;
     };
-    static parseGridTemplate(gridTemplate: string): number;
-    static createGridTemplate(repetitionCount: number): string;
-}
-declare function findNonEmptyBreakpoints<T>(values: AXPBreakpointValues<T>): AXPBreakpoints[];
-
-declare abstract class AXPFlexBaseLayoutWidgetComponent extends AXPBlockBaseLayoutWidgetComponent {
-    protected flex: _angular_core.Signal<AXPFlexBoxString | undefined>;
-    hostFlexStyle: _angular_core.Signal<Record<string, string | number>>;
-    hostFlexClass: _angular_core.Signal<Record<string, boolean>>;
-    hostClass: _angular_core.Signal<Record<string, boolean>>;
-    hostStyle: _angular_core.Signal<Record<string, string | number>>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPFlexBaseLayoutWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPFlexBaseLayoutWidgetComponent>;
-}
-
-declare abstract class AXPInlineBaseLayoutWidgetComponent extends AXPBoxModelLayoutWidgetComponent {
-    hostClass: _angular_core.Signal<Readonly<Record<string, boolean>>>;
-    hostStyle: _angular_core.Signal<Readonly<Record<string, string | number>>>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPInlineBaseLayoutWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPInlineBaseLayoutWidgetComponent>;
-}
-
-declare abstract class AXPFlexItemBaseLayoutWidgetComponent extends AXPInlineBaseLayoutWidgetComponent {
-    protected flexItem: _angular_core.Signal<AXPFlexItemBoxString | undefined>;
-    hostFlexItemStyle: _angular_core.Signal<Record<string, string | number>>;
-    hostFlexItemClass: _angular_core.Signal<{
-        [x: string]: boolean;
-    }>;
-    hostClass: _angular_core.Signal<{
-        [x: string]: boolean;
-    }>;
-    hostStyle: _angular_core.Signal<Record<string, string | number>>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPFlexItemBaseLayoutWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPFlexItemBaseLayoutWidgetComponent>;
-}
-
-declare abstract class AXPGridBaseLayoutWidgetComponent extends AXPBlockBaseLayoutWidgetComponent {
-    private grid;
-    hostGridStyle: _angular_core.Signal<Record<string, string | number>>;
-    hostGridClass: _angular_core.Signal<Record<string, boolean>>;
-    hostClass: _angular_core.Signal<Record<string, boolean>>;
-    hostStyle: _angular_core.Signal<Record<string, string | number>>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPGridBaseLayoutWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPGridBaseLayoutWidgetComponent>;
-}
-
-declare abstract class AXPGridItemBaseLayoutWidgetComponent extends AXPFlexBaseLayoutWidgetComponent {
-    private gridItem;
-    hostGridItemStyle: _angular_core.Signal<Record<string, string | number>>;
-    hostGridItemClass: _angular_core.Signal<Record<string, boolean>>;
-    hostClass: _angular_core.Signal<Record<string, boolean>>;
-    hostStyle: _angular_core.Signal<Record<string, string | number>>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPGridItemBaseLayoutWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPGridItemBaseLayoutWidgetComponent>;
-}
-
-declare abstract class AXPTableBaseLayoutWidgetComponent extends AXPBlockBaseLayoutWidgetComponent {
-    hostTableClass: _angular_core.Signal<{
-        [x: string]: boolean;
-    }>;
-    hostTableStyle: _angular_core.Signal<Record<string, string | number>>;
-    hostClass: _angular_core.Signal<{
-        [x: string]: boolean;
-    }>;
-    hostStyle: _angular_core.Signal<Record<string, string | number>>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTableBaseLayoutWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTableBaseLayoutWidgetComponent>;
-}
-
-declare abstract class AXPTableItemOpsBaseLayoutWidgetComponent extends AXPBlockBaseLayoutWidgetComponent {
-    abstract insertColumnLeft(): void;
-    abstract insertColumnRight(): void;
-    abstract insertRowAbove(): void;
-    abstract insertRowBelow(): void;
-    abstract insertCellShiftRight(): void;
-    abstract insertCellShiftDown(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTableItemOpsBaseLayoutWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTableItemOpsBaseLayoutWidgetComponent>;
-}
-
-declare abstract class AXPTableItemBaseLayoutWidgetComponent extends AXPTableItemOpsBaseLayoutWidgetComponent {
-    protected colSpan: _angular_core.Signal<number>;
-    protected rowSpan: _angular_core.Signal<number>;
-    hostClass: _angular_core.Signal<Readonly<Record<string, boolean>>>;
-    hostStyle: _angular_core.Signal<Readonly<Record<string, string | number>>>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTableItemBaseLayoutWidgetComponent, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTableItemBaseLayoutWidgetComponent>;
-}
-
-type AXPLayoutContextState = 'initiated' | 'restored' | 'changed' | 'patch';
-declare class AXPLayoutContextChangeEvent {
-    oldValue?: any;
-    newValue?: any;
-    path?: string;
-    state: AXPLayoutContextState;
-    data: any;
-}
-declare const AXPLayoutBuilderContextStore: _angular_core.Type<{
-    data: _angular_core.Signal<{}>;
-    state: _angular_core.Signal<AXPLayoutContextState>;
-    initialSnapshot: _angular_core.Signal<{}>;
-    previousSnapshot: _angular_core.Signal<{}>;
-    lastChange: _ngrx_signals.DeepSignal<AXPLayoutContextChangeEvent>;
-    isChanged: _angular_core.Signal<boolean>;
-    isReset: _angular_core.Signal<boolean>;
-    isInitiated: _angular_core.Signal<boolean>;
-    isEmpty: _angular_core.Signal<boolean>;
-    isDirty: _angular_core.Signal<boolean>;
-    snapshot: _angular_core.Signal<{}>;
-    initial: _angular_core.Signal<{}>;
-    previous: _angular_core.Signal<{}>;
-    changeEvent: _angular_core.Signal<AXPLayoutContextChangeEvent>;
-    update: (path: string, value: any) => void;
-    patch: (context: {}) => void;
-    reset: () => void;
-    set: (initialData: any) => void;
-    getValue: (path: string) => any;
-} & _ngrx_signals.StateSource<{
-    data: {};
-    state: AXPLayoutContextState;
-    initialSnapshot: {};
-    previousSnapshot: {};
-    lastChange: AXPLayoutContextChangeEvent;
-}>>;
-
-declare class AXPWidgetContainerComponent {
-    readonly contextService: {
-        data: _angular_core.Signal<{}>;
-        state: _angular_core.Signal<_acorex_platform_layout_builder.AXPLayoutContextState>;
-        initialSnapshot: _angular_core.Signal<{}>;
-        previousSnapshot: _angular_core.Signal<{}>;
-        lastChange: _ngrx_signals.DeepSignal<AXPLayoutContextChangeEvent>;
-        isChanged: _angular_core.Signal<boolean>;
-        isReset: _angular_core.Signal<boolean>;
-        isInitiated: _angular_core.Signal<boolean>;
-        isEmpty: _angular_core.Signal<boolean>;
-        isDirty: _angular_core.Signal<boolean>;
-        snapshot: _angular_core.Signal<{}>;
-        initial: _angular_core.Signal<{}>;
-        previous: _angular_core.Signal<{}>;
-        changeEvent: _angular_core.Signal<AXPLayoutContextChangeEvent>;
-        update: (path: string, value: any) => void;
-        patch: (context: {}) => void;
-        reset: () => void;
-        set: (initialData: any) => void;
-        getValue: (path: string) => any;
-    } & _ngrx_signals.StateSource<{
-        data: {};
-        state: _acorex_platform_layout_builder.AXPLayoutContextState;
-        initialSnapshot: {};
-        previousSnapshot: {};
-        lastChange: AXPLayoutContextChangeEvent;
-    }>;
-    readonly builderService: AXPLayoutBuilderService;
-    readonly onContextChanged: EventEmitter<AXPLayoutContextChangeEvent>;
-    set context(value: any);
-    set functions(v: any);
-    constructor();
-    status: _angular_core.Signal<_acorex_platform_layout_builder.AXPPageStatus>;
-    isBusy: _angular_core.Signal<boolean>;
-    refresh(): void;
-    find(name: string): Promise<_acorex_platform_layout_builder.AXPLayoutElement | undefined>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetContainerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetContainerComponent, "axp-widgets-container", never, { "context": { "alias": "context"; "required": false; }; "functions": { "alias": "functions"; "required": false; }; }, { "onContextChanged": "onContextChanged"; }, never, ["*"], false, never>;
-}
-
-declare class AXPWidgetRegistryService {
-    private types;
-    static instance: AXPWidgetRegistryService;
     /**
-     *
+     * Convert a single group to Fieldset widget structure
      */
-    constructor();
-    register(widget: AXPWidgetConfig): void;
-    extend(parentName: string, widget: AXPWidgetConfig): void;
-    resolve(name: string): AXPWidgetConfig | undefined;
-    all(): AXPWidgetConfig[];
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetRegistryService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPWidgetRegistryService>;
-}
-
-declare class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
-    protected widgetRegistery: AXPWidgetRegistryService;
-    private grid;
-    customExpandIcon: string;
-    customCollapseIcon: string;
-    customWidth: string;
-    private _node;
-    get node(): AXPWidgetColumnNode;
-    set node(v: AXPWidgetColumnNode);
-    private mergedOptions;
-    protected loadingRow: _angular_core.WritableSignal<null>;
-    footerTemplate: TemplateRef<unknown>;
-    private _contentFooterTemplate;
-    get renderFooterTemplate(): TemplateRef<unknown>;
-    expandHandler: boolean;
-    cellTemplate: TemplateRef<unknown>;
-    private _contentCellTemplate;
-    get renderCellTemplate(): TemplateRef<unknown>;
-    headerTemplate: TemplateRef<unknown>;
-    private _contentHeaderTemplate;
-    protected handleExpandRow(row: any): Promise<void>;
-    get renderHeaderTemplate(): TemplateRef<unknown>;
-    get loadingEnabled(): boolean;
-    get name(): string;
-    private injector;
-    private cdr;
-    protected widgetInjector: Injector;
-    protected component: any;
-    ngOnInit(): Promise<void>;
-    getInputs(data: any): any;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetColumnRendererComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetColumnRendererComponent, "axp-widget-column-renderer", never, { "caption": { "alias": "caption"; "required": false; }; "customExpandIcon": { "alias": "customExpandIcon"; "required": false; }; "customCollapseIcon": { "alias": "customCollapseIcon"; "required": false; }; "customWidth": { "alias": "customWidth"; "required": false; }; "node": { "alias": "node"; "required": true; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; "expandHandler": { "alias": "expandHandler"; "required": false; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; }, {}, never, never, false, never>;
-}
-
-type AXPWidgetRendererDirectiveOptions = AXPMetaData;
-declare class AXPWidgetRendererDirective {
-    parentNode: _angular_core.InputSignal<AXPLayoutBaseWidgetComponent | null | undefined>;
-    index: _angular_core.InputSignal<number | null | undefined>;
-    mode: _angular_core.InputSignal<keyof _acorex_platform_layout_builder.AXPWidgetConfigComponents>;
-    node: _angular_core.InputSignal<AXPWidgetNode>;
-    private _options;
-    options: _angular_core.Signal<AXPMetaData>;
-    onOptionsChanged: _angular_core.OutputEmitterRef<{
-        sender: AXPWidgetRendererDirective;
-        widget: AXPBaseWidgetComponent;
-    }>;
-    onValueChanged: _angular_core.OutputEmitterRef<{
-        sender: AXPWidgetRendererDirective;
-        widget: AXPValueWidgetComponent;
-    }>;
-    protected mergedOptions: WritableSignal<any>;
-    private injector;
-    protected builderService: AXPLayoutBuilderService;
-    protected contextService: {
-        data: _angular_core.Signal<{}>;
-        state: _angular_core.Signal<_acorex_platform_layout_builder.AXPLayoutContextState>;
-        initialSnapshot: _angular_core.Signal<{}>;
-        previousSnapshot: _angular_core.Signal<{}>;
-        lastChange: _ngrx_signals.DeepSignal<_acorex_platform_layout_builder.AXPLayoutContextChangeEvent>;
-        isChanged: _angular_core.Signal<boolean>;
-        isReset: _angular_core.Signal<boolean>;
-        isInitiated: _angular_core.Signal<boolean>;
-        isEmpty: _angular_core.Signal<boolean>;
-        isDirty: _angular_core.Signal<boolean>;
-        snapshot: _angular_core.Signal<{}>;
-        initial: _angular_core.Signal<{}>;
-        previous: _angular_core.Signal<{}>;
-        changeEvent: _angular_core.Signal<_acorex_platform_layout_builder.AXPLayoutContextChangeEvent>;
-        update: (path: string, value: any) => void;
-        patch: (context: {}) => void;
-        reset: () => void;
-        set: (initialData: any) => void;
-        getValue: (path: string) => any;
-    } & _ngrx_signals.StateSource<{
-        data: {};
-        state: _acorex_platform_layout_builder.AXPLayoutContextState;
-        initialSnapshot: {};
-        previousSnapshot: {};
-        lastChange: _acorex_platform_layout_builder.AXPLayoutContextChangeEvent;
-    }>;
-    protected widgetRegistery: AXPWidgetRegistryService;
-    protected unsubscriber: AXUnsubscriber;
-    protected translateService: AXTranslationService;
-    protected widgetService: AXPWidgetRegistryService;
-    protected expressionEvaluator: AXPExpressionEvaluatorService;
-    private viewContainerRef;
-    protected isLoading: WritableSignal<boolean>;
-    instance: AXPValueWidgetComponent;
-    private expressionEvaluators;
-    private componentRef;
-    private renderTimeoutId;
-    private hasInitialRender;
-    private onContextChanged;
-    private contextUpdateQueue;
-    private contextUpdateTimeout;
-    private readonly CONTEXT_UPDATE_DEBOUNCE_MS;
-    private expressionCache;
-    private readonly EXPRESSION_CACHE_TTL;
-    private lastAppliedOptions;
-    private lastExpressionResults;
-    private preRenderContextQueue;
-    constructor();
-    private getCachedExpressionResult;
-    private setCachedExpressionResult;
-    private clearExpressionCache;
-    private isPathAffectingExpressions;
-    private queueContextUpdate;
-    private processBatchedUpdates;
-    private isRelevantContextChange;
-    private hasExpressionDependency;
-    private isPathAlias;
-    private getExpressionValueFromNode;
-    private hasTriggerDependency;
-    ngOnChanges(changes: SimpleChanges): void;
-    private rerenderComponent;
-    ngOnDestroy(): void;
-    private loadComponent;
-    private applyOptions;
-    private hasOptionsChanged;
-    private checkFormulaForUpdate;
-    preprocessAndInitialOptions(obj: any, pathPrefix?: string): void;
-    updateOptionsBasedOnContext(): Promise<number>;
-    updateValueBasedOnFormula(): Promise<void>;
-    private evaluateExpression;
-    private buildExpressionScope;
-    private getContextScope;
-    private getEventScope;
-    private getWidgetScope;
-    private getFunctionScope;
-    private getVariablesScope;
-    private assignTriggers;
-    private evaluateTrigger;
-    private evaluateAction;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetRendererDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXPWidgetRendererDirective, "[axp-widget-renderer]", ["widgetRenderer"], { "parentNode": { "alias": "parentNode"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "node": { "alias": "node"; "required": true; "isSignal": true; }; }, { "onOptionsChanged": "onOptionsChanged"; "onValueChanged": "onValueChanged"; }, never, never, false, never>;
-}
-
-interface AXPLayoutBuilderModuleConfigs {
-    widgets?: AXPWidgetConfig[];
-    extendedWidgets?: extendedWidget[];
-}
-declare class AXPLayoutBuilderModule {
-    static forRoot(config?: AXPLayoutBuilderModuleConfigs): ModuleWithProviders<AXPLayoutBuilderModule>;
-    static forChild(config?: AXPLayoutBuilderModuleConfigs): ModuleWithProviders<AXPLayoutBuilderModule>;
+    private createGroupAsFieldsetWidget;
+    /**
+     * Convert fields to Form Field widgets
+     */
+    private createFieldWidgets;
+    /**
+     * Convert a single field to Form Field widget with editor as child
+     */
+    private createFormFieldWidget;
+    /**
+     * Extract group information from Fieldset Layout widget
+     */
+    private extractGroupFromFieldset;
+    /**
+     * Extract field information from Form Field widget
+     */
+    private extractFieldFromFormWidget;
+    /**
+     * Create cache key for form definition
+     */
+    private createFormDefinitionCacheKey;
     /**
-     * @ignore
+     * Create cache key for widget tree
      */
-    constructor(instances: any[]);
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLayoutBuilderModule, [{ optional: true; }]>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXPLayoutBuilderModule, [typeof AXPWidgetContainerComponent, typeof AXPWidgetColumnRendererComponent, typeof AXPWidgetRendererDirective], [typeof i4.CommonModule, typeof i5.PortalModule, typeof i6.AXSkeletonModule, typeof i4.CommonModule, typeof i7.AXTranslationModule], [typeof AXPWidgetContainerComponent, typeof AXPWidgetColumnRendererComponent, typeof AXPWidgetRendererDirective]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXPLayoutBuilderModule>;
+    private createWidgetTreeCacheKey;
+    /**
+     * Create a simple hash from a string
+     */
+    private createSimpleHash;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPLayoutConversionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPLayoutConversionService>;
 }
 
-interface AXPMetaDataDefinition {
-    name: string;
+interface DialogRendererConfig {
     title: string;
-    defaultValue?: any;
-    interface: string | AXPWidgetNode | (() => Promise<AXPWidgetNode>);
+    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>;
 }
 
-declare const AXPWidgetsCatalog: AXPWidgetTypesMap;
-
-export { AXPBaseWidgetComponent, AXPBlockBaseLayoutWidgetComponent, AXPBoxModelLayoutWidgetComponent, AXPColumnWidgetComponent, AXPDataListWidgetComponent, AXPFlexBaseLayoutWidgetComponent, AXPFlexItemBaseLayoutWidgetComponent, AXPGridBaseLayoutWidgetComponent, AXPGridItemBaseLayoutWidgetComponent, AXPInlineBaseLayoutWidgetComponent, AXPLayoutBaseWidgetComponent, AXPLayoutBuilderContextStore, AXPLayoutBuilderModule, AXPLayoutBuilderService, AXPLayoutContextChangeEvent, AXPLayoutElement, AXPPageStatus, AXPPropertyEditorHelper, AXPTableBaseLayoutWidgetComponent, AXPTableItemBaseLayoutWidgetComponent, AXPTableItemOpsBaseLayoutWidgetComponent, AXPValueWidgetComponent, AXPWidgetColumnRendererComponent, AXPWidgetContainerComponent, AXPWidgetGroupEnum, AXPWidgetRegistryService, AXPWidgetRendererDirective, AXPWidgetStatus, AXPWidgetsCatalog, AXP_WIDGETS_ACTION_CATEGORY, AXP_WIDGETS_ADVANCE_CATEGORY, AXP_WIDGETS_CATEGORIES, AXP_WIDGETS_EDITOR_CATEGORY, AXP_WIDGETS_LAYOUT_CATEGORY, AXP_WIDGET_COLUMN_TOKEN, AXP_WIDGET_TOKEN, cloneProperty, createBooleanProperty, createNumberProperty, createSelectProperty, createStringProperty, findNonEmptyBreakpoints };
-export type { AXPBorderBox, AXPBorderBoxString, AXPBreakpointValues, AXPBreakpoints, AXPClassMap, AXPExtractWidgetConfig, AXPFlexBoxString, AXPFlexItemBoxString, AXPGridBoxString, AXPGridBreakpointValues, AXPGridItemBoxString, AXPLayoutBuilderModuleConfigs, AXPLayoutBuilderStatusChangedEvent, AXPLayoutContextState, AXPLayoutElementAPI, AXPMetaDataDefinition, AXPPropertyCorners, AXPPropertyEditorCornerValues, AXPPropertyEditorSideGeneric, AXPPropertyEditorSideValues, AXPPropertySides, AXPSpacingBox, AXPSpacingBoxString, AXPStyleMap, AXPWidgetCategory, AXPWidgetColumnNode, AXPWidgetColumnNodeToken, AXPWidgetComponentConfig, AXPWidgetConfig, AXPWidgetConfigComponents, AXPWidgetDesignerOptionsMap, AXPWidgetGroup, AXPWidgetNode, AXPWidgetNodeToken, AXPWidgetProperty, AXPWidgetPropertyGroup, AXPWidgetRenderMode, AXPWidgetRendererDirectiveOptions, AXPWidgetTypesMap, AXPWidgetViewType, extendedWidget };
+export { AXPDialogRendererComponent, AXPLayoutBuilderService, AXPLayoutConversionService, AXPLayoutRendererComponent, LayoutBuilderModule };
+export type { AXPDialogContainerOptions, AXPDialogRef, AXPDynamicFormDefinition, AXPDynamicFormDirection, AXPDynamicFormFieldDefinition, AXPDynamicFormGroupDefinition, AXPDynamicFormLook, AXPDynamicFormMode, 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 };