import * as _angular_core from '@angular/core';
import { Signal, InjectionToken, ComponentRef, OnInit, EventEmitter, TemplateRef, Injector, WritableSignal, SimpleChanges, ModuleWithProviders } from '@angular/core';
import * as _ngrx_signals from '@ngrx/signals';
import * as _acorex_platform_layout_widget_core from '@acorex/platform/layout/widget-core';
import { AXValueChangedEvent, AXDataSource } from '@acorex/cdk/common';
import { AXPOptionsData, AXPDataType, AXPExpression, AXPWidgetTriggers, AXPMetaData, AXPValueTransformerFunctions, AXPValidationRules, AXPPartialNested, AXPExpressionEvaluatorService } from '@acorex/platform/core';
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';

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 AXPWidgetCoreElementAPI = {
    [name: string]: Subject<any> | Function;
};
type AXPWidgetCoreElementAction = {
    title: string;
    command: string;
    icon?: string;
    color?: string;
    disabled?: boolean | string;
    hidden?: boolean | string;
    zone?: 'header' | 'footer';
    placement?: 'prefix' | 'suffix';
    scope?: 'primary' | 'secondary';
};
declare abstract class AXPWidgetCoreElement {
    abstract get id(): string | null;
    abstract get status(): Signal<AXPWidgetStatus>;
    api(): AXPWidgetCoreElementAPI;
    actions(): AXPWidgetCoreElementAction[];
}
declare class AXPWidgetCoreService {
    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>;
    registeredWidgetsCount: _angular_core.WritableSignal<number>;
    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: AXPWidgetCoreElement): void;
    getWidget(id: string): AXPWidgetCoreElement | 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<AXPWidgetCoreElement | undefined>;
    /**
     * Returns a list of registered widget ids (names).
     */
    listRegisteredWidgetNames(): string[];
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetCoreService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPWidgetCoreService>;
}

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' | 'utility-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",
    UtilityWidget = "utility-widget"
}

interface AXPWidgetTypesMap {
    timeDuration: 'time-duration';
    checkbox: 'checkbox-editor';
    color: 'color-editor';
    connectedLists: 'connected-lists-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';
    schedulerPicker: 'scheduler-picker';
    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';
    timeDurationFilter: 'time-duration-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';
    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';
    icon: 'icon';
    themeColorChooser: 'theme-color-chooser';
    panel: 'panel';
    notification: 'notification';
    taskBoard: 'task-board';
    comment: 'comment';
    list: 'list-editor';
    dataList: 'data-list';
    listToolbar: 'list-toolbar';
    entityList: 'entity-list';
    stepWizard: 'step-wizard';
    documentUploader: 'document-uploader';
    editorJs: 'editor-js-editor';
    progressBar: 'progress-bar-editor';
    rate: 'rate-picker-editor';
}

interface AXPWidgetPropertyGroup {
    name: string;
    title: string;
    order: number;
}
interface AXPWidgetProperty {
    name: string;
    title: string;
    description?: string;
    group: AXPWidgetPropertyGroup;
    order?: number;
    /**
     * Controls whether the property title label is shown in the property viewer panel.
     * Defaults to true when omitted.
     */
    showLabel?: boolean;
    schema: {
        dataType: AXPDataType;
        nullable?: boolean;
        defaultValue?: any | string | ((context: any | null) => any);
        interface: Required<Pick<AXPWidgetNode, 'path'>> & Omit<AXPWidgetNode, 'path'>;
    };
    validations?: AXPValidationRules;
    visible: boolean;
    binding?: {
        enabled: boolean;
        /** When set, the expression is edited at path + '.' + optionKey (e.g. options.visibility). */
        optionKey?: string;
    };
}
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;
    mode?: AXPWidgetRenderMode;
    path?: string;
    name?: string;
    visible?: boolean | AXPExpression;
    defaultValue?: any;
    children?: AXPWidgetNode[];
    options?: AXPOptionsData;
    triggers?: AXPWidgetTriggers;
    meta?: AXPMetaData;
    valueTransforms?: AXPValueTransformerFunctions;
}
interface AXPWidgetNodeToken<TOptions extends AXPOptionsData = AXPOptionsData> {
    defaultValue?: any;
    config: AXPWidgetConfig;
    node: AXPWidgetNode;
    options?: TOptions;
}
interface AXPWidgetColumnNode {
    type: string;
    path: string;
    options?: AXPOptionsData;
}
interface AXPWidgetColumnNodeToken extends AXPWidgetColumnNode {
    config: AXPWidgetConfig;
}
declare const AXP_WIDGET_TOKEN: InjectionToken<AXPWidgetNodeToken<Record<string, any>>>;
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' | 'time-duration-filter' | string;
}
interface extendedWidget {
    widget: AXPWidgetConfig;
    parentName: string;
}
type AXPWidgetRenderMode = keyof AXPWidgetConfigComponents;
interface AXPLayoutBuilderStatusChangedEvent {
    status: AXPPageStatus;
}

