ngx-form-designer 0.0.23

package/lib/form-designer/designer-state.service.d.ts

@@ -0,0 +1,167 @@
+import { FormSchema, WidgetKind, LayoutNode, WidgetNode, FieldSchema, DesignerFlavor } from '../form-core/models';
+import { WidgetDefinition } from '../widgets/widget-definition';
+import type { DesignerSectionDefinition } from '../plugins/section-definition';
+import * as i0 from "@angular/core";
+export interface InternalDragData {
+    type: 'new-widget' | 'new-section';
+    widgetType?: string;
+    widgetKind?: WidgetKind;
+    widgetId?: string;
+    section?: DesignerSectionDefinition;
+}
+interface DragDropEventLike {
+    previousContainer: unknown;
+    container: unknown;
+    previousIndex: number;
+    currentIndex: number;
+    item: {
+        data: unknown;
+    };
+}
+type LayoutIndexEntry = {
+    node: LayoutNode;
+    parentId: string | null;
+    path: string[];
+    index: number;
+    scopePath: string[];
+    rawNodeId: string;
+};
+type LayoutIndex = Record<string, LayoutIndexEntry>;
+export declare class DesignerStateService {
+    private readonly widgetDefs;
+    readonly activeFlavor: import("@angular/core").WritableSignal<DesignerFlavor>;
+    readonly schema: import("@angular/core").WritableSignal<FormSchema>;
+    readonly selectedNodeId: import("@angular/core").WritableSignal<string | null>;
+    readonly selectedNodeIds: import("@angular/core").WritableSignal<string[]>;
+    readonly contextMenu: import("@angular/core").WritableSignal<{
+        x: number;
+        y: number;
+    } | null>;
+    readonly activeBreakpoint: import("@angular/core").WritableSignal<"xs" | "sm" | "md" | "lg" | "xl" | "2xl">;
+    readonly isPreviewMode: import("@angular/core").WritableSignal<boolean>;
+    readonly isLeftPanelCollapsed: import("@angular/core").WritableSignal<boolean>;
+    readonly activeDevice: import("@angular/core").Signal<"mobile" | "desktop">;
+    readonly activeThemeId: import("@angular/core").WritableSignal<string>;
+    readonly isReadOnly: import("@angular/core").WritableSignal<boolean>;
+    readonly clipboard: import("@angular/core").WritableSignal<{
+        nodes: LayoutNode[];
+        fields: FieldSchema[];
+        scopePath: string[];
+    } | null>;
+    private readonly history;
+    private readonly historyIndex;
+    private readonly historyLength;
+    private readonly maxHistory;
+    readonly canUndo: import("@angular/core").Signal<boolean>;
+    readonly canRedo: import("@angular/core").Signal<boolean>;
+    constructor();
+    readonly layoutIndex: import("@angular/core").Signal<LayoutIndex>;
+    readonly selectedNode: import("@angular/core").Signal<LayoutNode | null>;
+    readonly selectedField: import("@angular/core").Signal<FieldSchema | null>;
+    updateSchema(schema: FormSchema): void;
+    setFlavor(flavor: DesignerFlavor): void;
+    setIsReadOnly(readonly: boolean): void;
+    toggleLeftPanel(): void;
+    undo(): void;
+    redo(): void;
+    selectNode(id: string | null): void;
+    toggleNodeSelection(id: string): void;
+    isNodeSelected(nodeId: string): boolean;
+    composeScopedNodeId(scopePath: string[], nodeId: string): string;
+    getSelectedScopeFields(): FieldSchema[];
+    isSelectionInScope(scopePath: string[]): boolean;
+    openContextMenu(position: {
+        x: number;
+        y: number;
+    }): void;
+    closeContextMenu(): void;
+    private setSchema;
+    copy(): void;
+    cut(): void;
+    paste(): void;
+    deleteSelected(): void;
+    private collectFields;
+    private ensureSelectionIsValid;
+    private recordHistory;
+    private restoreSnapshot;
+    findNode(root: LayoutNode, id: string): LayoutNode | null;
+    /** Get the path of nodes from root to target (for breadcrumb) */
+    getNodePath(nodeId: string): {
+        id: string;
+        label: string;
+        type: string;
+    }[];
+    private getNodeLabel;
+    addFieldWidget(field: FieldSchema, widgetNode: WidgetNode, targetColId: string): void;
+    private insertNodeIntoLayout;
+    handleDrop(event: DragDropEventLike, targetColId: string): void;
+    pushField(widgetDef: WidgetDefinition): void;
+    private resolveWidgetDefinition;
+    private createFieldFromWidget;
+    pushStructure(type: 'row' | '2col'): void;
+    /** Remove a column by its id */
+    removeColumn(columnId: string): void;
+    /** Set preset column layout (e.g., 3,4,6) on a row */
+    setPresetLayout(rowId: string, preset: number): void;
+    /** Add one or more columns to a row */
+    addColumn(rowId: string, count?: number): void;
+    /** Move a node up or down within its parent container */
+    moveNode(nodeId: string, direction: 'up' | 'down'): void;
+    /** Duplicate a node (row, col, or widget) */
+    duplicateNode(nodeId: string): void;
+    /** Delete a node (row, col, or widget) and associated field if widget */
+    deleteNode(nodeId: string): void;
+    duplicateField(fieldId: string): void;
+    removeField(fieldId: string): void;
+    updateField(fieldId: string, updates: Partial<FieldSchema>): void;
+    groupSelectedFields(): string | null;
+    ungroupSelectedFields(): void;
+    canGroupSelectedFields(): boolean;
+    canUngroupSelectedFields(): boolean;
+    private getSelectedWidgetFields;
+    /**
+     * Update a specific node's style without cloning the entire tree.
+     * Only the path from root to the target node gets new references.
+     */
+    updateNodeStyle(nodeId: string, style: Record<string, unknown>): void;
+    /**
+     * Update a specific node's responsive settings.
+     */
+    updateNodeResponsive(nodeId: string, responsive: Record<string, number | undefined>): void;
+    /**
+     * Immutable tree update - only creates new references along the path to target.
+     * Returns the original node if no changes were made (preserves reference equality).
+     */
+    private updateNodeInTree;
+    private resolveEntry;
+    private resolveSchemaAtScope;
+    private findFieldByIdInScope;
+    private resolveInsertionScopePath;
+    private resolveTargetColumnForFieldInsert;
+    private findFirstColumn;
+    private selectedNodeScopePath;
+    private findFieldLocation;
+    private sameScope;
+    private isScopePrefix;
+    private cloneValue;
+    private isLayoutNode;
+    private detachNode;
+    private findWidgetByRefId;
+    private findParentCol;
+    private removeWidgetByRefId;
+    /**
+     * Insert a new Row (with default column structure) into a specific Column.
+     * Useful for creating nested grids.
+     */
+    insertRowInColumn(columnId: string, colCount?: 1 | 2): void;
+    /**
+     * Wrap an existing widget in a new Row -> Column structure.
+     * Replaces the widget's current position with the new Row,
+     * and puts the widget inside the new Row's Column.
+     */
+    wrapWidgetInRow(widgetId: string): void;
+    private findParentAndIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesignerStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DesignerStateService>;
+}
+export {};

