@acorex/platform 19.4.14 → 20.0.0-next.0

package/layout/builder/index.d.ts

@@ -1 +1,682 @@
-export * from './lib/builder';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, EventEmitter, TemplateRef, Injector, OnInit, WritableSignal, SimpleChanges, ModuleWithProviders } from '@angular/core';
+import * as _acorex_platform_core from '@acorex/platform/core';
+import { AXPDataType, AXPOptionsData, AXPWidgetTriggers, AXPMetaData, AXPValueTransformerFunctions, AXPValidationRules, AXPPartialNested } from '@acorex/platform/core';
+import * as _acorex_platform_layout_builder from '@acorex/platform/layout/builder';
+import * as _ngrx_signals from '@ngrx/signals';
+import { Subject, BehaviorSubject } from 'rxjs';
+import { AXDataTableColumnComponent } from '@acorex/components/data-table';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXUnsubscriber } from '@acorex/core/utils';
+import { AXValueChangedEvent, AXDataSource } from '@acorex/cdk/common';
+import * as i4 from '@angular/common';
+import * as i5 from '@angular/cdk/portal';
+import * as i6 from '@acorex/components/skeleton';
+
+interface AXPWidgetCategory {
+    name: string;
+    title: string;
+    order: number;
+}
+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 AXPWidgetTypesMap {
+    timeDuration: 'time-duration';
+    checkbox: 'checkbox-editor';
+    color: 'color-editor';
+    contact: 'contact-editor';
+    dateTime: 'date-time-editor';
+    email: 'email-editor';
+    largeText: 'large-text-editor';
+    link: 'link-editor';
+    number: 'number-editor';
+    numberUnit: 'number-unit-editor';
+    password: 'password-editor';
+    phone: 'phone-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';
+    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';
+    gridRow: 'grid-row-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';
+    avatar: 'avatar';
+    stringFilter: 'string-filter';
+    numberFilter: 'number-filter';
+    dateTimeFilter: 'datetime-filter';
+    booleanFilter: 'boolean-filter';
+    lookupFilter: 'lookup-filter';
+    flexOptions: 'flex-options';
+    gridOptions: 'grid-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';
+    panel: 'panel';
+    notification: 'notification';
+    taskList: 'task-list';
+}
+
+declare enum AXPPageStatus {
+    Rendering = "rendering",// The widget is being rendered.
+    Rendered = "rendered",// The rendering process is complete.
+    Processing = "processing",// The widget 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"
+}
+
+interface AXPWidgetPropertyGroup {
+    name: string;
+    title: string;
+    order: number;
+}
+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;
+    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;
+    };
+}): 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[];
+    name: string;
+    title: string;
+    path?: string;
+    group: AXPWidgetPropertyGroup;
+    visible?: boolean;
+}): AXPWidgetProperty;
+interface AXPWidgetNode {
+    type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | keyof AXPWidgetTypesMap | string;
+    path?: string;
+    name?: string;
+    defaultValue?: any;
+    formula?: string;
+    children?: AXPWidgetNode[];
+    options?: AXPOptionsData;
+    triggers?: AXPWidgetTriggers;
+    meta?: AXPMetaData;
+    valueTransforms?: AXPValueTransformerFunctions;
+}
+interface AXPWidgetNodeToken {
+    config: AXPWidgetConfig;
+    node: AXPWidgetNode;
+    options?: AXPOptionsData;
+}
+interface AXPWidgetColumnNode {
+    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 AXPExtractWidgetConfig<T> = {
+    type: AXPWidgetViewType;
+    designer: T extends {
+        type: infer V;
+    } ? V extends keyof AXPWidgetDesignerOptionsMap ? AXPWidgetDesignerOptionsMap[V] : any : any;
+};
+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 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 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;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLayoutBuilderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPLayoutBuilderService>;
+}
+
+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: _ngrx_signals.DeepSignal<{}>;
+    state: _angular_core.Signal<AXPLayoutContextState>;
+    initialSnapshot: _ngrx_signals.DeepSignal<{}>;
+    previousSnapshot: _ngrx_signals.DeepSignal<{}>;
+    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>;
+    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: _ngrx_signals.DeepSignal<{}>;
+        state: _angular_core.Signal<_acorex_platform_layout_builder.AXPLayoutContextState>;
+        initialSnapshot: _ngrx_signals.DeepSignal<{}>;
+        previousSnapshot: _ngrx_signals.DeepSignal<{}>;
+        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>;
+        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>;
+    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;
+    /**
+     *
+     */
+    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>;
+}
+
+declare abstract class AXPBaseWidgetComponent extends AXPLayoutElement {
+    #private;
+    protected readonly token: _acorex_platform_layout_builder.AXPWidgetNodeToken;
+    readonly host: HTMLDivElement;
+    protected readonly layoutService: AXPLayoutBuilderService;
+    protected readonly contextService: {
+        data: _ngrx_signals.DeepSignal<{}>;
+        state: _angular_core.Signal<_acorex_platform_layout_builder.AXPLayoutContextState>;
+        initialSnapshot: _ngrx_signals.DeepSignal<{}>;
+        previousSnapshot: _ngrx_signals.DeepSignal<{}>;
+        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>;
+        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 _id: string | null;
+    get id(): string | null;
+    protected _options: _angular_core.WritableSignal<any>;
+    options: _angular_core.Signal<any>;
+    onOptionsChanged: Subject<{
+        sender: AXPBaseWidgetComponent;
+    }>;
+    private _status;
+    status: _angular_core.Signal<AXPWidgetStatus>;
+    readonly onStatusChanged: BehaviorSubject<AXPWidgetStatus>;
+    isBusy: _angular_core.Signal<boolean>;
+    parent: AXPLayoutWidgetComponent | 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;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPBaseWidgetComponent, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPBaseWidgetComponent>;
+}
+declare abstract class AXPLayoutWidgetComponent extends AXPBaseWidgetComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLayoutWidgetComponent, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPLayoutWidgetComponent>;
+}
+declare abstract class AXPValueWidgetComponent<T = any | null> extends AXPLayoutWidgetComponent implements OnInit {
+    protected readonly path: string | undefined;
+    protected readonly defaultValue: any;
+    private _isValueWidget;
+    private isValueWidget;
+    onValueChanged: Subject<{
+        sender: AXPBaseWidgetComponent;
+    }>;
+    protected fullPath: _angular_core.WritableSignal<string | null>;
+    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 dataSource: _angular_core.WritableSignal<AXDataSource<unknown>>;
+    protected textField: _angular_core.Signal<string>;
+    protected valueField: _angular_core.Signal<string>;
+    selectedItems: _angular_core.WritableSignal<any[]>;
+    private rf;
+    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;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPColumnWidgetComponent<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPColumnWidgetComponent<any>>;
+}
+
+type AXPWidgetRendererDirectiveOptions = AXPMetaData;
+declare class AXPWidgetRendererDirective {
+    parentNode: _angular_core.InputSignal<AXPLayoutWidgetComponent | 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: _ngrx_signals.DeepSignal<{}>;
+        state: _angular_core.Signal<_acorex_platform_layout_builder.AXPLayoutContextState>;
+        initialSnapshot: _ngrx_signals.DeepSignal<{}>;
+        previousSnapshot: _ngrx_signals.DeepSignal<{}>;
+        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>;
+        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;
+    private viewContainerRef;
+    protected isLoading: WritableSignal<boolean>;
+    private instance;
+    private expressionCache;
+    private expressionEvaluators;
+    private scope;
+    private componentRef;
+    private onContextChanged;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    private rerenderComponent;
+    ngOnDestroy(): void;
+    private loadComponent;
+    private applyOptions;
+    private checkFormulaForUpdate;
+    preprocessAndInitialOptions(obj: any, pathPrefix?: string): void;
+    updateOptionsBasedOnContext(): Promise<number>;
+    updateValueBasedOnFormula(): Promise<void>;
+    private evaluateExpression;
+    private getGlobalScope;
+    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>;
+    /**
+     * @ignore
+     */
+    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 AXPWidgetContainerComponent, typeof AXPWidgetColumnRendererComponent, typeof AXPWidgetRendererDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXPLayoutBuilderModule>;
+}
+
+interface AXPWidgetDataSource<T = any> {
+    name: string;
+    title: string;
+    valueField: string;
+    textField: string;
+    columns: {
+        name: string;
+        title: string;
+    }[];
+    samples?: any[];
+    source: () => AXDataSource<T> | Promise<AXDataSource<T>>;
+}
+interface AXPWidgetDataSourceProvider {
+    items(): Promise<AXPWidgetDataSource[]>;
+}
+declare const AXP_WIDGET_DATASOURCE_PROVIDER: InjectionToken<AXPWidgetDataSourceProvider[]>;
+declare class AXPWidgetDataSourceProviderService implements AXPWidgetDataSourceProvider {
+    private providers;
+    items(): Promise<AXPWidgetDataSource[]>;
+    get(name: string): Promise<AXPWidgetDataSource | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetDataSourceProviderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPWidgetDataSourceProviderService>;
+}
+
+interface AXPMetaDataDefinition {
+    name: string;
+    title: string;
+    defaultValue?: any;
+    interface: string | AXPWidgetNode | (() => Promise<AXPWidgetNode>);
+}
+
+declare const AXPWidgetsCatalog: AXPWidgetTypesMap;
+
+export { AXPBaseWidgetComponent, AXPColumnWidgetComponent, AXPDataListWidgetComponent, AXPLayoutBuilderContextStore, AXPLayoutBuilderModule, AXPLayoutBuilderService, AXPLayoutContextChangeEvent, AXPLayoutElement, AXPLayoutWidgetComponent, AXPPageStatus, AXPValueWidgetComponent, AXPWidgetColumnRendererComponent, AXPWidgetContainerComponent, AXPWidgetDataSourceProviderService, 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_DATASOURCE_PROVIDER, AXP_WIDGET_TOKEN, cloneProperty, createBooleanProperty, createNumberProperty, createSelectProperty, createStringProperty };
+export type { AXPExtractWidgetConfig, AXPLayoutBuilderModuleConfigs, AXPLayoutBuilderStatusChangedEvent, AXPLayoutContextState, AXPLayoutElementAPI, AXPMetaDataDefinition, AXPWidgetCategory, AXPWidgetColumnNode, AXPWidgetColumnNodeToken, AXPWidgetComponentConfig, AXPWidgetConfig, AXPWidgetConfigComponents, AXPWidgetDataSource, AXPWidgetDataSourceProvider, AXPWidgetDesignerOptionsMap, AXPWidgetGroup, AXPWidgetNode, AXPWidgetNodeToken, AXPWidgetProperty, AXPWidgetPropertyGroup, AXPWidgetRenderMode, AXPWidgetRendererDirectiveOptions, AXPWidgetTypesMap, AXPWidgetViewType, extendedWidget };