type AXPClassMap = Readonly<Record<string, boolean>>;
type AXPStyleMap = Readonly<Record<string, string | number>>;
declare abstract class AXPBaseWidgetComponent<TOptions extends Record<string, unknown> = AXPOptionsData> extends AXPWidgetCoreElement {
    #private;
    protected readonly token: AXPWidgetNodeToken<TOptions>;
    readonly host: HTMLDivElement;
    protected readonly layoutService: AXPWidgetCoreService;
    protected readonly contextService: {
        data: _angular_core.Signal<{}>;
        state: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPWidgetCoreContextState>;
        initialSnapshot: _angular_core.Signal<{}>;
        previousSnapshot: _angular_core.Signal<{}>;
        lastChange: _ngrx_signals.DeepSignal<_acorex_platform_layout_widget_core.AXPWidgetCoreContextChangeEvent>;
        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_widget_core.AXPWidgetCoreContextChangeEvent>;
        update: (path: string, value: any) => void;
        patch: (context: {}, skipDirtyTracking?: boolean) => void;
        reset: () => void;
        set: (initialData: any) => void;
        getValue: (path: string) => any;
        hasValue: (path: string) => boolean;
    } & _ngrx_signals.StateSource<{
        data: {};
        state: _acorex_platform_layout_widget_core.AXPWidgetCoreContextState;
        initialSnapshot: {};
        previousSnapshot: {};
        lastChange: _acorex_platform_layout_widget_core.AXPWidgetCoreContextChangeEvent;
    }>;
    readonly config: _acorex_platform_layout_widget_core.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<TOptions>;
    options: _angular_core.Signal<TOptions>;
    onOptionsChanged: Subject<{
        sender: AXPBaseWidgetComponent;
    }>;
    private _status;
    status: _angular_core.Signal<AXPWidgetStatus>;
    readonly onStatusChanged: BehaviorSubject<AXPWidgetStatus>;
    isBusy: _angular_core.Signal<boolean>;
    parent: AXPLayoutBaseWidgetComponent<any> | 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: Partial<TOptions>): 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<any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPBaseWidgetComponent<any>>;
}
declare abstract class AXPLayoutBaseWidgetComponent<TOptions extends AXPOptionsData = AXPOptionsData> extends AXPBaseWidgetComponent<TOptions> {
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLayoutBaseWidgetComponent<any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPLayoutBaseWidgetComponent<any>>;
}
declare abstract class AXPValueWidgetComponent<T = any | null, TOptions extends AXPOptionsData = AXPOptionsData> extends AXPLayoutBaseWidgetComponent<TOptions> 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>;
    ngOnInit(): void;
    getValue: _angular_core.Signal<T>;
    protected validationRules: _angular_core.Signal<AXPValidationRules>;
    protected extractValue(path: string): any;
    setValue(value: T | null | undefined): void;
    protected detectFullPath(): void;
    protected handleValueChanged(e: AXValueChangedEvent<T>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPValueWidgetComponent<any, any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPValueWidgetComponent<any, any>>;
}
declare abstract class AXPDataListWidgetComponent extends AXPValueWidgetComponent<any> {
    private dataService;
    protected textField: _angular_core.Signal<string>;
    protected valueField: _angular_core.Signal<string>;
    protected textTemplate: _angular_core.Signal<string | undefined>;
    protected dataSource: _angular_core.WritableSignal<AXDataSource<any>>;
    selectedItems: _angular_core.WritableSignal<any[]>;
    /**
     * Track the last loaded string dataSource reference to prevent infinite loops
     * Only used for string-based datasources (not arrays or AXDataSource instances)
     */
    private lastStringDataSourceRef;
    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: Record<string, any>;
    protected readonly rawValue: T;
    protected readonly rowData: any;
    protected readonly nullText: any;
    protected readonly nullValue: T;
    protected value: () => 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>;
}

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>;
}

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;
}
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;
    };
    static parseGridTemplate(gridTemplate: string): number;
    static createGridTemplate(repetitionCount: number): string;
}
declare function findNonEmptyBreakpoints<T>(values: AXPBreakpointValues<T>): AXPBreakpoints[];