package/lib/form-designer/dynamic-properties/dynamic-properties.component.d.ts

@@ -0,0 +1,92 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { PropertySection, PropertyField, PropertyFieldType } from '../../widgets/widget-definition';
+import { FieldSchema } from '../../form-core/models';
+import * as i0 from "@angular/core";
+export declare class DynamicPropertiesComponent implements OnChanges {
+    onPropertyChange?: () => void;
+    private readonly designerCtx;
+    get properties(): PropertySection[];
+    getFieldReferenceCandidates(field: PropertyField): FieldSchema[];
+    config: any;
+    readOnly: boolean;
+    includeSections: string[] | null;
+    excludeSections: string[] | null;
+    allFields: FieldSchema[];
+    configChange: EventEmitter<any>;
+    openSections: {
+        [key: string]: boolean;
+    };
+    nameDraft: string;
+    nameError: string;
+    private nameDraftDirty;
+    private lastConfigId;
+    private lastConfigName;
+    ngOnChanges(changes: SimpleChanges): void;
+    isSectionOpen(section: PropertySection, index: number): boolean;
+    toggleSection(label: string, index: number): void;
+    private didSelectedFieldChange;
+    private syncOpenSections;
+    getValue(key: string): any;
+    setValue(key: string, value: any): void;
+    isBasicInput(type: PropertyFieldType): boolean;
+    isNameField(field: PropertyField): boolean;
+    isGroupKeyField(field: PropertyField): boolean;
+    onNameDraftChange(value: string): void;
+    commitNameField(): void;
+    getGroupKeyOptions(): string[];
+    getGroupKeyListId(field: PropertyField): string;
+    private getNameError;
+    private getAllFields;
+    private getSafeOptionValue;
+    getDimensionPaths(field: PropertyField): [string, string];
+    onDimensionChange(field: PropertyField, value: {
+        width: any;
+        height: any;
+    }): void;
+    getBoxModelPath(field: PropertyField, key: string): string;
+    onBoxModelChange(field: PropertyField, value: {
+        marginTop?: any;
+        marginRight?: any;
+        marginBottom?: any;
+        marginLeft?: any;
+        paddingTop?: any;
+        paddingRight?: any;
+        paddingBottom?: any;
+        paddingLeft?: any;
+        borderWidth?: any;
+        width?: any;
+        height?: any;
+    }): void;
+    getEdgePaths(field: PropertyField): {
+        top: string;
+        right: string;
+        bottom: string;
+        left: string;
+    };
+    onEdgeChange(field: PropertyField, value: {
+        top: any;
+        right: any;
+        bottom: any;
+        left: any;
+    }): void;
+    handleFieldChange(): void;
+    buildCustomInputs(field: PropertyField): {
+        config: any;
+        getValue: (path: string) => any;
+        setValue: (path: string, value: any) => void;
+        onChange: () => void;
+    };
+    private setValues;
+    addOption(path: string): void;
+    removeOption(path: string, index: number): void;
+    updateOption(path: string, index: number, field: string, value: any): void;
+    addValidator(path: string): void;
+    removeValidator(path: string, index: number): void;
+    updateValidator(path: string, index: number, field: string, value: any): void;
+    getValidatorLabel(name: string): string;
+    enableConditional(path: string): void;
+    disableConditional(path: string): void;
+    updateConditional(path: string, field: string, value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPropertiesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPropertiesComponent, "app-dynamic-properties", never, { "onPropertyChange": { "alias": "onPropertyChange"; "required": false; }; "config": { "alias": "config"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "includeSections": { "alias": "includeSections"; "required": false; }; "excludeSections": { "alias": "excludeSections"; "required": false; }; "allFields": { "alias": "allFields"; "required": false; }; }, { "configChange": "configChange"; }, never, never, true, never>;
+}

package/lib/form-designer/events-panel/events-panel.component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from '@angular/core';
+import { FieldSchema, WidgetEventBinding, WidgetEventType, WidgetEventAction } from '../../form-core/models';
+import * as i0 from "@angular/core";
+export declare class EventsPanelComponent {
+    config: FieldSchema;
+    allFields: FieldSchema[];
+    configChange: EventEmitter<FieldSchema>;
+    eventTypes: WidgetEventType[];
+    get bindings(): WidgetEventBinding[];
+    get availableFields(): FieldSchema[];
+    addEvent(): void;
+    removeEvent(index: number): void;
+    addAction(binding: WidgetEventBinding): void;
+    removeAction(binding: WidgetEventBinding, index: number): void;
+    asSetValue(action: WidgetEventAction): any;
+    asLog(action: WidgetEventAction): any;
+    emitChange(): void;
+    private emitUpdate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventsPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EventsPanelComponent, "app-events-panel", never, { "config": { "alias": "config"; "required": false; }; "allFields": { "alias": "allFields"; "required": false; }; }, { "configChange": "configChange"; }, never, never, true, never>;
+}

package/lib/form-designer/events-workspace.component.d.ts

@@ -0,0 +1,125 @@
+import { DesignerEventApiBrowser, DesignerEventApiDefinition, EventsWorkspaceSavePayload, FieldSchema, FormSchema, WidgetEventAction, WidgetEventActionApi, WidgetEventActionLog, WidgetEventActionSetValue, WidgetEventBinding, WidgetEventType } from '../form-core/models';
+import * as i0 from "@angular/core";
+type WorkspaceTab = 'fields' | 'input' | 'output';
+interface WorkspaceFieldItem {
+    id: string;
+    name: string;
+    label: string;
+    type: string;
+    scopePath: string[];
+    scopeLabel: string;
+}
+interface ApiLookupState {
+    items: DesignerEventApiDefinition[];
+    query: string;
+    pageNo: number;
+    hasMore: boolean;
+    loading: boolean;
+    error: string | null;
+    requestId: number;
+    initialized: boolean;
+}
+interface ApiSchemaState {
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    loading: boolean;
+    error: string | null;
+}
+export declare class EventsWorkspaceComponent {
+    readonly schema: import("@angular/core").InputSignal<FormSchema>;
+    readonly readOnly: import("@angular/core").InputSignal<boolean>;
+    readonly eventApis: import("@angular/core").InputSignal<DesignerEventApiDefinition[]>;
+    readonly eventApiBrowser: import("@angular/core").InputSignal<DesignerEventApiBrowser | undefined>;
+    readonly schemaChange: import("@angular/core").OutputEmitterRef<FormSchema>;
+    readonly eventsSave: import("@angular/core").OutputEmitterRef<EventsWorkspaceSavePayload>;
+    readonly draftSchema: import("@angular/core").WritableSignal<FormSchema | null>;
+    readonly fieldSearch: import("@angular/core").WritableSignal<string>;
+    readonly selectedFieldId: import("@angular/core").WritableSignal<string | null>;
+    readonly expandedEventId: import("@angular/core").WritableSignal<string | null>;
+    readonly actionTabs: import("@angular/core").WritableSignal<Record<string, WorkspaceTab>>;
+    readonly actionFieldQueries: import("@angular/core").WritableSignal<Record<string, string>>;
+    readonly apiLookupState: import("@angular/core").WritableSignal<Record<string, ApiLookupState>>;
+    readonly apiSchemaState: import("@angular/core").WritableSignal<Record<string, ApiSchemaState>>;
+    readonly eventTypes: WidgetEventType[];
+    readonly currentSchema: import("@angular/core").Signal<FormSchema>;
+    readonly fields: import("@angular/core").Signal<WorkspaceFieldItem[]>;
+    readonly filteredFields: import("@angular/core").Signal<WorkspaceFieldItem[]>;
+    readonly selectedFieldItem: import("@angular/core").Signal<WorkspaceFieldItem | null>;
+    readonly selectedField: import("@angular/core").Signal<FieldSchema | null>;
+    readonly selectedFieldEvents: import("@angular/core").Signal<WidgetEventBinding[]>;
+    readonly availableTargetFields: import("@angular/core").Signal<WorkspaceFieldItem[]>;
+    readonly availableSourceFields: import("@angular/core").Signal<WorkspaceFieldItem[]>;
+    constructor();
+    selectField(fieldId: string): void;
+    addEventBinding(): void;
+    removeEventBinding(bindingIndex: number): void;
+    updateBindingEnabled(bindingIndex: number, enabled: boolean): void;
+    updateBindingType(bindingIndex: number, type: WidgetEventType): void;
+    addAction(binding: WidgetEventBinding): void;
+    removeAction(bindingIndex: number, actionIndex: number): void;
+    setActionType(action: WidgetEventAction, type: WidgetEventAction['type']): void;
+    updateActionType(bindingIndex: number, actionIndex: number, type: WidgetEventAction['type']): void;
+    patchAction(bindingIndex: number, actionIndex: number, patch: Partial<WidgetEventActionSetValue> | Partial<WidgetEventActionLog> | Partial<WidgetEventActionApi>): void;
+    patchApiAction(action: WidgetEventAction, patch: Partial<WidgetEventActionApi>): void;
+    getSelectableActionFields(action: WidgetEventAction): WorkspaceFieldItem[];
+    actionFieldSearch(action: WidgetEventAction): string;
+    setActionFieldSearch(action: WidgetEventAction, query: string): void;
+    apiSearchQuery(action: WidgetEventAction): string;
+    updateApiSearchQuery(action: WidgetEventAction, query: string): Promise<void>;
+    ensureApiOptions(action: WidgetEventAction): void;
+    loadMoreApiOptions(action: WidgetEventAction): Promise<void>;
+    onApiOptionsScroll(event: Event, action: WidgetEventAction): void;
+    getVisibleApiOptions(action: WidgetEventAction): DesignerEventApiDefinition[];
+    isApiOptionsLoading(action: WidgetEventAction): boolean;
+    apiOptionsError(action: WidgetEventAction): string | null;
+    isApiFieldSelected(action: WidgetEventActionApi, fieldId: string): boolean;
+    toggleApiSourceField(action: WidgetEventAction, fieldId: string, checked: boolean): void;
+    activeActionTab(bindingId: string, actionIndex: number): WorkspaceTab;
+    setActionTabForAction(action: WidgetEventAction, tab: WorkspaceTab): void;
+    formatApiInputSchema(action: WidgetEventActionApi): string;
+    formatApiOutputSchema(action: WidgetEventActionApi): string;
+    selectedApiLabel(action: WidgetEventActionApi): string;
+    selectedApiReference(action: WidgetEventActionApi): string;
+    formatApiOptionReference(api: DesignerEventApiDefinition): string;
+    selectApiOption(action: WidgetEventAction, api: DesignerEventApiDefinition): Promise<void>;
+    saveEventConfig(): void;
+    asSetValue(action: WidgetEventAction): WidgetEventActionSetValue;
+    asLog(action: WidgetEventAction): WidgetEventActionLog;
+    asApi(action: WidgetEventAction): WidgetEventActionApi;
+    trackFieldById(_: number, field: WorkspaceFieldItem): string;
+    trackBindingById(_: number, binding: WidgetEventBinding): string;
+    trackActionByIndex(index: number): number;
+    trackApiOption(_: number, api: DesignerEventApiDefinition): string;
+    hasApiAction(binding: WidgetEventBinding): boolean;
+    canSelectApiAction(binding: WidgetEventBinding, actionIndex: number): boolean;
+    isEventExpanded(bindingId: string): boolean;
+    toggleEventExpansion(bindingId: string): void;
+    private getFieldsExcludingSelected;
+    private updateSelectedEvents;
+    private buildActionByType;
+    private flattenFields;
+    private findFieldById;
+    private updateFieldInSchema;
+    private collectFieldSnapshots;
+    private findActionPath;
+    private getActionStorageKey;
+    private actionTabKey;
+    private loadApiOptions;
+    private ensureApiSchema;
+    private loadApiSchema;
+    private getApiSchemaState;
+    private getApiSchemaKey;
+    private createApiLookupState;
+    private searchStaticEventApis;
+    private hasMoreApiResults;
+    private resolveStaticApiSchema;
+    private findApiDefinition;
+    private hydrateApiSchemas;
+    private collectApiActionsFromBindings;
+    private formatJson;
+    private clone;
+    private createEventDatasourceId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventsWorkspaceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EventsWorkspaceComponent, "app-events-workspace", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "eventApis": { "alias": "eventApis"; "required": false; "isSignal": true; }; "eventApiBrowser": { "alias": "eventApiBrowser"; "required": false; "isSignal": true; }; }, { "schemaChange": "schemaChange"; "eventsSave": "eventsSave"; }, never, never, true, never>;
+}
+export {};

package/lib/form-designer/field-palette.component.d.ts

@@ -0,0 +1,99 @@
+import { WidgetDefinition } from '../widgets/widget-definition';
+import { InternalDragData, DesignerStateService } from './designer-state.service';
+import { DesignerSectionDefinition } from '../plugins/section-definition';
+import * as i0 from "@angular/core";
+type PaletteTab = 'pages' | 'sections' | 'widgets' | 'layers';
+type SectionsView = 'library' | 'saved' | 'bricks';
+type PalettePage = {
+    id: string;
+    name: string;
+    route: string;
+};
+type PaletteSavedSectionDefinition = {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+};
+type PaletteBrick = {
+    id: string;
+    name: string;
+    runtime?: 'dom' | 'react';
+    defaultProps?: Record<string, unknown>;
+};
+export declare class FieldPaletteComponent {
+    private _widgets;
+    designerState: DesignerStateService;
+    readonly sectionLibrary: import("@angular/core").InputSignal<DesignerSectionDefinition[] | null>;
+    readonly sectionInsert: import("@angular/core").OutputEmitterRef<DesignerSectionDefinition>;
+    readonly pages: import("@angular/core").InputSignal<PalettePage[] | null>;
+    readonly activePageId: import("@angular/core").InputSignal<string | null>;
+    readonly canRemovePage: import("@angular/core").InputSignal<boolean>;
+    readonly pageAdd: import("@angular/core").OutputEmitterRef<void>;
+    readonly pageSelect: import("@angular/core").OutputEmitterRef<string>;
+    readonly pageRemove: import("@angular/core").OutputEmitterRef<string>;
+    readonly pageRename: import("@angular/core").OutputEmitterRef<{
+        id: string;
+        name: string;
+    }>;
+    readonly pageRouteChange: import("@angular/core").OutputEmitterRef<{
+        id: string;
+        route: string;
+    }>;
+    readonly savedSections: import("@angular/core").InputSignal<PaletteSavedSectionDefinition[] | null>;
+    readonly savedSectionInsert: import("@angular/core").OutputEmitterRef<string>;
+    readonly savedSectionRemove: import("@angular/core").OutputEmitterRef<string>;
+    readonly savedSectionCreateRequested: import("@angular/core").OutputEmitterRef<{
+        name: string;
+    }>;
+    readonly bricks: import("@angular/core").InputSignal<PaletteBrick[] | null>;
+    activeTab: import("@angular/core").WritableSignal<PaletteTab>;
+    sectionsView: import("@angular/core").WritableSignal<SectionsView>;
+    widgetSearchQuery: import("@angular/core").WritableSignal<string>;
+    sectionLibrarySearchQuery: import("@angular/core").WritableSignal<string>;
+    savedSectionSearchQuery: import("@angular/core").WritableSignal<string>;
+    savedSectionName: import("@angular/core").WritableSignal<string>;
+    brickSearchQuery: import("@angular/core").WritableSignal<string>;
+    private readonly injectedSections;
+    private readonly injectedSectionsFlat;
+    allWidgets: import("@angular/core").Signal<WidgetDefinition[]>;
+    filteredFields: import("@angular/core").Signal<WidgetDefinition[]>;
+    filteredStatic: import("@angular/core").Signal<WidgetDefinition[]>;
+    pagesList: import("@angular/core").Signal<PalettePage[]>;
+    activePage: import("@angular/core").Signal<PalettePage | null>;
+    savedSectionsList: import("@angular/core").Signal<PaletteSavedSectionDefinition[]>;
+    filteredSavedSections: import("@angular/core").Signal<PaletteSavedSectionDefinition[]>;
+    canSaveSection: import("@angular/core").Signal<boolean>;
+    sectionLibraryList: import("@angular/core").Signal<DesignerSectionDefinition[]>;
+    filteredSections: import("@angular/core").Signal<DesignerSectionDefinition[]>;
+    sectionGroups: import("@angular/core").Signal<{
+        label: string;
+        items: DesignerSectionDefinition[];
+    }[]>;
+    bricksList: import("@angular/core").Signal<PaletteBrick[]>;
+    showBricks: import("@angular/core").Signal<boolean>;
+    sectionViewOptions: import("@angular/core").Signal<SectionsView[]>;
+    currentSectionView: import("@angular/core").Signal<SectionsView>;
+    filteredBricks: import("@angular/core").Signal<PaletteBrick[]>;
+    brickGroups: import("@angular/core").Signal<{
+        label: string;
+        items: PaletteBrick[];
+    }[]>;
+    tabOptions: import("@angular/core").Signal<PaletteTab[]>;
+    currentTab: import("@angular/core").Signal<PaletteTab>;
+    constructor(_widgets: WidgetDefinition[][], designerState: DesignerStateService);
+    tabLabel(tab: PaletteTab): string;
+    sectionViewLabel(view: SectionsView): string;
+    sectionViewCount(view: SectionsView): number;
+    addField(widget: WidgetDefinition): void;
+    addStructure(type: 'row' | '2col'): void;
+    getDragData(widget: WidgetDefinition): InternalDragData;
+    getSectionDragData(section: DesignerSectionDefinition): InternalDragData;
+    insertSection(section: DesignerSectionDefinition): void;
+    insertBrick(brick: PaletteBrick): void;
+    requestSaveSection(): void;
+    private cloneBrickProps;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldPaletteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FieldPaletteComponent, "app-field-palette", never, { "sectionLibrary": { "alias": "sectionLibrary"; "required": false; "isSignal": true; }; "pages": { "alias": "pages"; "required": false; "isSignal": true; }; "activePageId": { "alias": "activePageId"; "required": false; "isSignal": true; }; "canRemovePage": { "alias": "canRemovePage"; "required": false; "isSignal": true; }; "savedSections": { "alias": "savedSections"; "required": false; "isSignal": true; }; "bricks": { "alias": "bricks"; "required": false; "isSignal": true; }; }, { "sectionInsert": "sectionInsert"; "pageAdd": "pageAdd"; "pageSelect": "pageSelect"; "pageRemove": "pageRemove"; "pageRename": "pageRename"; "pageRouteChange": "pageRouteChange"; "savedSectionInsert": "savedSectionInsert"; "savedSectionRemove": "savedSectionRemove"; "savedSectionCreateRequested": "savedSectionCreateRequested"; }, never, never, true, never>;
+}
+export {};

package/lib/form-designer/form-designer-shell.component.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter, SimpleChanges, OnChanges } from '@angular/core';
+import { FormEngine } from '../form-core/form-engine';
+import { FormSchema, DesignerEventApiBrowser, DesignerEventApiDefinition, DesignerFlavor, EventsWorkspaceSavePayload, WidgetEventApiExecutor } from '../form-core/models';
+import { DesignerStateService } from './designer-state.service';
+import { DesignerTemplateDefinition } from './template-library';
+import { ExternalDataSource } from '../data/external-data-source';
+import * as i0 from "@angular/core";
+export interface FormDesignerShellSchemaMetadata {
+    id?: string;
+    version?: string;
+    title?: string;
+    description?: string;
+}
+export declare class FormDesignerShellComponent implements OnChanges {
+    protected readonly state: DesignerStateService;
+    schema?: FormSchema;
+    schemaMetadata?: FormDesignerShellSchemaMetadata;
+    flavor: DesignerFlavor;
+    flavors: DesignerFlavor[];
+    templates: DesignerTemplateDefinition[];
+    headerLabel?: string;
+    enableTemplateLibrary: boolean;
+    enableGlobalDataManager: boolean;
+    showEditButton: boolean;
+    showSaveButton: boolean;
+    showPushButton: boolean;
+    showEmailPreview: boolean;
+    isReadOnly: boolean;
+    dataSources: ExternalDataSource[];
+    eventApis: DesignerEventApiDefinition[];
+    eventApiBrowser?: DesignerEventApiBrowser;
+    eventApiExecutor?: WidgetEventApiExecutor;
+    flavorChange: EventEmitter<DesignerFlavor>;
+    edit: EventEmitter<FormSchema>;
+    save: EventEmitter<FormSchema>;
+    push: EventEmitter<FormSchema>;
+    eventsSave: EventEmitter<EventsWorkspaceSavePayload>;
+    private catalog;
+    private managedSourceIds;
+    private managedEventSourceIds;
+    showGlobalData: boolean;
+    showTemplateLibrary: boolean;
+    activeWorkspace: 'designer' | 'events';
+    selectedTemplateId: string | null;
+    pendingTemplate: DesignerTemplateDefinition | null;
+    private lastSavedSchemaSnapshot;
+    get engine(): FormEngine;
+    get filteredTemplates(): DesignerTemplateDefinition[];
+    get selectedTemplate(): DesignerTemplateDefinition | null;
+    get resolvedHeaderLabel(): string;
+    ngOnChanges(changes: SimpleChanges): void;
+    private syncDataSources;
+    private syncEventDataSources;
+    private collectEventDataSources;
+    switchFlavor(next: DesignerFlavor): void;
+    openLibrary(): void;
+    closeLibrary(): void;
+    openHomeWorkspace(): void;
+    openEventsWorkspace(): void;
+    onEventsSchemaChange(schema: FormSchema): void;
+    onEventsSave(payload: EventsWorkspaceSavePayload): void;
+    selectTemplate(template: DesignerTemplateDefinition): void;
+    requestApplyTemplate(template: DesignerTemplateDefinition | null): void;
+    confirmApplyTemplate(): void;
+    cancelApplyTemplate(): void;
+    onEdit(): void;
+    onSave(): void;
+    onPush(): void;
+    trackByTemplateId(_index: number, template: DesignerTemplateDefinition): string;
+    trackByFlavor(_index: number, flavor: DesignerFlavor): DesignerFlavor;
+    private shouldConfirmReplace;
+    private hasUnsavedChanges;
+    private serializeSchema;
+    private applyTemplate;
+    private syncTemplateSelection;
+    private createSchemaId;
+    private getResolvedExternalSchema;
+    private applySchemaMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormDesignerShellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormDesignerShellComponent, "app-form-designer-shell", never, { "schema": { "alias": "schema"; "required": false; }; "schemaMetadata": { "alias": "schemaMetadata"; "required": false; }; "flavor": { "alias": "flavor"; "required": false; }; "flavors": { "alias": "flavors"; "required": false; }; "templates": { "alias": "templates"; "required": false; }; "headerLabel": { "alias": "headerLabel"; "required": false; }; "enableTemplateLibrary": { "alias": "enableTemplateLibrary"; "required": false; }; "enableGlobalDataManager": { "alias": "enableGlobalDataManager"; "required": false; }; "showEditButton": { "alias": "showEditButton"; "required": false; }; "showSaveButton": { "alias": "showSaveButton"; "required": false; }; "showPushButton": { "alias": "showPushButton"; "required": false; }; "showEmailPreview": { "alias": "showEmailPreview"; "required": false; }; "isReadOnly": { "alias": "isReadOnly"; "required": false; }; "dataSources": { "alias": "dataSources"; "required": false; }; "eventApis": { "alias": "eventApis"; "required": false; }; "eventApiBrowser": { "alias": "eventApiBrowser"; "required": false; }; "eventApiExecutor": { "alias": "eventApiExecutor"; "required": false; }; }, { "flavorChange": "flavorChange"; "edit": "edit"; "save": "save"; "push": "push"; "eventsSave": "eventsSave"; }, never, never, true, never>;
+}

