@acorex/platform 0.0.0-ACOREX

package/types/acorex-platform-layout-builder.d.ts

@@ -0,0 +1,926 @@
+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, AXPWidgetContainerComponent, AXPWidgetCoreElementAction } from '@acorex/platform/layout/widget-core';
+import { AXDataSource } from '@acorex/cdk/common';
+import { AXPopupSizeType } from '@acorex/components/popup';
+import { AXStepWizardLook } from '@acorex/components/step-wizard';
+import { AXPMultiLanguageString, AXPGridLayoutOptions, AXPExpression, AXPValidationRules, AXPOptionsData, AXPActionMenuItem, AXPContextChangeEvent, AXPExecuteCommandResult } from '@acorex/platform/core';
+import { AXBasePageComponent } from '@acorex/components/page';
+import { AXPCommand } from '@acorex/platform/runtime';
+
+/**
+ * Extended widget node properties (excluding type, path, name, options, children)
+ * These properties can be passed as a third parameter to customWidget method
+ */
+type AXPWidgetNodeExtendedProperties = Omit<AXPWidgetNode, 'type' | 'path' | 'name' | 'options'>;
+/**
+ * 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?: AXPMultiLanguageString;
+    badge?: string;
+    description?: AXPMultiLanguageString;
+    widget: AXPWidgetNode;
+    /**
+     * Optional per-field rendering mode. Takes precedence over section and form modes.
+     */
+    mode?: AXPDynamicFormMode;
+    layout?: AXPGridLayoutOptions;
+}
+interface AXPDynamicFormGroupDefinition {
+    name: string;
+    title?: AXPMultiLanguageString;
+    description?: AXPMultiLanguageString;
+    parameters: AXPDynamicFormFieldDefinition[];
+    /**
+     * Optional per-section rendering mode. Takes precedence over form mode and is overridden by field mode.
+     */
+    mode?: AXPDynamicFormMode;
+    /**
+     * Visual appearance of the group (fieldset, card, group, container)
+     */
+    look?: 'fieldset' | 'card' | 'group' | 'container';
+}
+interface AXPDynamicFormDefinition {
+    groups: AXPDynamicFormGroupDefinition[];
+    /**
+     * Optional form-level rendering mode
+     */
+    mode?: AXPDynamicFormMode;
+}
+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 LayoutWidgetOptions {
+    name?: string;
+}
+interface ValueWidgetOptions extends LayoutWidgetOptions {
+    path: string;
+    defaultValue?: any;
+    validations?: AXPValidationRules;
+}
+interface TextBoxOptions extends ValueWidgetOptions {
+    placeholder?: AXPMultiLanguageString;
+    maxLength?: number;
+    minLength?: number;
+    prefix?: string;
+    suffix?: string;
+    clearButton?: boolean;
+}
+interface NumberBoxOptions extends ValueWidgetOptions {
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: AXPMultiLanguageString;
+    format?: string;
+}
+interface SelectBoxOptions extends ValueWidgetOptions {
+    dataSource: any[] | (() => any[]) | (() => Promise<any[]>) | AXDataSource<any>;
+    valueField?: string;
+    textField?: string;
+    placeholder?: AXPMultiLanguageString;
+    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?: AXPMultiLanguageString;
+    clearButton?: boolean;
+}
+interface ToggleSwitchOptions extends ValueWidgetOptions {
+    label?: string;
+    trueText?: string;
+    falseText?: string;
+}
+interface LargeTextBoxOptions extends ValueWidgetOptions {
+    rows?: number;
+    maxLength?: number;
+    minLength?: number;
+    placeholder?: AXPMultiLanguageString;
+    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;
+    };
+    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' | 'container';
+    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?: AXPMultiLanguageString;
+    toolbar?: string[];
+    readonly?: boolean;
+}
+interface PasswordBoxOptions extends ValueWidgetOptions {
+    placeholder?: AXPMultiLanguageString;
+    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?: AXPMultiLanguageString;
+}
+interface AXPListWidgetColumn {
+    name: string;
+    title?: string;
+    visible?: boolean;
+    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 AXPWizardActionDefinition {
+    title?: string;
+    icon?: string;
+    color?: string;
+}
+interface AXPWizardActions {
+    previous?: AXPWizardActionDefinition;
+    next?: AXPWizardActionDefinition;
+    submit?: AXPWizardActionDefinition;
+}
+interface AXPStepDefinition {
+    id: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    skippable?: boolean;
+    content: AXPWidgetNode;
+    actions?: AXPActionMenuItem[];
+}
+interface AXPStepWizardGuardPayload {
+    step: AXPStepDefinition;
+    index: number;
+    total: number;
+    isFirst: boolean;
+    isLast: boolean;
+    context: any;
+    stepContext?: any;
+    dialogContext?: any;
+}
+interface AXPStepWizardStatus {
+    currentStep: AXPStepDefinition;
+    index: number;
+    total: number;
+    isFirst: boolean;
+    isLast: boolean;
+}
+interface AXPStepWizardDefinition {
+    steps: AXPStepDefinition[];
+    linear?: boolean;
+    direction?: 'horizontal' | 'vertical';
+    look?: string;
+    showActions?: boolean;
+    actions?: AXPWizardActions;
+    guards?: {
+        next?: (payload: AXPStepWizardGuardPayload) => boolean | Promise<boolean>;
+        prev?: (payload: AXPStepWizardGuardPayload) => boolean | Promise<boolean>;
+    };
+    events?: {
+        onStepChanged?: (status: AXPStepWizardStatus) => void;
+        onComplete?: (status: AXPStepWizardStatus) => void;
+    };
+}
+interface AXPStepWizardContainerOptions extends LayoutWidgetOptions {
+    definition?: AXPStepWizardDefinition;
+}
+interface InheritanceContext {
+    mode?: AXPWidgetRenderMode;
+    disabled?: boolean | string;
+    readonly?: boolean | string;
+    direction?: 'rtl' | 'ltr';
+    visible?: boolean | string;
+    defaultValue?: any;
+}
+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 = AXPWidgetNode & {
+    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 & {
+        position?: 'prefix' | 'suffix';
+    }): 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<T = AXPDialogRef>(delegate: (container: IDialogBuilder<T>) => void): IDialogBuilder<T>;
+    stepWizard(delegate: (wizard: IStepWizardBuilder) => void): ILayoutBuilder;
+    build(): AXPWidgetNode;
+    toJson(options?: {
+        removeMeta?: boolean;
+        removeFunctions?: boolean;
+        pretty?: boolean;
+    }): string;
+}
+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;
+    defaultValue(defaultValue: any): 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;
+    stepWizard(delegate: (wizard: IStepWizardBuilder) => void): TContainer;
+    dynamicForm(definition: AXPDynamicFormDefinition): 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;
+    customWidget<T>(type: string, delegate: (widget: IWidgetBuilder) => void): 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;
+    /** Add a grid-item-layout child with optional placement; delegate builds the fieldset content. */
+    item(layoutOptions: Partial<AXPGridLayoutOptions> | null | undefined, delegate: (container: IFieldsetContainerBuilder) => void): 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;
+    defaultValue(value: any): 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;
+    customWidget<T>(type: string, options?: Omit<T, 'path'> & Partial<AXPWidgetNodeExtendedProperties>): 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' | 'container'): IFieldsetContainerBuilder;
+    setShowHeader(showHeader: boolean): IFieldsetContainerBuilder;
+    setCols(cols: number): IFieldsetContainerBuilder;
+    formField(label: string, delegate?: (field: IFormFieldBuilder) => void): IFieldsetContainerBuilder;
+}
+interface IDialogBuilder<T = AXPDialogRef> {
+}
+interface IDialogBuilder<T = AXPDialogRef> {
+    setOptions(options: AXPDialogContainerOptions): IDialogBuilder<T>;
+    setTitle(title: string): IDialogBuilder<T>;
+    setMessage(message?: string): IDialogBuilder<T>;
+    setSize(size: AXPopupSizeType): IDialogBuilder<T>;
+    setCloseButton(closeButton: boolean): IDialogBuilder<T>;
+    setContext(context: any): IDialogBuilder<T>;
+    content(delegate: (layoutBuilder: IFlexContainerBuilder) => void): IDialogBuilder<T>;
+    setActions(delegate?: (actions: IActionBuilder) => void): IDialogBuilder<T>;
+    /**
+     * Handler invoked when user clicks an action. Receives AXPDialogRef (context, action, setLoading, close).
+     * If handler throws, dialog stays open for retry.
+     * If handler returns, dialog closes and show() resolves with the return value.
+     */
+    onAction(handler: (dialogRef: AXPDialogRef) => T | Promise<T>): IDialogBuilder<T>;
+    addCustomAction(action: AXPActionMenuItem): IDialogBuilder<T>;
+    build(): AXPWidgetNode;
+    show(): Promise<T>;
+}
+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;
+}
+interface IStepBuilder {
+    setIcon(icon: string): IStepBuilder;
+    setDescription(description: string): IStepBuilder;
+    setSkippable(skippable: boolean): IStepBuilder;
+    content(delegate: (layoutBuilder: ILayoutBuilder) => void): IStepBuilder;
+    build(): AXPStepDefinition;
+}
+interface IStepWizardBuilder extends IBaseContainerBuilder<IStepWizardBuilder>, ILayoutContainerBuilder<IStepWizardBuilder> {
+    setLinear(linear: boolean): IStepWizardBuilder;
+    setDirection(direction: 'horizontal' | 'vertical'): IStepWizardBuilder;
+    setLook(look: AXStepWizardLook): IStepWizardBuilder;
+    setShowActions(show: boolean): IStepWizardBuilder;
+    setActions(actions: AXPWizardActions): IStepWizardBuilder;
+    setGuards(guards: {
+        next?: (payload: AXPStepWizardGuardPayload) => boolean | Promise<boolean>;
+        prev?: (payload: AXPStepWizardGuardPayload) => boolean | Promise<boolean>;
+    }): IStepWizardBuilder;
+    setEvents(events: {
+        onStepChanged?: (status: AXPStepWizardStatus) => void;
+        onComplete?: (status: AXPStepWizardStatus) => void;
+    }): IStepWizardBuilder;
+    step(id: string, title: string, delegate: (step: IStepBuilder) => void): IStepWizardBuilder;
+}
+
+declare class AXPLayoutRendererComponent implements OnInit {
+    #private;
+    private conversionService;
+    /**
+     * RxJS subjects for context management
+     */
+    private contextUpdateSubject;
+    private contextChangeSubject;
+    /**
+     * 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 layout data to widget tree when inputs change
+     */
+    conversionEffect: i0.EffectRef;
+    /**
+     * 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;
+    /**
+     * Handle context change events from widget container (optimized with RxJS)
+     */
+    protected handleContextChanged(event: AXPContextChangeEvent): 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;
+    /**
+     * Type guard to check if the input is a widget node
+     */
+    private isWidgetNode;
+    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>;
+}
+
+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 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;
+    };
+    /**
+     * Convert a single group to Fieldset widget structure
+     */
+    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;
+    /**
+     * Create cache key for widget tree
+     */
+    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[];
+        };
+    };
+    /**
+     * When present, handler is called on action click with AXPDialogRef.
+     * Throw = stay open for retry. Return = close and resolve show() with return value.
+     */
+    onAction?: (dialogRef: AXPDialogRef) => any | Promise<any>;
+}
+interface DialogRendererResult {
+    context: any;
+    action?: string;
+}
+declare class AXPDialogRendererComponent extends AXBasePageComponent implements OnInit {
+    #private;
+    config: DialogRendererConfig;
+    result: EventEmitter<DialogRendererResult>;
+    private widgetCoreService;
+    private expressionEvaluator;
+    private dialogResult?;
+    context: i0.WritableSignal<any>;
+    callBack: (dialogRef: AXPDialogRef) => void;
+    data: any;
+    private isDialogLoading;
+    footerPrefix: i0.WritableSignal<AXPWidgetCoreElementAction[]>;
+    footerSuffix: i0.WritableSignal<AXPWidgetCoreElementAction[]>;
+    ngOnInit(): void;
+    private layoutRenderer;
+    private debounceTimer?;
+    handleContextChanged(event: any): void;
+    handleContextInitiated(event: any): void;
+    footerPrefixActions(): AXPWidgetCoreElementAction[];
+    footerSuffixActions(): AXPWidgetCoreElementAction[];
+    isFormLoading(): boolean;
+    isSubmitting(): boolean;
+    executeAction(action: AXPWidgetCoreElementAction): Promise<void>;
+    /** Resolves footer/widget action command to a string (e.g. `cancel`, `submit`, `widget:...`). */
+    private resolveActionCommandName;
+    private parseWidgetCommand;
+    private executeWidgetApi;
+    close(result?: DialogRendererResult): Promise<void>;
+    private aggregateAndEvaluateActions;
+    private collectWidgetActions;
+    private collectDialogActionsFromConfig;
+    private evaluatePredicates;
+    private evalBool;
+    private resolveApi;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDialogRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPDialogRendererComponent, "axp-dialog-renderer", never, {}, { "result": "result"; }, never, never, true, never>;
+}
+
+/** Registration key for {@link AXPPreviewWidgetFieldCommand}; lives alone so `LayoutBuilderModule` can reference it without static-importing the command implementation. */
+declare const AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY = "Widget:Preview";
+
+/** See `AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY` in `preview-widget-field.command.key.ts`. */
+interface AXPPreviewWidgetFieldCommandInput {
+    /** Widget node to render (same shape as `widget-field-configurator` model). */
+    widget?: AXPWidgetNode;
+    /**
+     * Alternate property name for the widget node (matches metadata definition `interface` field).
+     */
+    interface?: AXPWidgetNode | string;
+    fieldName?: string;
+    fieldTitle?: AXPMultiLanguageString;
+    name?: string;
+    title?: AXPMultiLanguageString;
+}
+type AXPPreviewWidgetFieldInvocation = AXPPreviewWidgetFieldCommandInput & {
+    __context__?: {
+        data?: Record<string, unknown>;
+        options?: Record<string, unknown>;
+    };
+};
+/**
+ * Opens a dialog that previews a widget configuration (same behavior as the preview button on
+ * `axp-widget-field-configurator`). Invoked from that component and from entity list actions.
+ */
+declare class AXPPreviewWidgetFieldCommand implements AXPCommand<AXPPreviewWidgetFieldCommandInput, void> {
+    private readonly formBuilderService;
+    private readonly widgetRegistry;
+    private readonly translationService;
+    private readonly mlResolver;
+    private readonly crudService;
+    execute(input: AXPPreviewWidgetFieldInvocation): Promise<AXPExecuteCommandResult<void>>;
+    private mergeInvocation;
+    private normalizeWidget;
+    private resolveFieldTitleLabel;
+    private isCancelDialogOutcome;
+    private resolveWidgetDisplayTitle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPreviewWidgetFieldCommand, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPPreviewWidgetFieldCommand>;
+}
+
+export { AXPDialogRendererComponent, AXPLayoutBuilderService, AXPLayoutConversionService, AXPLayoutRendererComponent, AXPPreviewWidgetFieldCommand, AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY, LayoutBuilderModule };
+export type { AXPDialogContainerOptions, AXPDialogRef, AXPDynamicFormDefinition, AXPDynamicFormDirection, AXPDynamicFormFieldDefinition, AXPDynamicFormGroupDefinition, AXPDynamicFormLook, AXPDynamicFormMode, AXPFieldsetContainerOptions, AXPFlexContainerOptions, AXPFormFieldOptions, AXPGridContainerOptions, AXPListWidgetColumn, AXPListWidgetOptions, AXPListWidgetRowCommand, AXPPageContainerOptions, AXPPanelContainerOptions, AXPPreviewWidgetFieldCommandInput, AXPStepDefinition, AXPStepWizardContainerOptions, AXPStepWizardDefinition, AXPStepWizardGuardPayload, AXPStepWizardStatus, AXPTabsetContainerOptions, AXPWidgetConfiguration, AXPWidgetNodeExtendedProperties, AXPWizardActionDefinition, AXPWizardActions, ColorBoxOptions, DateTimeBoxOptions, DialogBuilderState, DialogRendererConfig, DialogRendererResult, FormFieldBuilderState, IActionBuilder, IBaseContainerBuilder, IChildContainerBuilder, IDialogBuilder, IFieldsetContainerBuilder, IFlexContainerBuilder, IFormFieldBuilder, IGridContainerBuilder, ILayoutBuilder, ILayoutContainerBuilder, IListWidgetBuilder, IPageContainerBuilder, IPanelContainerBuilder, IStepBuilder, IStepWizardBuilder, ITabsetContainerBuilder, IWidgetBuilder, IWidgetContainerBuilder, InheritanceContext, InheritedProperties, LargeTextBoxOptions, LayoutBuilderState, LayoutWidgetOptions, LookupBoxOptions, NumberBoxOptions, PasswordBoxOptions, RichTextOptions, SelectBoxOptions, SelectionListOptions, TextBoxOptions, ToggleSwitchOptions, ValueWidgetOptions, WidgetBuilderState };