/**
 * Helper class for serializing and deserializing AXPWidgetNode to/from JSON
 */
declare class AXPWidgetSerializationHelper {
    /**
     * Removes non-serializable properties from widget node
     * @param node - The widget node to clean
     * @param options - Serialization options
     * @returns Cleaned widget node ready for JSON serialization
     */
    private static cleanNode;
    /**
     * Recursively removes functions from object properties
     */
    private static removeFunctions;
    /**
     * Converts AXPWidgetNode to JSON string
     * @param node - The widget node to serialize
     * @param options - Serialization options
     * @returns JSON string representation of the widget node
     */
    static toJson(node: AXPWidgetNode, options?: {
        removeMeta?: boolean;
        removeFunctions?: boolean;
        pretty?: boolean;
    }): string;
    /**
     * Converts JSON string to AXPWidgetNode
     * @param json - JSON string to deserialize
     * @returns Parsed AXPWidgetNode object
     * @throws Error if JSON is invalid or doesn't match AXPWidgetNode structure
     */
    static fromJson(json: string): AXPWidgetNode;
    /**
     * Removes meta property from widget node (similar to designer service)
     * @param node - The widget node to process
     * @returns Widget node without meta property
     */
    static removeMeta(node: AXPWidgetNode): AXPWidgetNode;
}

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 AXPWidgetCoreContextState = 'initiated' | 'restored' | 'changed' | 'patch';
declare class AXPWidgetCoreContextChangeEvent {
    oldValue?: any;
    newValue?: any;
    path?: string;
    state: AXPWidgetCoreContextState;
    data: any;
}
declare const AXPWidgetCoreContextStore: _angular_core.Type<{
    data: _angular_core.Signal<{}>;
    state: _angular_core.Signal<AXPWidgetCoreContextState>;
    initialSnapshot: _angular_core.Signal<{}>;
    previousSnapshot: _angular_core.Signal<{}>;
    lastChange: _ngrx_signals.DeepSignal<AXPWidgetCoreContextChangeEvent>;
    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<AXPWidgetCoreContextChangeEvent>;
    update: (path: string, value: any) => void;
    patch: (context: {}, skipDirtyTracking?: boolean) => void;
    reset: () => void;
    set: (initialData: any) => void;
    getValue: (path: string) => any;
    hasValue: (path: string) => boolean;
} & _ngrx_signals.StateSource<{
    data: {};
    state: AXPWidgetCoreContextState;
    initialSnapshot: {};
    previousSnapshot: {};
    lastChange: AXPWidgetCoreContextChangeEvent;
}>>;

