ngx-dynamic-entity-builder 1.3.0 → 1.5.0

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "ngx-dynamic-entity-builder",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Angular standalone visual builder for authoring dynamic-entity EntityConfig (fields, tabs, validators, RBAC).",
+  "//typings": "Local workspace resolution only: ng-packagr 21 writes types/ngx-dynamic-entity-builder.d.ts into dist/package.json. Do NOT add a 'main' field here — ng-packagr does not generate one, so it would be copied verbatim and resolve wrongly in the published package.",
+  "typings": "types/ngx-dynamic-entity-builder.d.ts",
   "peerDependencies": {
     "@angular/cdk": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
     "@angular/common": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
     "@angular/core": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
     "@angular/forms": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
     "@angular/material": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
-    "@dynamic-entity/core": "^1.3.0",
-    "ngx-dynamic-entity": "^1.3.0",
+    "@dynamic-entity/core": "^1.5.0",
+    "ngx-dynamic-entity": "^1.5.0",
     "rxjs": "^7.0.0"
   },
   "keywords": [
@@ -33,18 +35,16 @@
   },
   "author": "Nizamudeen",
   "module": "fesm2022/ngx-dynamic-entity-builder.mjs",
-  "typings": "index.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./index.d.ts",
-      "esm2022": "./esm2022/ngx-dynamic-entity-builder.mjs",
-      "esm": "./esm2022/ngx-dynamic-entity-builder.mjs",
+      "types": "./types/ngx-dynamic-entity-builder.d.ts",
       "default": "./fesm2022/ngx-dynamic-entity-builder.mjs"
     }
   },
+  "type": "module",
   "dependencies": {
     "tslib": "^2.3.0"
   }

package/types/ngx-dynamic-entity-builder.d.ts

