ngx-dynamic-entity 1.3.0 → 1.5.0

package/lib/form/dynamic-record-form.component.d.ts

@@ -1,199 +0,0 @@
-import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
-import { FormGroup } from '@angular/forms';
-import type { EntityFormConfig, FormRule, NestedFieldConfig } from '@dynamic-entity/core';
-import { DynamicFormComponent } from './dynamic-form.component';
-import * as i0 from "@angular/core";
-/**
- * DynamicRecordFormComponent — comprehensive tabbed record view & edit component.
- * Supports cross-tab rule evaluation, profile header, summary drawer (showOnMinimize),
- * interactive quick-jump links, and baseline modification tracking.
- */
-export declare class DynamicRecordFormComponent implements OnChanges {
-    config: EntityFormConfig;
-    rules?: FormRule[];
-    initialData?: Record<string, any>;
-    userRoles: string[];
-    language: string;
-    readonly: boolean;
-    loading: boolean;
-    error: string | null;
-    /** Whole record read-only, regardless of RBAC. Equivalent to the reference's `isReadOnly`. */
-    isReadOnly: boolean;
-    /** Specific field ids forced read-only while the rest of the record stays editable. */
-    readOnlyFields: string[];
-    /**
-     * Open the record read-only, with a per-tab "Edit section" flow — one tab is edited and
-     * validated at a time. This is the framework's `EntityRecordComponent` model and the
-     * default here.
-     *
-     * Set false for a directly editable record with no view/edit distinction.
-     */
-    viewMode: boolean;
-    formSubmit: EventEmitter<Record<string, any>>;
-    formChange: EventEmitter<Record<string, any>>;
-    formReset: EventEmitter<void>;
-    /** One tab section was saved. Carries the whole record, plus which tab was edited. */
-    sectionSave: EventEmitter<{
-        tabId: string;
-        record: Record<string, any>;
-    }>;
-    dynamicFormComp?: DynamicFormComponent;
-    private readonly rulesEvaluation;
-    private readonly host;
-    private readonly injector;
-    readonly currentData: import("@angular/core").WritableSignal<Record<string, any>>;
-    readonly originalBaseline: import("@angular/core").WritableSignal<Record<string, any>>;
-    /**
-     * Info banners the user has dismissed, by field id.
-     *
-     * The reference's contract: an info banner persists until dismissed, **not** until the
-     * value changes. Dismissal is keyed by field so re-triggering a different field's rule
-     * still shows. Re-armed when a different record is loaded.
-     */
-    private readonly dismissed;
-    /**
-     * Info banners from the rules engine that are still showing.
-     *
-     * A getter, not a `computed`: the source is `dynamicFormComp`, a ViewChild. A computed
-     * evaluated before the view initialises would capture no dependency on the child's
-     * `ruleResult` signal and then never recompute. Read per change-detection pass instead.
-     */
-    get infoBanners(): {
-        fieldId: string;
-        message: string;
-    }[];
-    dismissInfoBanner(fieldId: string): void;
-    /** True when nothing in the record may be edited. */
-    get recordReadOnly(): boolean;
-    /**
-     * A row of an `array` field is edited in a drawer, not inline in the tab panel.
-     *
-     * The drawer is rendered outside the tab container on purpose: the reference found that
-     * building a row's FormGroup inside the tab view races the tab's own initialisation, so
-     * the row form is kept detached and only pushed into the FormArray on save.
-     */
-    readonly inlineRowField: import("@angular/core").WritableSignal<any>;
-    readonly inlineRowIndex: import("@angular/core").WritableSignal<number>;
-    inlineRowForm: FormGroup | null;
-    /** `array` fields on the tab currently shown, so the template can list their rows. */
-    get arrayFieldsForActiveTab(): NestedFieldConfig[];
-    /**
-     * Rows currently held by an `array` field, read from the record value.
-     *
-     * Deliberately not read off the child's FormArray: that control only exists once the
-     * child has initialised, so rendering from it changed value mid-pass. `currentData` is a
-     * signal seeded from `initialData` and kept current by the child's `formChange`.
-     */
-    rowsOf(field: NestedFieldConfig): Record<string, unknown>[];
-    /** One row rendered as text, so the list is readable without opening the drawer. */
-    rowSummary(field: NestedFieldConfig, row: Record<string, unknown>): string;
-    openAddRow(field: NestedFieldConfig): void;
-    openEditRow(field: NestedFieldConfig, index: number): void;
-    cancelRow(): void;
-    /** Commit the drawer into the FormArray. Rules re-evaluate off the resulting value change. */
-    saveRow(): void;
-    deleteRow(field: NestedFieldConfig, index: number): void;
-    /**
-     * The tab currently open for editing, or null when the record is being viewed.
-     *
-     * The reference edits one tab section at a time rather than the whole record, and
-     * validates only that section on save — a required field on an untouched tab must not
-     * block saving the tab you are actually working on.
-     */
-    readonly editingTabId: import("@angular/core").WritableSignal<string>;
-    /**
-     * The tab the inner form is showing.
-     *
-     * Tracked here rather than read off the ViewChild. The child resolves its first tab as
-     * part of its own initialisation, so reading it during this component's render changed
-     * value mid-pass — an ExpressionChangedAfterItHasBeenChecked error. Seeded from the
-     * config and kept in step by the child's `activeTabChange` output.
-     */
-    private readonly activeTabIdSig;
-    get activeTabId(): string | null;
-    onActiveTabChange(tabId: string): void;
-    /** First tab a user can see, used to seed the active tab before the child reports one. */
-    private firstVisibleTabId;
-    /** Errors from the last save attempt, by field id. */
-    readonly sectionErrors: import("@angular/core").WritableSignal<Record<string, string>>;
-    /** Template access to `Object.keys` for iterating the error map. */
-    protected readonly Object: ObjectConstructor;
-    get isEditingActiveTab(): boolean;
-    /** Fields render read-only unless their own tab is the one being edited. */
-    get sectionReadOnly(): boolean;
-    editSection(): void;
-    /** Discard this section's edits, restoring each field from the session baseline. */
-    cancelSection(): void;
-    /**
-     * Validate this section only, then emit it. Validation is scoped two ways: Angular
-     * validity of the tab's own controls, and rules filtered to this tab — a rule targeting
-     * a hidden tab must not block the save (the reference's OV0-968 fix).
-     */
-    saveSection(): void;
-    /**
-     * Seed the session baseline from the loaded record so `VALUE_CHANGED` rules and the
-     * modification banner compare against the record as it was opened — not as it was
-     * after the first keystroke.
-     */
-    ngOnChanges(changes: SimpleChanges): void;
-    get recordTitle(): string;
-    get avatarLetter(): string;
-    /** Every field in the config, at any depth. */
-    private allFields;
-    /** The field flagged `isProfileImage`, rendered as the record avatar. */
-    get headerProfileField(): NestedFieldConfig | null;
-    /** The field flagged `isHeaderToggle`, rendered as a status switch in the header. */
-    get headerToggleField(): NestedFieldConfig | null;
-    /** Avatar image URL, when the profile field holds a persisted FileRef. */
-    get profileImageUrl(): string | null;
-    get headerToggleValue(): boolean;
-    /**
-     * Flip the header toggle. It writes straight to the control rather than going through
-     * section editing — the reference treats it as a record-level status switch, not part of
-     * any one tab's section.
-     */
-    toggleHeaderStatus(): void;
-    /** Locate a field's control wherever it lives, since header fields may be on any tab. */
-    private controlFor;
-    /**
-     * A field's current value, read from the record so it is stable during render.
-     *
-     * Resolved through `getTabData` so it honours exactly the nesting contract the form
-     * patches with — `{ tabId: { fieldId } }`, or the record root when the tab sets
-     * `flatData`. Reading the record flat instead is not a shortcut: it makes the summary
-     * display values the form never loaded, which reads as "the data is there" while every
-     * control behind it is empty.
-     *
-     * Walks sub-tabs as well: a summary, header, or profile field may sit on any tab at any
-     * depth.
-     */
-    private fieldValue;
-    readonly isModified: import("@angular/core").Signal<boolean>;
-    readonly summaryFields: import("@angular/core").Signal<NestedFieldConfig[]>;
-    onFormChange(data: Record<string, any>): void;
-    onFormSubmit(data: Record<string, any>): void;
-    onFormReset(): void;
-    formatFieldLabel(field: NestedFieldConfig): string;
-    /** Summary values render through the shared core formatter, not a local stringifier. */
-    formatFieldValue(field: NestedFieldConfig): string;
-    /**
-     * Finds which tab — and, where the field lives one level down, which sub-tab — owns a
-     * field. The walk used to check top-level `fields` only, so every field in a sub-tab was
-     * simply not found and the jump did nothing at all.
-     */
-    private locateField;
-    /**
-     * Switches to the tab holding `fieldId`, then scrolls it into view and moves focus to it.
-     *
-     * The wait for the new tab to render used to be a 50 ms `setTimeout`, which was wrong three
-     * ways: `document` is undefined on a server render, 50 ms is a guess that a large tab can
-     * outrun, and nothing cancelled the timer if the component went away first.
-     * `afterNextRender` fixes all three — it never runs on the server, it runs when the panel
-     * has actually rendered rather than when a guess expires, and it is tied to the injector so
-     * destroying the component cancels it. The query is scoped to this component's own element,
-     * so the library no longer reaches for the global `document` at all.
-     */
-    jumpToField(fieldId: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicRecordFormComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicRecordFormComponent, "ngx-dynamic-record-form", never, { "config": { "alias": "config"; "required": false; }; "rules": { "alias": "rules"; "required": false; }; "initialData": { "alias": "initialData"; "required": false; }; "userRoles": { "alias": "userRoles"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "error": { "alias": "error"; "required": false; }; "isReadOnly": { "alias": "isReadOnly"; "required": false; }; "readOnlyFields": { "alias": "readOnlyFields"; "required": false; }; "viewMode": { "alias": "viewMode"; "required": false; }; }, { "formSubmit": "formSubmit"; "formChange": "formChange"; "formReset": "formReset"; "sectionSave": "sectionSave"; }, never, never, true, never>;
-}

package/lib/providers/provide-field-types.d.ts

@@ -1,24 +0,0 @@
-import { EnvironmentProviders, Type } from '@angular/core';
-/**
- * Field-type registration — the tree-shaking seam.
- *
- * `FieldRegistryService` imports no components. Whatever you register here is what gets
- * bundled, so an app that only uses text/number/dropdown pays for three components and
- * their imports, not nineteen.
- *
- * ```ts
- * // Everything (convenient; bundles all built-ins):
- * provideNgxDynamicEntity(), provideBuiltInFieldTypes()
- *
- * // Only what this app renders:
- * provideFieldTypes({ text: TextFieldComponent, number: NumberFieldComponent })
- * ```
- *
- * Both merge into `FIELD_TYPE_REGISTRY`; later registrations win on key collision.
- */
-/** Map of every built-in field type key → component. Referencing this pulls in all of them. */
-export declare function builtInFieldTypes(): Record<string, Type<any>>;
-/** Register a specific set of field types. Only the components you name are bundled. */
-export declare function provideFieldTypes(types: Record<string, Type<any>>): EnvironmentProviders;
-/** Register all 19 built-in field type keys. Convenience for apps that use most of them. */
-export declare function provideBuiltInFieldTypes(): EnvironmentProviders;

package/lib/providers/provide-ngx-dynamic-entity.d.ts

@@ -1,56 +0,0 @@
-import { EnvironmentProviders, Type } from '@angular/core';
-import type { EntityReferenceLoader, LookupListSource, RecordMigration } from '@dynamic-entity/core';
-import { type HookFn } from '../tokens/injection-tokens';
-export interface NgxDynamicEntityConfig {
-    /** Roles that see masked field values as XXXXXXXXX */
-    maskedRoles?: string[];
-    /** Custom field type components keyed by type string */
-    fieldTypes?: Record<string, Type<any>>;
-    /**
-     * Entity-ref option loaders keyed by entity key.
-     * Each receives `{ parentValue, filters, lang }` and may return an array, Promise, or Observable.
-     */
-    entityRefs?: Record<string, EntityReferenceLoader>;
-    /**
-     * Named master lists keyed by list name, for fields that set `listName`.
-     * Each may be the values themselves (array/Promise/Observable) or a loader function — prefer
-     * a loader for anything fetched, so an unused list is never loaded.
-     */
-    lookups?: Record<string, LookupListSource>;
-    /**
-     * Override the messages shown under invalid fields, keyed by Angular error key. A value is
-     * a string, or a function receiving `(language, error)` when it needs the error's detail.
-     * Unlisted keys keep their English default.
-     */
-    validationMessages?: Record<string, string | ((language: string, error: any) => string)>;
-    /**
-     * Async validator functions keyed by name, for checks that need a server — uniqueness,
-     * availability, a remote rule. Name them from a schema with
-     * `validators: { customAsync: ['uniqueEmail'] }`.
-     *
-     * Each is an Angular `AsyncValidatorFn`: it receives the control and returns a Promise or
-     * Observable of `ValidationErrors | null`. The control is `pending` while it runs, and the
-     * form cannot be submitted until every pending check settles.
-     */
-    asyncValidators?: Record<string, any>;
-    /** Custom validator functions keyed by validator name */
-    validators?: Record<string, any>;
-    /** Hook functions keyed by hook name */
-    hooks?: Record<string, HookFn>;
-    /**
-     * Ordered steps that upgrade a saved record when `EntityFormConfig.version` moves ahead
-     * of the record's `_configVersion`. Applied to `initialData` before the form is patched.
-     */
-    migrations?: RecordMigration[];
-}
-/**
- * Provider function for ngx-dynamic-entity.
- * All options are optional — consumers provide only what they use (ISP).
- *
- * Usage in app.config.ts:
- *   provideNgxDynamicEntity({
- *     maskedRoles: ['IT_SUPPORT'],
- *     entityRefs: { clients: () => clientService.getOptions() },
- *   })
- */
-export declare const provideNgxDynamicEntity: (config?: NgxDynamicEntityConfig) => EnvironmentProviders;

package/lib/services/cascade-data.service.d.ts

@@ -1,45 +0,0 @@
-import type { EntityFormConfig, NestedFieldConfig, ReferenceLoaderContext, ReferenceOption } from '@dynamic-entity/core';
-import * as i0 from "@angular/core";
-/**
- * CascadeDataService — loads entity-reference options and applies parent→child cascades.
- *
- * Loaders come from the registry only. This service owns the three things a
- * field component should not: resolving the loader, coercing whatever it returned
- * (array | Promise | Observable) into a Promise, and filtering by the parent's value.
- */
-export declare class CascadeDataService {
-    private readonly registry;
-    private readonly references;
-    /** Preload runs by formConfigId, so a second call joins the first rather than re-fetching. */
-    private readonly preloads;
-    /** Registry key for a field: explicit `linkedEntityKey`, else the field id. */
-    entityKeyFor(field: NestedFieldConfig): string;
-    /** Whether a loader is registered for this field. */
-    canLoad(field: NestedFieldConfig): boolean;
-    /**
-     * Load the options for a field, cascade-filtered against `parentValue`.
-     * Returns `[]` when no loader is registered, or when a cascade child has no parent value yet.
-     */
-    load(field: NestedFieldConfig, ctx?: ReferenceLoaderContext): Promise<ReferenceOption[]>;
-    /**
-     * Warm the cache for every entity a config's cascades depend on, so changing a parent
-     * resolves from memory instead of a round-trip.
-     *
-     * Idempotent per `formConfigId`: calling it again returns the in-flight or completed run
-     * rather than re-fetching.
-     */
-    initializeCascadeData(formConfigId: string, config: EntityFormConfig, lang?: string): Promise<void>;
-    /** Resolves true once `initializeCascadeData` for this config has finished. */
-    waitForData(formConfigId: string): Promise<boolean>;
-    /**
-     * Child options for a parent selection, from cache only — no load is triggered.
-     * Returns `[]` when the entity has not been preloaded.
-     */
-    getCachedChildOptions(field: NestedFieldConfig, parentValue: unknown, lang?: string): ReferenceOption[];
-    /** Forget the preload for one config. The option cache itself is untouched. */
-    clearCache(formConfigId: string): void;
-    /** Every entity-ref field in the config that participates in a cascade. */
-    private cascadeFields;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CascadeDataService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<CascadeDataService>;
-}

package/lib/services/config-source.service.d.ts

@@ -1,14 +0,0 @@
-import type { EntityFormConfig } from '@dynamic-entity/core';
-import * as i0 from "@angular/core";
-export declare class ConfigSourceService {
-    private readonly cache;
-    private readonly inFlight;
-    private readonly handler?;
-    constructor(handler?: any);
-    /** Retrieve an entity config by key, with caching and in-flight deduplication. */
-    getConfig(entityKey: string): Promise<EntityFormConfig | undefined>;
-    /** Clear cached configs (e.g. after a config edit in the builder). */
-    clearCache(entityKey?: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigSourceService, [{ optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigSourceService>;
-}

package/lib/services/entity-ref-cache.d.ts

@@ -1,27 +0,0 @@
-import type { ReferenceOption } from '@dynamic-entity/core';
-/**
- * Backing store for cached reference options.
- *
- * Pluggable on purpose. The reference implementation kept its cache in a service instance,
- * so every entity label was re-fetched on a browser refresh (issue #22 in the architecture
- * doc). A consumer that wants the cache to survive a reload can back this with
- * sessionStorage; the default keeps it in memory, which is the right call for a library
- * that must not silently persist a tenant's data.
- */
-export interface EntityRefCacheStore {
-    get(key: string): ReferenceOption[] | undefined;
-    set(key: string, value: ReferenceOption[]): void;
-    delete(key: string): void;
-    /** Every key currently held — used for prefix invalidation of one entity. */
-    keys(): string[];
-    clear(): void;
-}
-/** Default in-memory store. Lives as long as the injector that created it. */
-export declare class InMemoryEntityRefCacheStore implements EntityRefCacheStore {
-    private readonly map;
-    get(key: string): ReferenceOption[] | undefined;
-    set(key: string, value: ReferenceOption[]): void;
-    delete(key: string): void;
-    keys(): string[];
-    clear(): void;
-}

package/lib/services/entity-ref-registry.service.d.ts

@@ -1,21 +0,0 @@
-import type { EntityReferenceLoader } from '@dynamic-entity/core';
-import * as i0 from "@angular/core";
-/**
- * EntityRefRegistryService — resolves entity-ref option loader functions.
- * Entity-ref options come ONLY from this registry.
- * Never pass loaders via @Input() on field components.
- *
- * Consumers register loaders via provideNgxDynamicEntity({ entityRefs: { clients: () => [...] } }).
- * EntityRefFieldComponent injects this service and calls resolve(field.component ?? field.id).
- */
-export declare class EntityRefRegistryService {
-    private readonly registry;
-    /**
-     * Get the option loader for an entity key.
-     * @returns The loader, or null if none is registered.
-     */
-    resolve(entityKey: string): EntityReferenceLoader | null;
-    has(entityKey: string): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EntityRefRegistryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<EntityRefRegistryService>;
-}

package/lib/services/entity-ref-selection.service.d.ts

@@ -1,24 +0,0 @@
-import type { ReferenceOption } from '@dynamic-entity/core';
-import * as i0 from "@angular/core";
-export interface EntityRefSelection {
-    fieldId: string;
-    /** The chosen option, or `null` when the selection was cleared. */
-    option: ReferenceOption | null;
-}
-/**
- * EntityRefSelectionService — the channel an entity-ref field uses to publish *which record*
- * the user picked, so the owning form can run `autoPatch` against it.
- *
- * The control value alone is not enough: `autoPatch` copies fields out of the selected
- * record, which only the field component has after loading its options.
- *
- * Provided at `DynamicFormComponent` level so each form instance gets its own channel;
- * the `root` fallback keeps standalone field components injectable in isolation.
- */
-export declare class EntityRefSelectionService {
-    private readonly subject;
-    readonly selection$: import("rxjs").Observable<EntityRefSelection>;
-    emit(fieldId: string, option: ReferenceOption | null): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EntityRefSelectionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<EntityRefSelectionService>;
-}

package/lib/services/entity-reference.service.d.ts

@@ -1,49 +0,0 @@
-import type { ReferenceLoaderContext, ReferenceOption } from '@dynamic-entity/core';
-import * as i0 from "@angular/core";
-/**
- * EntityReferenceService — the cache in front of consumer-registered option loaders.
- *
- * Three layers, matching the reference implementation:
- *  1. **options** — resolved `ReferenceOption[]` per (entity, lang, displayFields, filters).
- *  2. **in-flight** — the pending Promise, so N fields referencing one entity trigger one
- *     load rather than N. This is the layer that actually removes duplicate HTTP calls;
- *     an options cache alone does nothing for concurrent first loads.
- *  3. **labels** — synchronous value → text, for rendering a stored reference without
- *     waiting on a load.
- *
- * Invalidation is per entity, not global. The reference could only `clearCache()` everything
- * (issue #16), so saving one record re-fetched every entity's options.
- */
-export declare class EntityReferenceService {
-    private readonly registry;
-    private readonly store;
-    /** Loads in progress, keyed the same way as the options cache. */
-    private readonly inFlight;
-    /** `entityKey|lang|canonicalValue` -> display text. */
-    private readonly labels;
-    /**
-     * Options for an entity, from cache when present.
-     * Concurrent callers with the same key share one load.
-     */
-    load(entityKey: string, ctx?: ReferenceLoaderContext): Promise<ReferenceOption[]>;
-    /** Cached options without triggering a load. `undefined` when not cached. */
-    peek(entityKey: string, ctx?: ReferenceLoaderContext): ReferenceOption[] | undefined;
-    /**
-     * Display text for a stored reference value, synchronously.
-     * Returns `undefined` when the entity's options have never been loaded.
-     */
-    labelFor(entityKey: string, value: unknown, lang?: string): string | undefined;
-    /** Drop everything cached for one entity, leaving other entities intact. */
-    invalidate(entityKey: string): void;
-    clear(): void;
-    private rememberLabels;
-    /** Label-cache key. An object value collapses to its resolved text for the active language. */
-    private labelKey;
-    private invoke;
-    private toPromise;
-    private isSubscribable;
-    /** Exposed for cascade filtering, which matches a parent value against option values. */
-    matches(a: unknown, b: unknown, lang?: string): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EntityReferenceService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<EntityReferenceService>;
-}

package/lib/services/field-registry.service.d.ts

@@ -1,32 +0,0 @@
-import { Type } from '@angular/core';
-import * as i0 from "@angular/core";
-/**
- * FieldRegistryService — resolves field type strings to Angular component classes.
- *
- * **Tree-shaking contract:** this service holds *no* static imports of field components.
- * Nothing is bundled until something registers it, which is what makes the built-ins
- * opt-in. Register them with `provideBuiltInFieldTypes()` (all 19 keys) or a narrower
- * subset via `provideFieldTypes({ ... })` — see `providers/provide-field-types.ts`.
- *
- * Resolution order: consumer token registry → runtime registrations → nothing.
- */
-export declare class FieldRegistryService {
-    private readonly consumerRegistry;
-    private readonly dynamicRegistry;
-    constructor();
-    /** Register a field type component mapping at runtime. */
-    register(type: string, component: Type<any>): void;
-    /** Register multiple field type component mappings at runtime. */
-    registerAll(map: Record<string, Type<any>>): void;
-    /**
-     * Resolve a field type string to a component class.
-     * Consumer token registry takes priority over runtime registrations.
-     */
-    resolve(fieldType: string): Type<any> | null;
-    /** Check if a field type has a registered component. */
-    has(fieldType: string): boolean;
-    /** Every registered field type key. Consumer overrides and runtime registrations combined. */
-    registeredTypes(): string[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<FieldRegistryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FieldRegistryService>;
-}

package/lib/services/file-upload.service.d.ts

@@ -1,27 +0,0 @@
-import type { FileRef } from '@dynamic-entity/core';
-import * as i0 from "@angular/core";
-/**
- * FileUploadService — the single place image-field and file-field agree on how a
- * selected `File` becomes a `FileRef`.
- *
- * With `UPLOAD_HANDLER` registered the file is persisted and stored as `{ url }`;
- * without one it is stored as `{ file }` for the consumer to upload at submit time.
- */
-export declare class FileUploadService {
-    private readonly handler;
-    get hasHandler(): boolean;
-    /** Metadata common to both persisted and unpersisted refs. */
-    private describe;
-    /**
-     * Turn a selected File into the value to store on the control.
-     * @throws when a registered handler rejects — callers surface it as a field error.
-     */
-    toFileRef(file: File): Promise<FileRef>;
-    /** Object URL for previewing an unpersisted File. Callers must revoke it. */
-    previewUrlFor(ref: FileRef | null | undefined): string | null;
-    revokePreviewUrl(url: string | null): void;
-    private normalize;
-    private isSubscribable;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FileUploadService>;
-}

package/lib/services/hook-registry.service.d.ts

@@ -1,12 +0,0 @@
-import * as i0 from "@angular/core";
-/**
- * HookRegistryService — stores and runs Angular-side pre/post hooks.
- * Consumers register hooks via provideNgxDynamicEntity({ hooks: { 'clients:beforeSave': fn } }).
- */
-export declare class HookRegistryService {
-    private readonly registry;
-    has(key: string): boolean;
-    run(key: string, data: any, context?: any): Promise<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HookRegistryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<HookRegistryService>;
-}

package/lib/services/lookup-registry.service.d.ts

@@ -1,94 +0,0 @@
-import { type WritableSignal } from '@angular/core';
-import type { DropdownOption, LookupListValue, NestedFieldConfig } from '@dynamic-entity/core';
-import * as i0 from "@angular/core";
-/**
- * LookupRegistryService — the cache in front of consumer-registered master lists.
- *
- * Three layers, deliberately the same shape as `EntityReferenceService`, because the problem is
- * the same: one list is typically used by many fields across many entities.
- *  1. **options** — resolved `DropdownOption[]` per (list name, lang).
- *  2. **in-flight** — the pending Promise, so N fields on one list trigger one load, not N.
- *  3. **labels** — synchronous value → text (parity plan §6.2). This is not a nicety: since
- *     `viewMode` defaults to true a record opens read-only, so rendering a stored value as
- *     text is the *first* thing a `listName` field has to do. An async-only registry would
- *     paint the raw stored value and then flip, on every record open.
- *
- * A failed load rejects and caches nothing, so one transient error does not serve an empty
- * list forever — the same fix made for entity references in phase 5.
- */
-export declare class LookupRegistryService {
-    private readonly registry;
-    /** `listName|lang` -> resolved options. */
-    private readonly options;
-    /** `listName|lang` -> normalised values, so a consumer can reach `code` / `isSystemDefined`. */
-    private readonly values;
-    /** Loads in progress, keyed as above. */
-    private readonly inFlight;
-    /** `listName|lang|text` -> display text, for the synchronous read-only path. */
-    private readonly labels;
-    has(listName: string): boolean;
-    /**
-     * Options for a named list, from cache when present.
-     * Concurrent callers with the same key share one load.
-     */
-    load(listName: string, lang?: string): Promise<DropdownOption[]>;
-    /** Cached options without triggering a load. `undefined` when not loaded. */
-    peek(listName: string, lang?: string): DropdownOption[] | undefined;
-    /**
-     * Cached list values, carrying `_id`, `code`, `isSystemDefined` and `from`.
-     * The library never reads those; this is the seam for a consumer that needs them.
-     */
-    valuesFor(listName: string, lang?: string): LookupListValue[] | undefined;
-    /**
-     * Display text for a stored value, synchronously. `undefined` when the list has not loaded
-     * or holds no matching value — the caller keeps its own fallback, which is the stored text.
-     *
-     * Every language of an option is indexed, so a record saved under one language renders in
-     * another: a value stored as `'Aktiv'` resolves to `'Active'` under `lang: 'en'`.
-     */
-    labelFor(listName: string | undefined, value: unknown, lang?: string): string | undefined;
-    /** True when this field's options have to come from the registry. */
-    needsResolve(field: NestedFieldConfig | undefined): boolean;
-    /**
-     * The options to render right now, without awaiting: inline options, else whatever the
-     * registry already holds. Empty on a cold miss — pair with `resolveOptions`.
-     */
-    optionsFor(field: NestedFieldConfig | undefined, lang?: string): DropdownOption[];
-    /** The options for a field, loading the named list if needed. */
-    resolveOptions(field: NestedFieldConfig | undefined, lang?: string): Promise<DropdownOption[]>;
-    /** Drop everything cached for one list, leaving other lists intact. */
-    invalidate(listName: string): void;
-    clear(): void;
-    private cacheKey;
-    private labelKey;
-    /** Index an option under every language it carries, so any stored spelling finds it. */
-    private rememberLabels;
-    /** The texts a stored value could have been indexed under. */
-    private candidateTexts;
-    private invoke;
-    private toPromise;
-    private isSubscribable;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LookupRegistryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LookupRegistryService>;
-}
-/** A choice field component, as far as option resolution is concerned. */
-export interface ChoiceOptionHost {
-    readonly field: NestedFieldConfig | undefined;
-    readonly language: string;
-    readonly options: WritableSignal<DropdownOption[]>;
-}
-/**
- * Point a choice component's `options` signal at the right source (parity plan §6.3).
- *
- * Called from the `field` / `language` input setters of `dropdown`, `radio` and `multiSelect` —
- * the wiring is theirs, the decision is the service's, which is what keeps the field
- * five-input contract intact: options are never pushed in as a sixth input.
- *
- * Setters rather than `ngOnChanges` on purpose. `ngOnChanges` only fires for inputs Angular
- * itself sets, so a component whose `field` is assigned directly — which the field specs do,
- * and any consumer holding a `ComponentRef` may do — would render no options at all.
- *
- * Paints synchronously first (inline options, or a warm list), then fills in when a cold list
- * lands. The late result is dropped if the field or language changed while it was in flight.
- */
-export declare function refreshChoiceOptions(host: ChoiceOptionHost, lookups: LookupRegistryService): void;