declare class AXPWidgetContainerComponent {
    readonly contextService: {
        data: _angular_core.Signal<{}>;
        state: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPWidgetCoreContextState>;
        initialSnapshot: _angular_core.Signal<{}>;
        previousSnapshot: _angular_core.Signal<{}>;
        lastChange: _ngrx_signals.DeepSignal<AXPWidgetCoreContextChangeEvent>;
        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<AXPWidgetCoreContextChangeEvent>;
        update: (path: string, value: any) => void;
        patch: (context: {}, skipDirtyTracking?: boolean) => void;
        reset: () => void;
        set: (initialData: any) => void;
        getValue: (path: string) => any;
        hasValue: (path: string) => boolean;
    } & _ngrx_signals.StateSource<{
        data: {};
        state: _acorex_platform_layout_widget_core.AXPWidgetCoreContextState;
        initialSnapshot: {};
        previousSnapshot: {};
        lastChange: AXPWidgetCoreContextChangeEvent;
    }>;
    readonly builderService: AXPWidgetCoreService;
    readonly onContextChanged: EventEmitter<AXPWidgetCoreContextChangeEvent>;
    set context(value: any);
    set functions(v: any);
    constructor();
    status: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPPageStatus>;
    isBusy: _angular_core.Signal<boolean>;
    refresh(): void;
    find(name: string): Promise<_acorex_platform_layout_widget_core.AXPWidgetCoreElement | 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;
    /**
     *
     */
    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;
    private expressionEvaluator;
    customExpandIcon: string;
    customCollapseIcon: string;
    customWidth: string;
    private _node;
    get node(): AXPWidgetColumnNode;
    set node(v: AXPWidgetColumnNode);
    private mergedOptions;
    protected loadingRow: _angular_core.WritableSignal<null>;
    private rowInjectorsCache;
    private hasExpressions;
    private pendingEvaluations;
    private changeDetectionScheduled;
    private readonly MAX_CACHE_SIZE;
    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>;
    /**
     * Check if options contain any expressions that need evaluation
     */
    private checkForExpressions;
    /**
     * Get cache key for row data - optimized to avoid JSON.stringify when possible
     */
    private getCacheKey;
    /**
     * Schedule change detection (debounced to batch multiple updates)
     */
    private scheduleChangeDetection;
    /**
     * Limit cache size using simple FIFO eviction
     */
    private evictCacheIfNeeded;
    getInputs(data: any): any;
    getRowInjector(data: any): Injector;
    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<Record<string, any>> | null | undefined>;
    index: _angular_core.InputSignal<number | null | undefined>;
    mode: _angular_core.InputSignal<keyof _acorex_platform_layout_widget_core.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;
    }>;
    onLoad: _angular_core.OutputEmitterRef<{
        sender: AXPWidgetRendererDirective;
        widget: AXPBaseWidgetComponent;
    }>;
    /**
     * Signal that emits the component reference when it's ready
     */
    private _componentRefSignal;
    componentRefSignal: _angular_core.Signal<ComponentRef<any> | null>;
    protected mergedOptions: WritableSignal<any>;
    private injector;
    protected builderService: AXPWidgetCoreService;
    protected contextService: {
        data: _angular_core.Signal<{}>;
        state: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPWidgetCoreContextState>;
        initialSnapshot: _angular_core.Signal<{}>;
        previousSnapshot: _angular_core.Signal<{}>;
        lastChange: _ngrx_signals.DeepSignal<_acorex_platform_layout_widget_core.AXPWidgetCoreContextChangeEvent>;
        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_widget_core.AXPWidgetCoreContextChangeEvent>;
        update: (path: string, value: any) => void;
        patch: (context: {}, skipDirtyTracking?: boolean) => void;
        reset: () => void;
        set: (initialData: any) => void;
        getValue: (path: string) => any;
        hasValue: (path: string) => boolean;
    } & _ngrx_signals.StateSource<{
        data: {};
        state: _acorex_platform_layout_widget_core.AXPWidgetCoreContextState;
        initialSnapshot: {};
        previousSnapshot: {};
        lastChange: _acorex_platform_layout_widget_core.AXPWidgetCoreContextChangeEvent;
    }>;
    protected widgetRegistery: AXPWidgetRegistryService;
    protected unsubscriber: AXUnsubscriber;
    protected translateService: AXTranslationService;
    protected widgetService: AXPWidgetRegistryService;
    protected expressionEvaluator: AXPExpressionEvaluatorService;
    private viewContainerRef;
    protected isLoading: WritableSignal<boolean>;
    protected isVisible: WritableSignal<boolean>;
    instance: AXPValueWidgetComponent;
    private expressionEvaluators;
    private componentRef;
    private renderTimeoutId;
    private hasInitialRender;
    private onContextChanged;
    private onLoadEvent;
    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;
    private hasVisibilityDependency;
    ngOnChanges(changes: SimpleChanges): void;
    private rerenderComponent;
    ngOnDestroy(): void;
    private loadComponent;
    private applyOptions;
    private hasOptionsChanged;
    preprocessAndInitialOptions(obj: any, pathPrefix?: string): void;
    updateOptionsBasedOnContext(): Promise<number>;
    updateVisibility(): Promise<void>;
    private show;
    private hide;
    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"; "onLoad": "onLoad"; }, never, never, false, never>;
}