@@ -0,0 +1,582 @@
+import * as _angular_core from '@angular/core';
+import { OnChanges, EventEmitter, SimpleChanges } from '@angular/core';
+import { NestedTabConfig, NestedFieldConfig, EntityFormConfig, FormRule, EntityPermissions, RichFieldType, FlagValidator, ParamValidator, DropdownOption, EntityReferenceConfig, AutoPatchMapping, PatchOnTrueMapping, CommonModuleEntry, FieldTypeMeta, RuleOperator } from '@dynamic-entity/core';
+export { AutoPatchConfig, AutoPatchMapping, DropdownOption, EntityFormConfig, EntityPermissions, EntityReferenceConfig, FIELD_TYPE_CATALOG, FieldTypeMeta, FlagValidator, FormRule, NestedFieldConfig, NestedTabConfig, ParamValidator, PatchOnTrueMapping, RichFieldType, RuleAction, RuleCondition, RuleOperator, createFieldConfig, getFieldTypeMeta, humanizeId } from '@dynamic-entity/core';
+import * as ngx_dynamic_entity from 'ngx-dynamic-entity';
+export { SYSTEM_DEFAULT_CAN_EDIT } from 'ngx-dynamic-entity';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+
+interface BuilderProblem {
+    level: 'error' | 'warning';
+    message: string;
+    fieldId?: string;
+}
+/** One tab's own fields, for a canvas that has to reorder within the right tab. */
+interface BuilderFieldGroup {
+    tabId: string;
+    label: NestedTabConfig['label'];
+    fields: NestedFieldConfig[];
+}
+declare class BuilderStore {
+    private readonly _config;
+    private readonly _selectedFieldId;
+    private readonly _activeLanguage;
+    /** Rules live beside the config: they are persisted per form, not inside `EntityFormConfig`. */
+    private readonly _rules;
+    /**
+     * Field ids the author owns — set by an explicit rename, or by loading a saved config
+     * whose ids are already live data keys. Ids outside this set are still derived from the
+     * field's label. Builder-session state, deliberately not part of the exported config.
+     */
+    private readonly manualIds;
+    /**
+     * Fields whose `refererField` the config declared, rather than the builder stamping it.
+     *
+     * A declared path is a deliberate binding override and must survive a structural edit. A
+     * stamped one is just the field's address, so it has to be rewritten when the field moves.
+     * Without the distinction, restamping would destroy the override and not restamping would
+     * leave a moved field pointing at where it used to be.
+     */
+    private readonly authoredRefs;
+    private readonly _isDirty;
+    /**
+     * Roles of the person using the builder — distinct from `availableRoles`, which is the
+     * vocabulary a schema may reference. Needed so the SYSTEM_DEFAULT_CAN_EDIT predicate can
+     * be asked a real question; it was previously called with a hardcoded empty array, which
+     * made any role-checking predicate answer false for everyone.
+     */
+    private readonly _userRoles;
+    readonly config: _angular_core.Signal<EntityFormConfig>;
+    readonly selectedFieldId: _angular_core.Signal<string>;
+    readonly activeLanguage: _angular_core.Signal<string>;
+    readonly rules: _angular_core.Signal<FormRule[]>;
+    readonly isDirty: _angular_core.Signal<boolean>;
+    readonly userRoles: _angular_core.Signal<string[]>;
+    readonly tabs: _angular_core.Signal<NestedTabConfig[]>;
+    /**
+     * Every field the config declares, sub-tabs included.
+     *
+     * This used to stop at top-level tabs, which quietly broke three things at once: nine of
+     * `insuranceClaims`'s twenty-eight fields never appeared on the canvas, the entity-reference
+     * picker could not offer a nested field as a source, and the drift check looked a nested
+     * field up here, got nothing, and returned without checking. The store's structural
+     * operations already walked the whole tree — only this view did not.
+     *
+     * It deliberately does not descend into a field's own `children`: `group` and `array`
+     * children are rendered by the row that owns them, not as rows of their own.
+     */
+    readonly fields: _angular_core.Signal<NestedFieldConfig[]>;
+    /**
+     * The same fields, kept in their owning tab.
+     *
+     * Drag-and-drop reorders by index, so the canvas needs to know which tab an index belongs
+     * to — `reorderField` has always taken a `tabId` for exactly this, and the canvas simply
+     * never passed one. Without the grouping a drag on any config with more than one tab
+     * reordered `tabs[0]` regardless of what was actually dragged.
+     */
+    readonly fieldGroups: _angular_core.Signal<BuilderFieldGroup[]>;
+    readonly selectedField: _angular_core.Signal<NestedFieldConfig>;
+    readonly problems: _angular_core.Signal<BuilderProblem[]>;
+    readonly errors: _angular_core.Signal<BuilderProblem[]>;
+    readonly isValid: _angular_core.Signal<boolean>;
+    load(config: EntityFormConfig): void;
+    reset(entity?: string): void;
+    resetDirty(): void;
+    private emptyConfig;
+    setEntityName(entity: string): void;
+    setDefaultLanguage(language: string): void;
+    setMaskData(mask: boolean): void;
+    setPermission(action: keyof EntityPermissions, roles: string[]): void;
+    setActiveLanguage(language: string): void;
+    /** Roles of the person using the builder, for SYSTEM_DEFAULT_CAN_EDIT. */
+    setUserRoles(roles: string[]): void;
+    private getAllFields;
+    /**
+     * Every tab in the tree, flattened.
+     *
+     * The structural operations below used to iterate `draft.tabs` directly, which is only
+     * the top level. A field on a sub-tab could be selected and edited but never removed,
+     * duplicated, moved or reordered — the builder could author nested configs it was then
+     * unable to restructure, which is the worst possible state for an authoring tool.
+     */
+    private flattenTabs;
+    /**
+     * Every field id in the config, including `group`/`array` children.
+     *
+     * Id uniqueness is a whole-config invariant, not a per-tab one: rules, `showWhen`
+     * conditions and `autoPatch` mappings all address fields by bare id, so two fields
+     * sharing an id anywhere in the tree interfere with each other. Uniqueness checks must
+     * therefore see deeper than `fields()`, which stops at a tab's own fields.
+     */
+    private allFieldIds;
+    private findFieldInTabs;
+    addField(type: RichFieldType, targetTabId?: string): string;
+    updateField(id: string, patch: Partial<NestedFieldConfig>): void;
+    /**
+     * Rename a field explicitly, pinning the id so it is no longer derived from the label.
+     *
+     * Not reachable from the inspector — the id input is read-only by design. This exists for
+     * programmatic callers that must match an id to an existing data key.
+     */
+    renameField(oldId: string, newId: string): void;
+    /** Whether this field's id is pinned (loaded from storage or explicitly renamed). */
+    hasManualId(id: string): boolean;
+    /**
+     * Move a field to a new id and repoint every id-based reference in the config at it.
+     *
+     * Ids are the wiring between fields — rules, cascades, patches and `showWhen` all address
+     * fields by id — so a rename that only touches `field.id` silently breaks that wiring.
+     * That was survivable while renaming was a rare manual act; label-derived ids make it
+     * routine, so the references move with it.
+     */
+    private applyRename;
+    removeField(id: string): void;
+    duplicateField(id: string): string | null;
+    moveField(id: string, direction: -1 | 1): void;
+    /**
+     * Moves a field to another tab, keeping its id.
+     *
+     * The builder could add, remove, duplicate and reorder a field but never relocate one, so
+     * a field authored on the wrong tab had to be deleted and rebuilt — losing its validators,
+     * options and any rule that pointed at it.
+     *
+     * The field's `refererField` changes, because it is an address and the field now has a new one.
+     * `mutate` restamps it and repoints the rules that named it, so a move does not silently
+     * strand them.
+     */
+    moveFieldToTab(id: string, targetTabId: string): boolean;
+    /** Safe reorder for drag & drop within active tab or flat list */
+    reorderField(fromIndex: number, toIndex: number, tabId?: string): void;
+    selectField(id: string | null): void;
+    /**
+     * Set a field's label, and derive the field's id from it: type "Employee Count", get
+     * `employeeCount`. The inspector renders the id read-only, so this is the only way a
+     * new field's id is set.
+     *
+     * Two things stop derivation: a config loaded from storage (its ids are live data keys
+     * that records are already stored under — see `load`), and an explicit `renameField`
+     * call, which remains available to programmatic callers.
+     *
+     * Only the config's default language drives the id; translating a label must not rename
+     * anything.
+     */
+    setFieldLabel(id: string, language: string, value: string): void;
+    /** `derived`, or `derived_2`, `derived_3`… if another field already holds it. */
+    private availableId;
+    setFieldPlaceholder(id: string, language: string, value: string): void;
+    toggleFlagValidator(id: string, validator: FlagValidator, on: boolean): void;
+    setParamValidator(id: string, validator: ParamValidator, value: number | null): void;
+    getParamValidator(field: NestedFieldConfig, validator: ParamValidator): number | null;
+    hasFlagValidator(field: NestedFieldConfig, validator: FlagValidator): boolean;
+    /**
+     * Where a choice field's options come from.
+     *
+     * `entity` is absent on purpose: in this model an entity reference is a field *type*
+     * (`entity-ref`), not a data source a dropdown can switch to, so offering it here would mean
+     * mutating the field's type — and rebuilding its control — from a source picker. The
+     * exclusion that matters within a choice field is inline `options` vs `listName`.
+     */
+    fieldDataSource(field: NestedFieldConfig | undefined): 'none' | 'manual' | 'lookup';
+    /**
+     * Switch a choice field's data source, clearing the one it is leaving.
+     *
+     * The reference makes these mutually exclusive (doc §4.4) and it has to stay that way here:
+     * `optionsFor` resolves inline options first, so a field left holding both would silently
+     * ignore its list.
+     */
+    setFieldDataSource(fieldId: string, source: 'none' | 'manual' | 'lookup'): void;
+    /** Set the named list a choice field reads its options from. */
+    setListName(fieldId: string, listName: string): void;
+    /** Link a field to a field defined in another entity configuration (Phase 8). */
+    linkReferencedField(fieldId: string, sourceEntityKey: string, sourceField: NestedFieldConfig): void;
+    /** Unlink a referenced field back to an independent field. */
+    unlinkReferencedField(fieldId: string): void;
+    /** Sync a drifted referenced field with the updated source field definition. */
+    syncReferencedField(fieldId: string, currentSourceField: NestedFieldConfig): void;
+    /** Scan all referenced fields in the config and update their hasDrift state against current source configs. */
+    checkDrift(sourceConfigs: Record<string, EntityFormConfig>): void;
+    addOption(fieldId: string): void;
+    /** Merge language keys into an option. `setOptionLabel` is the usual single-language path. */
+    updateOption(fieldId: string, index: number, patch: DropdownOption): void;
+    /**
+     * Set an option's text for one language.
+     *
+     * An option is a language-keyed object and the displayed text **is** the stored value,
+     * so this is the only way to edit one — there is no separate value to set.
+     */
+    setOptionLabel(fieldId: string, index: number, language: string, value: string): void;
+    removeOption(fieldId: string, index: number): void;
+    /** Merge a patch into a field's `entityReference` block, keeping it enabled. */
+    updateEntityReference(fieldId: string, patch: Partial<EntityReferenceConfig>): void;
+    addAutoPatchMapping(fieldId: string): void;
+    setAutoPatchTargetTab(fieldId: string, targetTab: string): void;
+    updateAutoPatchMapping(fieldId: string, index: number, patch: Partial<AutoPatchMapping>): void;
+    /** Removing the last mapping drops `autoPatch` entirely — no empty config in the export. */
+    removeAutoPatchMapping(fieldId: string, index: number): void;
+    addPatchOnTrueMapping(fieldId: string): void;
+    updatePatchOnTrueMapping(fieldId: string, index: number, patch: Partial<PatchOnTrueMapping>): void;
+    removePatchOnTrueMapping(fieldId: string, index: number): void;
+    /** Replace a field's `showWhen` map; an empty map removes the condition. */
+    setShowWhen(fieldId: string, showWhen: Record<string, unknown> | undefined): void;
+    /** Rules for the field currently selected in the inspector. */
+    /**
+     * Rules attached to the selected field, whichever way they name it.
+     *
+     * New rules are authored with the field's path — `[work.address]` — because a bare id
+     * cannot distinguish two fields that share one. Rules written before paths existed name it
+     * by id, and those must keep showing up here or editing an older config would look like it
+     * had lost its rules.
+     */
+    readonly rulesForSelectedField: _angular_core.Signal<FormRule[]>;
+    loadRules(rules: FormRule[]): void;
+    addRule(rule: FormRule): string;
+    updateRule(id: string, patch: Partial<FormRule>): void;
+    removeRule(id: string): void;
+    toggleRule(id: string, enabled: boolean): void;
+    /** Move a rule in priority order. Priorities are renumbered 1..n so they stay contiguous. */
+    moveRule(id: string, direction: -1 | 1): void;
+    exportRules(): FormRule[];
+    addTab(): string;
+    /** Every tab id in the tree, at any depth. Tab ids must be globally unique — they are paths. */
+    private allTabIds;
+    addSubTab(parentId: string): string;
+    setPrimaryTab(tabId: string): void;
+    updateTab(id: string, patch: Partial<NestedTabConfig>): void;
+    setTabLabel(id: string, language: string, value: string): void;
+    removeTab(id: string): void;
+    moveTab(id: string, direction: -1 | 1): void;
+    exportConfig(): EntityFormConfig;
+    /**
+     * The single choke point for a structural edit, and therefore the one place refs are kept
+     * true.
+     *
+     * `refererField` is a field's address, so it changes whenever the structure around it does —
+     * moving a field to another tab, or into a group, gives it a new one. Rules address fields
+     * by ref, so a move that only restamped the field would leave every rule pointing at an
+     * address nothing occupies. Both happen here, together, or the config is inconsistent
+     * between them.
+     */
+    private mutate;
+    /**
+     * Rewrites the address of every field the builder owns, leaving declared overrides alone.
+     *
+     * `assignFieldRefs` only fills in a missing path, which is right when a config arrives and
+     * wrong after a move: the field already has a path, and it is now the wrong one.
+     */
+    private restampFieldPaths;
+    /** Field id → the refs it currently has. A duplicated id has more than one. */
+    private refsById;
+    /**
+     * Rewrites rules that pointed at a ref a move has just changed.
+     *
+     * A field is matched by its id: if exactly one ref for that id disappeared and exactly one
+     * appeared, that is the move and the rules follow it. Anything less clear-cut — two fields
+     * sharing an id where one moved — is left alone rather than guessed at, because rewriting
+     * the wrong rule is worse than leaving one to be repointed by hand.
+     */
+    private repointRulesForMovedFields;
+    /**
+     * Replace one field, copying only the objects on the path to it.
+     *
+     * `mutate` deep-clones the entire config, which is right for a structural edit but wrong
+     * for the two setters bound to keystroke events: typing a label allocated a full copy of
+     * the config per character. Here every tab and field outside the target's chain is reused
+     * by reference, so the cost is proportional to nesting depth rather than config size —
+     * while the parts that did change are still fresh objects, so change detection and the
+     * signal both see a new identity.
+     *
+     * Returns without touching anything when the field is not found.
+     */
+    private mutateField;
+    private uniqueId;
+    private validate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BuilderStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BuilderStore>;
+}
+
+/**
+ * EntityBuilderComponent — the top-level visual builder for an EntityFormConfig.
+ */
+declare class EntityBuilderComponent implements OnChanges {
+    protected readonly store: BuilderStore;
+    /**
+     * Optional: only apps that registered a CONFIG_SOURCE have one. Used to drop the cached
+     * copy of a config the moment it is edited — see `doSave`.
+     */
+    private readonly configSource;
+    /** Existing config to edit. When omitted, the builder starts blank. */
+    config?: EntityFormConfig;
+    /** Languages available for label/placeholder editing. First entry is the default. */
+    languages: string[];
+    /** Optional role list — enables multi-select role pickers for RBAC instead of free text. */
+    availableRoles: string[];
+    /**
+     * Roles of the person using the builder. Distinct from `availableRoles`, which is the
+     * vocabulary a schema may reference. Passed to the `SYSTEM_DEFAULT_CAN_EDIT` predicate so
+     * it can decide whether this user may edit system-default tabs.
+     */
+    userRoles: string[];
+    /** Optional common-module definitions for module tabs; defaults to the built-in list from core. */
+    commonModules: readonly CommonModuleEntry[];
+    /** Emitted on every change to the working config. */
+    configChange: EventEmitter<EntityFormConfig>;
+    /** Emitted when the user clicks Save. Carries a clean, deep-cloned config. */
+    save: EventEmitter<EntityFormConfig>;
+    protected readonly rbacActions: (keyof EntityPermissions)[];
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    protected doSave(): void;
+    protected get json(): string;
+    protected copyJson(): void;
+    protected rolesFor(action: keyof EntityPermissions): readonly string[];
+    protected setRoles(action: keyof EntityPermissions, roles: string[]): void;
+    /** Parse a comma-separated role string into a trimmed, de-duplicated array. */
+    protected setRolesFromText(action: keyof EntityPermissions, text: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityBuilderComponent, "ngx-entity-builder", never, { "config": { "alias": "config"; "required": false; }; "languages": { "alias": "languages"; "required": false; }; "availableRoles": { "alias": "availableRoles"; "required": false; }; "userRoles": { "alias": "userRoles"; "required": false; }; "commonModules": { "alias": "commonModules"; "required": false; }; }, { "configChange": "configChange"; "save": "save"; }, never, ["[ngxBuilderPreview]"], true, never>;
+}
+
+/**
+ * FieldPaletteComponent — the list of buildable field types (Angular Material).
+ */
+declare class FieldPaletteComponent {
+    readonly catalog: readonly FieldTypeMeta[];
+    pick: EventEmitter<RichFieldType>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldPaletteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldPaletteComponent, "ngx-field-palette", never, {}, { "pick": "pick"; }, never, never, true, never>;
+}
+
+/** One choosable field: the reference stored, the label shown, and the path behind it. */
+interface FieldPathOption {
+    value: string;
+    label: string;
+    path: string;
+}
+/**
+ * Every field in the config, offered by path.
+ *
+ * Four places in the builder name a field — `showWhen` keys, `patchOnTrue` mappings,
+ * `autoPatch` targets and rule triggers/targets — and each was a free-text box. Typing an id
+ * is the one way left to author an ambiguous reference: ids are unique per scope, so
+ * `address` names nothing in particular once two tabs have one. Choosing from this list
+ * always yields a path.
+ *
+ * `collectFieldScopes` rather than the tab-level view, so a field nested inside a `group` is
+ * offered too, and every entry carries the scope `refOf` needs.
+ */
+declare function fieldPathOptions(config: EntityFormConfig | null | undefined, language: string): FieldPathOption[];
+/**
+ * The options plus whatever is already selected.
+ *
+ * A reference written before paths existed is a bare id, and one written against a field
+ * since deleted is a path nothing answers to. Neither appears in the list, and a `mat-select`
+ * silently drops a value it has no option for — so opening such a config and saving it would
+ * quietly erase the reference. They are kept, and shown as they are.
+ */
+declare function withExistingOptions(options: readonly FieldPathOption[], current: readonly (string | undefined)[]): FieldPathOption[];
+
+/**
+ * FieldInspectorComponent — edits every property of the currently selected field.
+ */
+declare class FieldInspectorComponent {
+    protected readonly store: BuilderStore;
+    protected readonly field: _angular_core.Signal<NestedFieldConfig>;
+    protected readonly meta: _angular_core.Signal<FieldTypeMeta>;
+    protected lang(): string;
+    protected toNum(value: unknown): number | null;
+    protected labelValue(field: NestedFieldConfig): string;
+    protected placeholderValue(field: NestedFieldConfig): string;
+    protected optionLabel(option: DropdownOption): string;
+    /**
+     * Every tab a field can live on, sub-tabs included.
+     *
+     * `moveFieldToTab` existed on the store with nothing calling it, so a field authored on the
+     * wrong tab had to be deleted and rebuilt — losing its validators, options and every rule
+     * aimed at it.
+     */
+    protected readonly tabOptions: _angular_core.Signal<{
+        id: string;
+        label: string;
+    }[]>;
+    /**
+     * The tab the selected field currently sits on.
+     *
+     * Looked up by identity rather than parsed out of the path: the scope of
+     * `incident.incidentDetails.incidentTime` is two segments and the field belongs to the
+     * *last* of them, while a field inside a group has the group id in that position and
+     * belongs to no tab of that name at all.
+     */
+    protected currentTabId(field: NestedFieldConfig): string;
+    protected moveToTab(field: NestedFieldConfig, tabId: string): void;
+    /**
+     * Fields offered wherever this inspector names one — the `showWhen` key and both ends of a
+     * `patchOnTrue` mapping. All three were free text, which is the one way left to write a
+     * reference that names two fields at once.
+     */
+    protected readonly fieldOptions: _angular_core.Signal<FieldPathOption[]>;
+    /** Options plus whatever is already selected, so an unknown reference is never dropped. */
+    protected optionsWith(...current: (string | undefined)[]): FieldPathOption[];
+    protected showWhenEntries(field: NestedFieldConfig): {
+        key: string;
+        display: string;
+    }[];
+    /**
+     * Seeds a new condition with the first field not already watched.
+     *
+     * It used to seed the literal string `field`, which is not a field id at all — so a new
+     * condition started out referencing nothing and silently hid the field until it was edited.
+     */
+    protected addShowWhen(field: NestedFieldConfig): void;
+    protected renameShowWhen(field: NestedFieldConfig, oldKey: string, newKey: string): void;
+    protected setShowWhenValue(field: NestedFieldConfig, key: string, raw: string): void;
+    protected removeShowWhen(field: NestedFieldConfig, key: string): void;
+    /**
+     * `showWhen` compares with `!==`, so the authored type has to survive the round trip:
+     * "true"/"false" become booleans and numeric text becomes a number.
+     */
+    private parseShowWhen;
+    private stringifyShowWhen;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldInspectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldInspectorComponent, "ngx-field-inspector", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * TabManagerComponent — add / rename / reorder / remove tabs & sub-tabs with systemDefault protection.
+ */
+declare class TabManagerComponent {
+    protected readonly store: BuilderStore;
+    private readonly canEditSystemDefaultsFn;
+    protected lang(): string;
+    protected tabLabel(tab: {
+        label?: any;
+    }): string;
+    protected canEditTab(tab: NestedTabConfig): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabManagerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabManagerComponent, "ngx-tab-manager", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * RuleFormComponent — dialog/panel form for creating or editing a FormRule.
+ */
+declare class RuleFormComponent {
+    private readonly store;
+    rule: FormRule;
+    save: EventEmitter<FormRule>;
+    cancel: EventEmitter<void>;
+    readonly operators: RuleOperator[];
+    protected readonly fieldOptions: _angular_core.Signal<FieldPathOption[]>;
+    /**
+     * Methods, not `computed`. Both read `rule`, which is a plain `@Input` object mutated in
+     * place rather than a signal — a computed would cache the first evaluation and never see a
+     * different rule being edited.
+     */
+    protected triggerOptions(): FieldPathOption[];
+    protected targetOptions(): FieldPathOption[];
+    private cachedTargets;
+    /**
+     * Field targets only — a rule may also target a tab, which this picker does not manage.
+     *
+     * The array identity is held stable while the contents are unchanged. This is bound through
+     * `[ngModel]` on a multi-select, and a fresh array on each call made `ngModel` see a new
+     * value on every change-detection pass: it wrote, which scheduled another pass, which built
+     * another array. Opening the rule editor locked the browser outright.
+     */
+    protected targetValues(): string[];
+    /**
+     * Replaces the field targets, leaving any tab target untouched.
+     *
+     * Rebuilding `targets` wholesale from this picker would drop tab targets, which it never
+     * offered and so cannot know about.
+     */
+    protected setTargets(ids: string[]): void;
+    addCondition(): void;
+    removeCondition(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RuleFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RuleFormComponent, "ngx-rule-form", never, { "rule": { "alias": "rule"; "required": false; }; }, { "save": "save"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+/**
+ * FieldRulesListComponent — the rules attached to the selected field: view, reorder,
+ * enable/disable, edit, delete. `RuleFormComponent` authors one rule; this owns the set.
+ */
+declare class FieldRulesListComponent {
+    protected readonly store: BuilderStore;
+    /** The rule currently open in the editor — a new draft or a copy of an existing rule. */
+    protected readonly editing: _angular_core.WritableSignal<FormRule>;
+    protected startCreate(): void;
+    protected startEdit(rule: FormRule): void;
+    protected commit(rule: FormRule): void;
+    /** One-line human summary: `status EQUAL "archived" → hide`. */
+    protected summarize(rule: FormRule): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldRulesListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldRulesListComponent, "ngx-field-rules-list", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * EntityReferenceConfigComponent — authors the `entityReference` block of an entity-ref field:
+ * registry key, display fields, static filters, and the parent→child cascade.
+ *
+ * Also authors `autoPatch`, since the mappings only make sense against the record the
+ * selected reference returns.
+ */
+declare class EntityReferenceConfigComponent {
+    protected readonly store: BuilderStore;
+    protected readonly field: _angular_core.Signal<NestedFieldConfig>;
+    /** Sibling fields that can drive a cascade — anything but this field itself. */
+    protected readonly parentCandidates: _angular_core.Signal<NestedFieldConfig[]>;
+    private readonly fieldOptions;
+    /**
+     * Cascade parents, offered by path.
+     *
+     * The picker existed but its values were bare ids, which name a field only while no second
+     * scope reuses the id — so the one control that was already a list could still produce an
+     * ambiguous reference.
+     */
+    protected parentOptions(): FieldPathOption[];
+    /** Options plus whatever is already selected, so an unknown reference is never dropped. */
+    protected optionsWith(...current: (string | undefined)[]): FieldPathOption[];
+    private readonly filtersParseError;
+    protected readonly filtersError: _angular_core.Signal<string>;
+    protected ref(field: NestedFieldConfig): ngx_dynamic_entity.EntityReferenceConfig;
+    protected patchRef(field: NestedFieldConfig, patch: Record<string, unknown>): void;
+    protected fieldLabel(field: NestedFieldConfig): string;
+    protected tabLabel(tabId: string): string;
+    protected displayFieldsText(field: NestedFieldConfig): string;
+    protected setDisplayFields(field: NestedFieldConfig, value: string): void;
+    protected filtersText(field: NestedFieldConfig): string;
+    /** Invalid JSON is reported inline and left unapplied rather than silently dropped. */
+    protected setFilters(field: NestedFieldConfig, value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityReferenceConfigComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityReferenceConfigComponent, "ngx-entity-reference-config", never, {}, {}, never, never, true, never>;
+}
+
+declare class EntityBuilderCanvasComponent {
+    protected readonly store: BuilderStore;
+    /**
+     * Headings only earn their space once the fields are actually split across tabs. A
+     * single-tab config — the common case, and every existing spec — renders exactly as before.
+     */
+    protected showTabHeadings(): boolean;
+    protected groupLabel(group: BuilderFieldGroup): string;
+    protected onDrop(tabId: string, event: CdkDragDrop<unknown>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityBuilderCanvasComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityBuilderCanvasComponent, "ngx-entity-builder-canvas", never, {}, {}, never, never, true, never>;
+}
+
+declare class EntityBuilderTreeNodeComponent {
+    protected readonly store: BuilderStore;
+    field: NestedFieldConfig;
+    index: number;
+    totalCount: number;
+    protected fieldTypeLabel(type: string): string;
+    protected fieldTypeIcon(type: string): string;
+    protected fieldLabel(field: {
+        id: string;
+        label?: any;
+    }): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityBuilderTreeNodeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityBuilderTreeNodeComponent, "ngx-entity-builder-tree-node", never, { "field": { "alias": "field"; "required": true; }; "index": { "alias": "index"; "required": true; }; "totalCount": { "alias": "totalCount"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+export { BuilderStore, EntityBuilderCanvasComponent, EntityBuilderComponent, EntityBuilderTreeNodeComponent, EntityReferenceConfigComponent, FieldInspectorComponent, FieldPaletteComponent, FieldRulesListComponent, RuleFormComponent, TabManagerComponent, fieldPathOptions, withExistingOptions };
+export type { BuilderFieldGroup, BuilderProblem, FieldPathOption };