package/lib/form-designer/form-preview.component.d.ts

@@ -0,0 +1,36 @@
+import { DesignerStateService } from './designer-state.service';
+import { type FieldDataAccessMap, type RuntimeFieldDataAccessApi } from '../data/runtime-field-data-access-registry.service';
+import { DesignerEventApiDefinition, WidgetEventApiExecutor } from '../form-core/models';
+import * as i0 from "@angular/core";
+export declare class FormPreviewComponent {
+    state: DesignerStateService;
+    eventApis: DesignerEventApiDefinition[];
+    eventApiExecutor?: WidgetEventApiExecutor;
+    fieldDataAccessMap?: FieldDataAccessMap;
+    fieldDataAccessApi?: RuntimeFieldDataAccessApi;
+    formContentId?: string;
+    formContentVersion?: string;
+    breakpoints: readonly ["xs", "sm", "md", "lg", "xl", "2xl"];
+    breakpoint: import("@angular/core").WritableSignal<"xs" | "sm" | "md" | "lg" | "xl" | "2xl">;
+    activeDevice: import("@angular/core").Signal<"mobile" | "desktop">;
+    formData: any;
+    combinedFormData: any;
+    constructor(state: DesignerStateService);
+    setBreakpoint(bp: any): void;
+    getContainerWidth(): "100%" | "375px" | "576px" | "768px" | "992px" | "1200px" | "1400px";
+    getPageStyle(): Record<string, any>;
+    close(): void;
+    updateData(data: any): void;
+    updateCombinedData(data: any): void;
+    previewData(): unknown;
+    copyData(): void;
+    private sanitizePreviewData;
+    private isObjectRecord;
+    private shouldHideFileData;
+    private isFileFieldRecord;
+    private isBytePayload;
+    private isBase64Payload;
+    private isLikelyBase64;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormPreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormPreviewComponent, "app-form-preview", never, { "eventApis": { "alias": "eventApis"; "required": false; }; "eventApiExecutor": { "alias": "eventApiExecutor"; "required": false; }; "fieldDataAccessMap": { "alias": "fieldDataAccessMap"; "required": false; }; "fieldDataAccessApi": { "alias": "fieldDataAccessApi"; "required": false; }; "formContentId": { "alias": "formContentId"; "required": false; }; "formContentVersion": { "alias": "formContentVersion"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/form-designer/form-settings-inspector.component.d.ts

@@ -0,0 +1,15 @@
+import { FormSchema, StyleTokenSet } from '../form-core/models';
+import * as i0 from "@angular/core";
+export declare class FormSettingsInspectorComponent {
+    readonly schema: import("@angular/core").InputSignal<FormSchema>;
+    readonly readOnly: import("@angular/core").InputSignal<boolean>;
+    readonly settingsChange: import("@angular/core").OutputEmitterRef<Record<string, any>>;
+    readonly styleChange: import("@angular/core").OutputEmitterRef<Partial<StyleTokenSet>>;
+    readonly tabs: string[];
+    activeTab: import("@angular/core").WritableSignal<string>;
+    currentStyle: import("@angular/core").Signal<StyleTokenSet>;
+    updateSettings(key: string, value: any): void;
+    onStyleChange(style: Partial<StyleTokenSet>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormSettingsInspectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormSettingsInspectorComponent, "form-settings-inspector", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, { "settingsChange": "settingsChange"; "styleChange": "styleChange"; }, never, never, true, never>;
+}