interface AXPWidgetCoreModuleConfigs {
    widgets?: AXPWidgetConfig[];
    extendedWidgets?: extendedWidget[];
}
declare class AXPWidgetCoreModule {
    static forRoot(config?: AXPWidgetCoreModuleConfigs): ModuleWithProviders<AXPWidgetCoreModule>;
    static forChild(config?: AXPWidgetCoreModuleConfigs): ModuleWithProviders<AXPWidgetCoreModule>;
    /**
     * @ignore
     */
    constructor(instances: any[]);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetCoreModule, [{ optional: true; }]>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXPWidgetCoreModule, [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<AXPWidgetCoreModule>;
}

interface AXPMetaDataDefinition {
    name: string;
    title: string;
    defaultValue?: any;
    interface: string | AXPWidgetNode | (() => Promise<AXPWidgetNode>);
}

declare const AXPWidgetsCatalog: AXPWidgetTypesMap;

export { AXPBaseWidgetComponent, AXPBlockBaseLayoutWidgetComponent, AXPBoxModelLayoutWidgetComponent, AXPColumnWidgetComponent, AXPDataListWidgetComponent, AXPFlexBaseLayoutWidgetComponent, AXPFlexItemBaseLayoutWidgetComponent, AXPGridBaseLayoutWidgetComponent, AXPGridItemBaseLayoutWidgetComponent, AXPInlineBaseLayoutWidgetComponent, AXPLayoutBaseWidgetComponent, AXPPageStatus, AXPPropertyEditorHelper, AXPTableBaseLayoutWidgetComponent, AXPTableItemBaseLayoutWidgetComponent, AXPTableItemOpsBaseLayoutWidgetComponent, AXPValueWidgetComponent, AXPWidgetColumnRendererComponent, AXPWidgetContainerComponent, AXPWidgetCoreContextChangeEvent, AXPWidgetCoreContextStore, AXPWidgetCoreElement, AXPWidgetCoreModule, AXPWidgetCoreService, AXPWidgetGroupEnum, AXPWidgetRegistryService, AXPWidgetRendererDirective, AXPWidgetSerializationHelper, 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, AXPLayoutBuilderStatusChangedEvent, AXPMetaDataDefinition, AXPPropertyCorners, AXPPropertyEditorCornerValues, AXPPropertyEditorSideGeneric, AXPPropertyEditorSideValues, AXPPropertySides, AXPSpacingBox, AXPSpacingBoxString, AXPStyleMap, AXPWidgetCategory, AXPWidgetColumnNode, AXPWidgetColumnNodeToken, AXPWidgetComponentConfig, AXPWidgetConfig, AXPWidgetConfigComponents, AXPWidgetCoreContextState, AXPWidgetCoreElementAPI, AXPWidgetCoreElementAction, AXPWidgetCoreModuleConfigs, AXPWidgetDesignerOptionsMap, AXPWidgetGroup, AXPWidgetNode, AXPWidgetNodeToken, AXPWidgetProperty, AXPWidgetPropertyGroup, AXPWidgetRenderMode, AXPWidgetRendererDirectiveOptions, AXPWidgetTypesMap, AXPWidgetViewType, extendedWidget };
