ngx-dynamic-entity 1.3.0 → 1.4.0

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

@@ -0,0 +1,1719 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Type, EnvironmentProviders, WritableSignal, OnInit, OnChanges, OnDestroy, EventEmitter, SimpleChanges } from '@angular/core';
+import { ReferenceOption as ReferenceOption$1, EntityReferenceLoader as EntityReferenceLoader$1, LookupListSource as LookupListSource$1, RecordMigration as RecordMigration$1, FieldValidators, NestedFieldConfig, ReferenceLoaderContext, EntityFormConfig, DropdownOption, LookupListValue, NestedTabConfig, FormRule, RuleEvaluationResult as RuleEvaluationResult$1 } from '@dynamic-entity/core';
+export { AutoPatchConfig, CommonModuleEntry, DropdownOption, EntityFormConfig, EntityPermissions, EntityReferenceConfig, EntityReferenceLoader, FieldTableConfig, FieldValidators, FileRef, FormRule, LocalizedText, NestedFieldConfig, NestedTabConfig, PatchOnTrueMapping, RbacContext, ReferenceLoaderContext, ReferenceOption, RichFieldType, RuleAction, RuleCondition, RuleEvaluationResult, VersionedRecord, formatDisplayValue, normalizeConfig, normalizeOption, resolveLabel, resolveOptionLabel, resolveOptionValue, valuesMatch } from '@dynamic-entity/core';
+import { ValidatorFn, AsyncValidatorFn, ValidationErrors, FormGroup, FormArray, AbstractControl } from '@angular/forms';
+import * as rxjs from 'rxjs';
+
+/**
+ * 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.
+ */
+interface EntityRefCacheStore {
+    get(key: string): ReferenceOption$1[] | undefined;
+    set(key: string, value: ReferenceOption$1[]): 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. */
+declare class InMemoryEntityRefCacheStore implements EntityRefCacheStore {
+    private readonly map;
+    get(key: string): ReferenceOption$1[] | undefined;
+    set(key: string, value: ReferenceOption$1[]): void;
+    delete(key: string): void;
+    keys(): string[];
+    clear(): void;
+}
+
+/** Roles that see XXXXXXXXX for masked fields. Presentational only — enforce authz server-side. */
+declare const MASKED_ROLES: InjectionToken<string[]>;
+/**
+ * Consumer **overrides**: fieldType string → Angular component class.
+ * Highest priority — beats anything registered through `provideFieldTypes()`.
+ */
+declare const FIELD_TYPE_REGISTRY: InjectionToken<Map<string, Type<any>>>;
+/**
+ * Multi-provider of field-type sets, contributed by `provideFieldTypes()` /
+ * `provideBuiltInFieldTypes()`. Multi so several calls compose instead of clobbering;
+ * later sets win on key collision. This is the seam that keeps unused field components
+ * out of the bundle — nothing is imported until a set names it.
+ */
+declare const FIELD_TYPE_SETS: InjectionToken<Record<string, Type<any>>[]>;
+/**
+ * Registry: entity key → option loader.
+ *
+ * A loader receives a `ReferenceLoaderContext` (`parentValue`, `filters`, `lang`) and may
+ * return an array, a Promise, or an Observable of `ReferenceOption[]`. `ctx` is optional,
+ * so a zero-arg loader (`() => svc.list()`) is still a valid registration.
+ */
+declare const ENTITY_REF_REGISTRY: InjectionToken<Map<string, EntityReferenceLoader>>;
+/**
+ * Registry: list name → the values of a named master list (`field.listName`).
+ *
+ * A source may be the values themselves (array / Promise / Observable) or a **loader function**,
+ * which is what you want for anything fetched: a bare Promise is created when the provider is
+ * built, so every list would load whether or not a form uses it.
+ *
+ * Values are normalised by `normalizeLookupValues` — bare strings and `LocalizedText` are
+ * accepted alongside the full `{ code, name, sortOrder }` shape.
+ *
+ * @example
+ * provideNgxDynamicEntity({
+ *   lookups: {
+ *     employeeStatus: () => listService.getByName('employeeStatus'),
+ *     grades: ['Junior', 'Senior'],
+ *   },
+ * })
+ */
+declare const LOOKUP_REGISTRY: InjectionToken<Map<string, LookupListSource>>;
+/**
+ * Ordered steps that move a saved record forward when a config's `version` increases.
+ *
+ * Without these, `EntityFormConfig.version` and `VersionedRecord._configVersion` are
+ * declarations nothing acts on: a schema can be edited freely while records keep their old
+ * shape, and nothing reconciles the two. Registering migrations makes the version numbers
+ * mean something.
+ *
+ * @example
+ * provideNgxDynamicEntity({
+ *   migrations: [
+ *     { from: 1, to: 2, description: 'split name', migrate: r => ({ ...r, firstName: r['name'] }) },
+ *   ],
+ * })
+ */
+declare const RECORD_MIGRATIONS: InjectionToken<RecordMigration[]>;
+/**
+ * Overrides for the messages shown under an invalid field, keyed by Angular error key
+ * (`required`, `minlength`, `pattern`, …) plus a few field-specific keys.
+ *
+ * The built-in messages are English literals. Registering here is what makes a non-English
+ * form possible without re-implementing every field component; unlisted keys keep their
+ * default, so overriding one does not mean supplying them all.
+ */
+declare const VALIDATION_MESSAGES: InjectionToken<Record<string, any>>;
+/** Registry: validator key → ValidatorFn */
+declare const VALIDATOR_REGISTRY: InjectionToken<Map<string, any>>;
+/**
+ * Registry: validator key → AsyncValidatorFn.
+ *
+ * Kept separate from VALIDATOR_REGISTRY because Angular applies the two differently: an async
+ * validator runs only once the synchronous ones pass, and puts the control into `pending`
+ * while it does. Name them from a schema with `validators: { customAsync: ['uniqueEmail'] }`.
+ */
+declare const ASYNC_VALIDATOR_REGISTRY: InjectionToken<Map<string, any>>;
+/**
+ * A registered hook: receives the payload, returns it (or a replacement), sync or async.
+ *
+ * Spelled out rather than typed as `Function`, which accepts class declarations and any
+ * arity and gives a consumer no signature to write against.
+ */
+type HookFn = (data: any, context?: unknown) => unknown | Promise<unknown>;
+/** Registry: hook key → async (data, context) => data */
+declare const HOOK_REGISTRY: InjectionToken<Map<string, HookFn>>;
+/**
+ * Consumer-registered list of common module tabs (documents, audit, tasks, etc.).
+ * The library ships no built-in implementations. Consumers provide their own list
+ * so the builder's module-picker and the renderer's tab switcher know what's available.
+ *
+ * @example
+ * providers: [
+ *   {
+ *     provide: COMMON_MODULES_REGISTRY,
+ *     useValue: [
+ *       { id: 'documents', label: { en: 'Documents' }, component: 'app-documents-view' },
+ *       { id: 'audit',     label: { en: 'Audit Log'  }, component: 'app-audit' },
+ *     ] satisfies CommonModuleEntry[]
+ *   }
+ * ]
+ */
+declare const COMMON_MODULES_REGISTRY: InjectionToken<CommonModuleEntry[]>;
+/**
+ * Consumer-provided file/image upload handler.
+ * When supplied, image-field and file-field call it to persist the File and receive a stable
+ * URL back. Without it the field stores `{ file, name, size, mimeType }` for the consumer to
+ * upload on submit. May return the result directly, as a Promise, or as an Observable.
+ *
+ * @example
+ * { provide: UPLOAD_HANDLER, useFactory: () => (file: File) => myUploadService.upload(file) }
+ */
+declare const UPLOAD_HANDLER: InjectionToken<FileUploadHandler>;
+/**
+ * Backing store for the entity-reference options cache. Defaults to in-memory.
+ * Provide your own to make the cache outlive a page refresh.
+ *
+ * @example
+ * { provide: ENTITY_REF_CACHE_STORE, useClass: SessionStorageRefCache }
+ */
+declare const ENTITY_REF_CACHE_STORE: InjectionToken<EntityRefCacheStore>;
+/**
+ * Consumer-provided predicate function to check whether user roles can edit system default tabs or fields.
+ * Defaults to allowing edits if not provided.
+ */
+declare const SYSTEM_DEFAULT_CAN_EDIT: InjectionToken<(roles: string[]) => boolean>;
+type ConfigSourceHandler = (entityKey: string) => any;
+/**
+ * Registry/Resolver for resolving an EntityFormConfig by entity key across entities (Phase 8).
+ * Enables cross-entity field referencing (`isReferenced`, `referencedEntityKey`, `referencedFieldId`, `hasDrift`).
+ */
+declare const CONFIG_SOURCE: InjectionToken<ConfigSourceHandler>;
+
+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$1>;
+    /**
+     * 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$1>;
+    /**
+     * 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$1[];
+}
+/**
+ * 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() },
+ *   })
+ */
+declare const provideNgxDynamicEntity: (config?: NgxDynamicEntityConfig) => EnvironmentProviders;
+
+/**
+ * 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. */
+declare function builtInFieldTypes(): Record<string, Type<any>>;
+/** Register a specific set of field types. Only the components you name are bundled. */
+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. */
+declare function provideBuiltInFieldTypes(): EnvironmentProviders;
+
+/**
+ * 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.
+ */
+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>;
+}
+
+/**
+ * HookRegistryService — stores and runs Angular-side pre/post hooks.
+ * Consumers register hooks via provideNgxDynamicEntity({ hooks: { 'clients:beforeSave': fn } }).
+ */
+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>;
+}
+
+/**
+ * ValidatorRegistryService — resolves validator configs / key strings to Angular ValidatorFns.
+ */
+declare class ValidatorRegistryService {
+    private readonly consumerRegistry;
+    private readonly asyncRegistry;
+    /**
+     * Resolve a validator key string to a ValidatorFn.
+     * Supports parameterized built-ins like 'min:0', 'maxLength:255'.
+     */
+    resolve(validatorKey: string): ValidatorFn | null;
+    /** Resolve multiple validator keys into a ValidatorFn[] */
+    resolveAll(validatorKeys?: string[]): ValidatorFn[];
+    /** Resolve a FieldValidators object or string[] into ValidatorFn[] */
+    resolveFromConfig(config?: FieldValidators | string[]): ValidatorFn[];
+    /**
+     * Resolve the async validators a field names, in `validators.customAsync`.
+     *
+     * Async validators are deliberately a separate registry and a separate config key: Angular
+     * attaches them through `setAsyncValidators`, runs them only once the synchronous ones
+     * pass, and holds the control in `pending` until they settle. Mixing them into the
+     * synchronous list would silently never run them.
+     *
+     * An unknown name is skipped rather than throwing, matching the synchronous behaviour.
+     */
+    resolveAsyncFromConfig(config?: FieldValidators | string[]): AsyncValidatorFn[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidatorRegistryService>;
+}
+
+/**
+ * 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).
+ */
+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$1 | null;
+    has(entityKey: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityRefRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityRefRegistryService>;
+}
+
+interface EntityRefSelection {
+    fieldId: string;
+    /** The chosen option, or `null` when the selection was cleared. */
+    option: ReferenceOption$1 | 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.
+ */
+declare class EntityRefSelectionService {
+    private readonly subject;
+    readonly selection$: rxjs.Observable<EntityRefSelection>;
+    emit(fieldId: string, option: ReferenceOption$1 | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityRefSelectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityRefSelectionService>;
+}
+
+/**
+ * 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.
+ */
+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$1[]>;
+    /**
+     * 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$1[];
+    /** 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>;
+}
+
+/**
+ * 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.
+ */
+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$1[]>;
+    /** Cached options without triggering a load. `undefined` when not cached. */
+    peek(entityKey: string, ctx?: ReferenceLoaderContext): ReferenceOption$1[] | 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>;
+}
+
+/**
+ * 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.
+ */
+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. */
+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.
+ */
+declare function refreshChoiceOptions(host: ChoiceOptionHost, lookups: LookupRegistryService): void;
+
+/**
+ * RbacService — ALL permission checks and masking logic live here.
+ */
+declare class RbacService {
+    private readonly maskedRoles;
+    /**
+     * Check if any of the user's roles satisfy the required roles.
+     * hasPermission(roles, undefined) → true (no restriction).
+     */
+    hasPermission(userRoles: string[], requiredRoles?: string[]): boolean;
+    /** 3-level OR resolution */
+    resolveEffectiveMask(formMask?: boolean, tabMask?: boolean, fieldMask?: boolean): boolean;
+    /** Check if the user's roles include any masked role */
+    isUserMaskedRole(userRoles: string[]): boolean;
+    /** Determine if a specific field should be masked for this user */
+    shouldMaskField(field: NestedFieldConfig, tab: NestedTabConfig | undefined, config: EntityFormConfig, userRoles: string[]): boolean;
+    /** Get view/edit/delete permissions for a config */
+    getPermissions(config: EntityFormConfig, userRoles: string[]): {
+        canView: boolean;
+        canEdit: boolean;
+        canDelete: boolean;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<RbacService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RbacService>;
+}
+
+/**
+ * RulesEvaluationService — evaluates dynamic form rules against active reactive form state.
+ */
+declare class RulesEvaluationService {
+    /**
+     * Evaluate rules against form values and optional original baseline values.
+     */
+    evaluate(rules: FormRule[] | undefined | null, values: Record<string, unknown>, originalValues?: Record<string, unknown>): RuleEvaluationResult$1;
+    /**
+     * Filter rules pertinent to a single tab.
+     */
+    filterForTab(rules: FormRule[] | undefined | null, tabId: string, config: EntityFormConfig): FormRule[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RulesEvaluationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RulesEvaluationService>;
+}
+
+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>;
+}
+
+/**
+ * Resolves an Angular `ValidationErrors` object to the message shown under a field.
+ *
+ * These strings used to be hardcoded English literals inside each field component, so a
+ * German form meant re-implementing every field type — the labels honoured `language` while
+ * the errors underneath them did not.
+ *
+ * A message is a plain string, or a function when it needs the error's own detail
+ * (`minlength.requiredLength`, `min.min`, and so on). The active `language` is passed
+ * through, so one registration can serve every locale:
+ *
+ * ```typescript
+ * provideNgxDynamicEntity({
+ *   validationMessages: {
+ *     required: lang => (lang === 'de' ? 'Pflichtfeld.' : 'This field is required.'),
+ *     minlength: (lang, err) => `Mindestens ${err['requiredLength']} Zeichen.`,
+ *   },
+ * });
+ * ```
+ *
+ * Unregistered keys fall back to the defaults below, so overriding one message does not
+ * mean supplying them all.
+ */
+type ValidationMessage = string | ((language: string, error: any) => string);
+/** The built-in English messages. Every key here can be overridden individually. */
+declare const DEFAULT_VALIDATION_MESSAGES: Record<string, ValidationMessage>;
+declare class ValidationMessagesService {
+    private readonly overrides;
+    /**
+     * The message for the first error present, in the order the caller lists.
+     *
+     * Order is the caller's because it is field-specific: a dropdown wants
+     * `requiredSelection` where a text input wants `required`, and the first match wins so the
+     * most specific message is the one shown.
+     */
+    resolve(errors: ValidationErrors | null | undefined, language: string, order: readonly (string | readonly [errorKey: string, messageKey: string])[], fallbackKey?: string): string;
+    /** One message by key, honouring an override before the default. */
+    messageFor(key: string, language: string, error: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationMessagesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidationMessagesService>;
+}
+
+/**
+ * DynamicFormComponent — the main form component.
+ * Renders a reactive form from EntityFormConfig with tab support, responsive 12-col grid,
+ * rules evaluation, conditional visibility, autoPatch/patchOnTrue, criticalField locking,
+ * keyboard shortcuts (Ctrl+S, Esc), and RBAC-gated submission.
+ */
+declare class DynamicFormComponent implements OnInit, OnChanges, OnDestroy {
+    /**
+     * The schema to render.
+     *
+     * An accessor pair rather than a plain field: `ngOnChanges` normalises the option shape,
+     * and that result is kept here instead of being written back over the input. Reassigning
+     * an `@Input` works, but it mutates what the parent handed us — and a parent using OnPush
+     * or signals would never observe the replacement anyway.
+     *
+     * Reads of `this.config` get the normalised copy once it exists, so every internal caller
+     * is unaffected.
+     */
+    set config(value: EntityFormConfig);
+    get config(): EntityFormConfig;
+    private rawConfig;
+    private normalizedConfig?;
+    rules?: FormRule[];
+    initialData?: Record<string, any>;
+    /** Session-original values for `VALUE_CHANGED` rules. Captured from the first build when omitted. */
+    originalData?: Record<string, any>;
+    userRoles: string[];
+    language: string;
+    readonly: boolean;
+    /** Field ids forced read-only while the rest of the form stays editable. */
+    readOnlyFields: string[];
+    /**
+     * Render rule `info` banners inline. The record editor sets this false and renders its
+     * own dismissible versions, so the two do not double up.
+     */
+    showInfoBanners: boolean;
+    loading: boolean;
+    error: string | null;
+    /**
+     * Milliseconds to debounce `formChange`. The reference debounces at 300ms so a consumer
+     * re-rendering on every value change is not driven per keystroke. Zero emits
+     * synchronously, which the record editor relies on for its own bookkeeping.
+     */
+    changeDebounceMs: number;
+    /**
+     * Preview mode: seed one empty row per `array` field so the structure is visible, then
+     * disable the form. Used by the builder's live preview.
+     */
+    preview: boolean;
+    formSubmit: EventEmitter<Record<string, any>>;
+    formChange: EventEmitter<Record<string, any>>;
+    formReset: EventEmitter<void>;
+    /** The visible tab changed. Lets a host track it without reaching into this component. */
+    activeTabChange: EventEmitter<string>;
+    /**
+     * Emitted when a `beforeSave` hook aborted the save — by returning false or throwing.
+     * `formSubmit` does not fire in that case.
+     */
+    saveRejected: EventEmitter<{
+        reason: string;
+        error?: unknown;
+    }>;
+    private readonly cdr;
+    private readonly fb;
+    private readonly validatorRegistry;
+    private readonly hookRegistry;
+    private readonly rbacService;
+    private readonly rulesEvaluation;
+    private readonly entityRefSelection;
+    private readonly commonModulesRegistry;
+    private readonly migrations;
+    protected readonly Object: ObjectConstructor;
+    readonly activeTab: i0.WritableSignal<string>;
+    readonly activeSubTab: i0.WritableSignal<string>;
+    readonly isSaving: i0.WritableSignal<boolean>;
+    readonly formValues: i0.WritableSignal<Record<string, any>>;
+    /** Baseline captured at first build, used when `originalData` is not supplied. */
+    readonly sessionBaseline: i0.WritableSignal<Record<string, any>>;
+    /** Critical fields the user has explicitly unlocked for editing. */
+    readonly unlockedFields: i0.WritableSignal<ReadonlySet<string>>;
+    /** The active tab's field panel, focused after a tab switch. */
+    private formPanel?;
+    /** The hosted field components, so an external control-state change can reach them. */
+    private fieldHosts?;
+    form: FormGroup;
+    private valueSub?;
+    private statusSub?;
+    private selectionSub?;
+    /** Previous values, for detecting `patchOnTrue` false→true transitions. */
+    private previousValues;
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    readonly ruleResult: i0.Signal<RuleEvaluationResult>;
+    /**
+     * Critical fields whose value differs from the session baseline.
+     * These drive the deferred `VALUE_CHANGED` banner — a critical edit is announced once,
+     * against the value the record had when the session started, not per keystroke.
+     */
+    readonly changedCriticalFields: i0.Signal<NestedFieldConfig[]>;
+    get tabs(): NestedTabConfig[];
+    get visibleTabs(): NestedTabConfig[];
+    get activeTabConfig(): NestedTabConfig | null;
+    get visibleSubTabs(): NestedTabConfig[];
+    get activeSubTabConfig(): NestedTabConfig | null;
+    get activeTabModuleComponent(): any | null;
+    get fieldsForActiveTab(): NestedFieldConfig[];
+    /**
+     * Entity-level permissions for the current roles.
+     *
+     * Cached rather than recomputed: this is read from the template several times per change
+     * detection pass, and a fresh object each time is both wasted allocation and a new
+     * identity for anything comparing by reference. Invalidated in `ngOnChanges` when
+     * `config` or `userRoles` change, which are its only inputs.
+     */
+    get permissions(): ReturnType<RbacService['getPermissions']>;
+    private permissionsCache;
+    /**
+     * Whether the current roles may see this record at all.
+     *
+     * `permissions.view` used to be computed and thrown away — a user whose roles failed it
+     * still received the complete form with every value in the DOM. It is honoured now.
+     *
+     * As with masking, this is presentational: it stops the browser rendering data, it does
+     * not stop the data reaching the browser. Authorize on the server.
+     */
+    get canView(): boolean;
+    /**
+     * Whether the current roles may delete this record.
+     *
+     * The library ships no delete affordance, so this is surfaced for the consumer to gate
+     * their own — exposed rather than dropped, because a permission the schema declares
+     * should be answerable.
+     */
+    get canDelete(): boolean;
+    get canSubmit(): boolean;
+    /**
+     * Errors raised by `validation` rules, keyed by the target they point at.
+     *
+     * A rule can declare the record invalid independently of Angular's validators, so form
+     * validity alone is not the whole picture. `DynamicRecordFormComponent.saveSection()`
+     * has always honoured these; `submit()` did not, which meant the same rule blocked one
+     * save path and merely painted a banner on the other — and anything wiring
+     * `(formSubmit)` to persistence wrote records the rules engine had already rejected.
+     */
+    get ruleValidationErrors(): Record<string, string>;
+    /** True when a `validation` rule is currently blocking submission. */
+    get hasRuleErrors(): boolean;
+    /**
+     * True while an async validator is still running.
+     *
+     * Angular reports a control with an outstanding async check as `pending`, and `invalid` is
+     * false until it settles — so without this a form could be submitted in the gap before a
+     * uniqueness check came back.
+     */
+    get isValidating(): boolean;
+    /** Single source of truth for both the submit guard and the button's disabled state. */
+    get submitBlocked(): boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    setActiveTab(tabId: string): void;
+    setActiveSubTab(subTabId: string): void;
+    getFieldSpan(field: NestedFieldConfig): string;
+    /** A critical field stays read-only until the user deliberately unlocks it. */
+    isFieldLocked(field: NestedFieldConfig): boolean;
+    /**
+     * Whether this field renders read-only, from any of the four reasons: the whole form,
+     * the field's own flag, a caller-supplied `readOnlyFields` entry, or a criticalField lock.
+     */
+    isFieldReadonly(field: NestedFieldConfig): boolean;
+    toggleFieldLock(field: NestedFieldConfig): void;
+    resolveFieldLabel(field: NestedFieldConfig): string;
+    private buildForm;
+    private buildFieldControl;
+    /** One row of an `array` field: a FormGroup when the field declares columns, else a bare control. */
+    /**
+     * The `FormArray` behind an `array` field, for callers that manage rows themselves —
+     * the record editor's inline row drawer.
+     */
+    getArrayControl(fieldId: string, tabId?: string): FormArray | null;
+    /**
+     * Build one detached row for an `array` field, with the field's own validators applied.
+     * Exposed so a row can be edited outside the form and pushed on save.
+     */
+    createArrayRow(field: NestedFieldConfig, value?: unknown): AbstractControl;
+    private buildArrayRow;
+    /**
+     * Mark every control touched, then re-check the field components.
+     *
+     * They are OnPush and `touched` is flipped from outside their own template, so the second
+     * half is what makes the error messages actually appear.
+     */
+    private markAllTouched;
+    /**
+     * Bring a record up to the config's `version` before it reaches the form.
+     *
+     * Done here because this is the one place a record enters the renderer, so a consumer
+     * cannot forget it. Migration is a no-op unless the consumer registered steps *and* the
+     * record is behind — an unstamped record is deliberately left alone (see `migrateRecord`).
+     *
+     * A missing or broken step throws from core. That is not swallowed: rendering a
+     * half-understood record would write it back in a shape matching neither schema.
+     */
+    private upgradeRecord;
+    private patchForm;
+    /**
+     * A record is nested by tab id (`{ tabId: { fieldId: value } }`) unless the tab sets
+     * `flatData: true`. Handing a flat record to a nested tab finds nothing, so the fields
+     * stay empty — with no error and no clue. That silent miss is the most expensive way to
+     * lose an hour with this library, so name it in dev builds.
+     *
+     * Only top-level keys that match a known field id are reported: anything else is assumed
+     * to be the consumer's own record metadata (ids, timestamps, `_configVersion`) and is not
+     * our business.
+     */
+    private warnUnconsumedInitialData;
+    /** Warn once per key per form instance — patchForm re-runs on every initialData change. */
+    private readonly warnedUnconsumedKeys;
+    /** Assemble full nested record from per-tab FormGroups, respecting flatData, refererField & arrays. */
+    extractRecord(): Record<string, any>;
+    /**
+     * Warns when a rule names a field id that two scopes define.
+     *
+     * Field ids are unique per scope, so `address` may exist on both Personal Details and Work
+     * Details — but a rule carries a bare id and no scope, so it cannot say which one it means.
+     * `flattenFormValues` keys by bare id, so one of the two silently wins and the rule reads
+     * whichever landed there.
+     *
+     * `validateConfig` catches this for `showWhen` and cascade parents, which live in the
+     * config. Rules do not: they arrive as a separate `@Input`, so the config alone cannot be
+     * checked for them and this is the only place both are in hand.
+     */
+    private warnAmbiguousRuleReferences;
+    private static readonly warnedAmbiguousIds;
+    /**
+     * The value map rules and `showWhen` are evaluated against.
+     *
+     * Every field appears under two keys: its bare id, and its `refererField` path wrapped in brackets.
+     * The bare id is what every config written so far uses and is kept exactly as it was — but
+     * ids are unique per scope, so when two scopes define one the last field walked wins and
+     * the rule reads whichever that is. `[personal.address]` names one field and cannot be
+     * ambiguous, which is why a rule that has to distinguish them uses the ref.
+     *
+     * Both live in one flat map on purpose: `evaluateFormRules` takes a `Record<string,
+     * unknown>` and needs no knowledge of refs at all — the extra keys simply resolve.
+     */
+    /**
+     * Whether a rule result names this field.
+     *
+     * A rule target is either a bare field id — how every config so far addresses a field — or
+     * a bracketed path, which is the only way to name one of two fields that share an id.
+     * Both have to match, or a rule written either way would fail to hide what it targeted.
+     */
+    private namesField;
+    /** The field's declared path, or the one its position implies when it carries none. */
+    private pathFor;
+    private flattenFormValues;
+    private getTabGroup;
+    /**
+     * `autoPatch` — copy mapped fields out of the record the user just selected in an
+     * entity-ref field into the configured target tab's controls.
+     */
+    private runAutoPatch;
+    /**
+     * `patchOnTrue` — when a boolean/checkbox field transitions to `true`,
+     * copy `from` → `to` within the current record.
+     */
+    private runPatchOnTrue;
+    /** Prefer a control declared on the configured target tab; fall back to a top-level control. */
+    private resolveTargetControl;
+    /**
+     * The fields the render filter operates on — a tab's own fields, at every tab depth.
+     * Deliberately not `allFields()`: `group` and `array` children are shown or hidden with
+     * their parent, and toggling a child's state independently would fight the parent's.
+     */
+    private tabFields;
+    /**
+     * Keep a hidden field's control out of form validity.
+     *
+     * A field hidden by a rule or a `showWhen` condition is filtered out of the render, but
+     * its validators stay attached — so a hidden *required* field holds `form.invalid` true
+     * forever, permanently disabling Save with nothing on screen to explain why.
+     *
+     * Disabling is the fix rather than stripping validators: Angular excludes disabled
+     * controls from validity, and the field's own validators survive intact for when it
+     * comes back. Values are untouched — `flattenFormValues` and `extractRecord` both read
+     * `control.value`, which a disabled control still carries, so rule evaluation and the
+     * emitted record see exactly what they saw before. That also keeps this from feeding
+     * back on itself: hiding a field cannot change the values the rules are evaluated over.
+     *
+     * The visibility predicate is the same one `fieldsForActiveTab` filters with, so what is
+     * rendered and what counts toward validity cannot drift apart.
+     */
+    private syncHiddenFieldState;
+    /** Every field in the config, including `group`/`array` children. */
+    private allFields;
+    /** An empty `originalData` counts as "not supplied" — fall back to the captured baseline. */
+    private baseline;
+    private sameValue;
+    getControl(fieldId: string, currentTabId?: string): AbstractControl | null;
+    /**
+     * Move focus into the newly shown panel.
+     *
+     * Activating a tab replaces everything below it while focus stays on the tab button, so a
+     * screen-reader or keyboard user is given no indication that the content changed and must
+     * tab back through the strip to reach it. Deferred a frame because the panel's contents
+     * are rendered by the change detection this call is part of.
+     */
+    private focusActivePanel;
+    /** Accessible name for the field panel — it is the tabpanel for the active tab. */
+    get activeTabLabel(): string;
+    /**
+     * Why a referenced field is flagged.
+     *
+     * `hasDrift` was written by the builder and read by nothing at runtime, so a field whose
+     * source definition had changed since it was linked looked entirely normal to the person
+     * filling the form in.
+     */
+    driftHint(field: NestedFieldConfig): string;
+    resolveTabLabel(tab: NestedTabConfig): string;
+    submit(): Promise<void>;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "ngx-dynamic-form", never, { "config": { "alias": "config"; "required": false; }; "rules": { "alias": "rules"; "required": false; }; "initialData": { "alias": "initialData"; "required": false; }; "originalData": { "alias": "originalData"; "required": false; }; "userRoles": { "alias": "userRoles"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "readOnlyFields": { "alias": "readOnlyFields"; "required": false; }; "showInfoBanners": { "alias": "showInfoBanners"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "error": { "alias": "error"; "required": false; }; "changeDebounceMs": { "alias": "changeDebounceMs"; "required": false; }; "preview": { "alias": "preview"; "required": false; }; }, { "formSubmit": "formSubmit"; "formChange": "formChange"; "formReset": "formReset"; "activeTabChange": "activeTabChange"; "saveRejected": "saveRejected"; }, never, never, true, never>;
+}
+
+/**
+ * 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.
+ */
+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: i0.WritableSignal<Record<string, any>>;
+    readonly originalBaseline: i0.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: i0.WritableSignal<any>;
+    readonly inlineRowIndex: i0.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: i0.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: i0.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: i0.Signal<boolean>;
+    readonly summaryFields: i0.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>;
+}
+
+/**
+ * DynamicFieldComponent — mounts the correct field component for a given NestedFieldConfig.
+ * Uses ViewContainerRef.createComponent() and passes inputs via setInput(); see
+ * DynamicFieldComponentContract for the five inputs every field component receives.
+ * Never add field-type-specific logic here — this component must remain generic.
+ *
+ * The 5 inputs (field, control, language, readonly, masked) are passed to every mounted
+ * component uniformly — no special-casing per type.
+ */
+declare class DynamicFieldComponent implements OnChanges, OnDestroy {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    config: EntityFormConfig;
+    currentTabId?: string;
+    language: string;
+    readonly: boolean;
+    userRoles: string[];
+    private readonly fieldHost;
+    private readonly fieldRegistry;
+    private readonly rbacService;
+    /**
+     * Passed into `createComponent` so a hosted field sees this host's injector — including
+     * `DynamicFormComponent`'s scoped `EntityRefSelectionService`. Without it, a standalone
+     * field resolves the root bus and `autoPatch` never runs.
+     */
+    private readonly injector;
+    private componentRef;
+    ngOnChanges(_changes: SimpleChanges): void;
+    private mountField;
+    /**
+     * Field types are opt-in (see `provideFieldTypes` / `provideBuiltInFieldTypes`), so an
+     * unregistered type renders nothing. Say so once per type in dev builds rather than
+     * leaving a silently blank slot.
+     */
+    private warnUnresolved;
+    private static readonly warnedTypes;
+    /**
+     * Re-check the hosted field component.
+     *
+     * The field components are OnPush, so they re-render on an input change, an event from
+     * their own template, or a signal they read. `form.markAllAsTouched()` is none of those —
+     * it flips `touched` from outside, and every field's error message depends on it. Without
+     * this, a blocked submit would mark the form touched and no error would appear.
+     */
+    refresh(): void;
+    /**
+     * Re-check the hosted component whenever its control changes from outside.
+     *
+     * The field components are OnPush, so they re-render on an input change or an event from
+     * their own template. A control mutated externally is neither — and that is not an edge
+     * case: patchForm, reset, autoPatch and patchOnTrue all do exactly that. Without this, a
+     * field patched from a record would keep rendering its previous value.
+     *
+     * `detectChanges()` rather than `markForCheck()`: a selection that arrives from a native
+     * `change` event (or Playwright) may not be followed by another Angular tick, so a dirty
+     * flag would never be flushed. Running CD on the hosted component now is the copy showing up.
+     *
+     * Done here rather than in each of the eighteen field components: the host owns the
+     * component reference, so one subscription covers every type including custom ones.
+     */
+    private watchControl;
+    private controlSub?;
+    ngOnDestroy(): void;
+    /**
+     * Pass all 5 contract inputs via ComponentRef.setInput() — uniform for all types.
+     * The public shape is DynamicFieldComponentContract.
+     * Must use setInput(), not property assignment: the field components declare inputs with
+     * definite assignment and no initializer, and the lib compiles with
+     * useDefineForClassFields:false, so `'field' in instance` is false until first set.
+     */
+    private setInputs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFieldComponent, "ngx-dynamic-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "config": { "alias": "config"; "required": false; }; "currentTabId": { "alias": "currentTabId"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "userRoles": { "alias": "userRoles"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * What a field component must accept to be registered with `provideFieldTypes`.
+ *
+ * The renderer instantiates a field component dynamically and assigns exactly these five
+ * inputs — no more, no less — so any component satisfying this interface can stand in for a
+ * built-in type or add a new one.
+ *
+ * Implement it explicitly and TypeScript will tell you when you have missed one:
+ *
+ * ```typescript
+ * @Component({
+ *   selector: 'app-signature-field',
+ *   standalone: true,
+ *   template: `<canvas [attr.aria-label]="field.id"></canvas>`,
+ * })
+ * export class SignatureFieldComponent implements DynamicFieldComponentContract {
+ *   @Input() field!: NestedFieldConfig;
+ *   @Input() control!: AbstractControl;
+ *   @Input() language = 'en';
+ *   @Input() readonly = false;
+ *   @Input() masked = false;
+ * }
+ *
+ * provideFieldTypes({ signature: SignatureFieldComponent });
+ * ```
+ *
+ * Two implementation notes that are easy to get wrong:
+ *
+ * - Declare the inputs with definite assignment (`field!: …`) or an initialiser. The
+ *   renderer sets them through `ComponentRef.setInput()` after construction, so they are
+ *   genuinely undefined until the first assignment.
+ * - `masked` means the value must not be displayed. Render a placeholder rather than the
+ *   control's value. This is presentational: the real value stays in the control and is
+ *   included in the submitted record, so it is not an access-control boundary.
+ */
+interface DynamicFieldComponentContract {
+    /** The field's schema entry: id, type, label, validators, options, and so on. */
+    field: NestedFieldConfig;
+    /** The reactive control backing this field. A `FormGroup` for `group`, `FormArray` for `array`. */
+    control: AbstractControl;
+    /** Active language, for resolving `LocalizedText` labels, placeholders and options. */
+    language: string;
+    /** Render the value as text rather than an editable control. */
+    readonly: boolean;
+    /** Hide the value from display. See the note above — presentational only. */
+    masked: boolean;
+}
+
+declare class TextFieldComponent implements OnDestroy {
+    private readonly messages;
+    private displaySub?;
+    field: NestedFieldConfig;
+    set control(value: AbstractControl);
+    get control(): AbstractControl;
+    private _control;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    /** Readonly markup reads this signal so an external patch (autoPatch) is visible under OnPush. */
+    readonly displayValue: i0.WritableSignal<unknown>;
+    ngOnDestroy(): void;
+    get label(): string;
+    get placeholder(): string;
+    get errorMessage(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextFieldComponent, "ngx-text-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TextareaFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    get placeholder(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextareaFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextareaFieldComponent, "ngx-textarea-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NumberFieldComponent {
+    private readonly messages;
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    get placeholder(): string;
+    get errorMessage(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumberFieldComponent, "ngx-number-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Currency field: number input with locale-aware currency symbol prefix. */
+declare class CurrencyFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    get placeholder(): string;
+    /** Picks the currency symbol from the locale — defaults to '$'. */
+    get symbol(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CurrencyFieldComponent, "ngx-currency-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Email field: type="email" input with inline validation hint. */
+declare class EmailFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    get placeholder(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmailFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmailFieldComponent, "ngx-email-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Password field: masked input with show/hide eye toggle. */
+declare class PasswordFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    readonly visible: i0.WritableSignal<boolean>;
+    get label(): string;
+    get placeholder(): string;
+    toggleVisibility(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordFieldComponent, "ngx-password-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CheckboxFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxFieldComponent, "ngx-checkbox-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Boolean field: a slide-toggle style switch (true/false).
+ * Distinct from `checkbox` (which is a standalone bool) in that it renders as a
+ * toggle switch with Yes/No labels for clearer binary state communication.
+ */
+declare class BooleanFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BooleanFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BooleanFieldComponent, "ngx-boolean-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DateFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    /** ISO 8601 date → locale display string (ONEHERMES convention: always UTC, display in user locale) */
+    formatDate(value: string | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateFieldComponent, "ngx-date-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Date & Time field: a single `datetime-local` input.
+ *
+ * The type is stored as ISO 8601 UTC, per the same convention `date` follows, while the
+ * input works in the viewer's local zone — `datetime-local` has no offset, so the two
+ * conversions here are what keep a value stable across a round trip.
+ */
+declare class DateTimeFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    /** Stored ISO 8601 → the `YYYY-MM-DDTHH:mm` local form the input requires. */
+    get inputValue(): string;
+    /** The input's local `YYYY-MM-DDTHH:mm` → stored ISO 8601 UTC. */
+    onInput(value: string): void;
+    /**
+     * Displays date *and* time. `DateFieldComponent` used `toLocaleDateString()` here, so a
+     * datetime read back through the field showed no time while the same value in the record
+     * summary — which goes through core's `formatDisplayValue` — showed it.
+     */
+    formatDateTime(value: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeFieldComponent, "ngx-date-time-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Time field: a bare time of day, with no date and no zone attached.
+ *
+ * Stored as `HH:mm` — exactly the value `<input type="time">` reads and writes, so the
+ * control binds straight through with no conversion. That is the whole reason this is a
+ * separate type from `datetime`: a recurring 09:00 opening time is not a moment in time,
+ * and converting it to UTC would move it whenever the offset changed.
+ */
+declare class TimeFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    get label(): string;
+    /**
+     * Defers to core rather than parsing `HH:mm` locally. The other date-ish components each
+     * grew their own formatter, and `datetime` ended up showing one thing in the field and
+     * another in the record summary because the two drifted apart.
+     */
+    formatTime(value: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimeFieldComponent, "ngx-time-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Month-Year field: two linked selects (Month + Year).
+ * Value stored as ISO partial date string "YYYY-MM" for unambiguous storage.
+ */
+declare class MonthYearFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    readonly months: {
+        value: string;
+        label: string;
+    }[];
+    readonly years: number[];
+    get label(): string;
+    /** Parses "YYYY-MM" or "YYYY-MM-DD" stored value → month part. */
+    get selectedMonth(): string;
+    get selectedYear(): string;
+    onMonthChange(month: string): void;
+    onYearChange(year: string): void;
+    formatValue(value: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonthYearFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonthYearFieldComponent, "ngx-month-year-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DropdownFieldComponent {
+    private readonly lookups;
+    private readonly messages;
+    private _field;
+    private _language;
+    /** Setter-based so options resolve however the input is set — see `refreshChoiceOptions`. */
+    set field(value: NestedFieldConfig);
+    get field(): NestedFieldConfig;
+    set language(value: string);
+    get language(): string;
+    control: AbstractControl;
+    readonly: boolean;
+    masked: boolean;
+    /** Inline `options`, or the field's named list resolved through the registry (§6.3). */
+    readonly options: i0.WritableSignal<DropdownOption[]>;
+    readonly compareFn: (o1: unknown, o2: unknown) => boolean;
+    isObjectVal(option: DropdownOption): boolean;
+    get label(): string;
+    get placeholder(): string;
+    getOptStoredVal(option: DropdownOption): unknown;
+    getOptLabel(option: DropdownOption): string;
+    /**
+     * Read-only display. Never awaits (§6.2): a warm list resolves the label, a cold one falls
+     * back to the stored text — which under the §2 contract *is* the display value, so it is
+     * never wrong, only unlocalised.
+     */
+    getLabel(value: unknown): string;
+    get errorMessage(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownFieldComponent, "ngx-dropdown-field", never, { "field": { "alias": "field"; "required": false; }; "language": { "alias": "language"; "required": false; }; "control": { "alias": "control"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Radio field: a group of radio buttons built from field.options. */
+declare class RadioFieldComponent {
+    private readonly lookups;
+    private _field;
+    private _language;
+    /** Setter-based so options resolve however the input is set — see `refreshChoiceOptions`. */
+    set field(value: NestedFieldConfig);
+    get field(): NestedFieldConfig;
+    set language(value: string);
+    get language(): string;
+    control: AbstractControl;
+    readonly: boolean;
+    masked: boolean;
+    /** Inline `options`, or the field's named list resolved through the registry (§6.3). */
+    readonly options: i0.WritableSignal<DropdownOption[]>;
+    get label(): string;
+    getOptStoredVal(option: DropdownOption): unknown;
+    /**
+     * Stable DOM id for one radio, so the <label for> association works.
+     * Slugified because the option text is the value now — "On Leave" must not put a space
+     * into an id attribute.
+     */
+    getRadioId(option: DropdownOption): string;
+    getOptVal(option: DropdownOption): string | number | boolean;
+    getOptLabel(option: DropdownOption): string;
+    /** Read-only display — synchronous, per §6.2. See `DropdownFieldComponent.getLabel`. */
+    getSelectedLabel(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioFieldComponent, "ngx-radio-field", never, { "field": { "alias": "field"; "required": false; }; "language": { "alias": "language"; "required": false; }; "control": { "alias": "control"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MultiSelectFieldComponent {
+    private readonly lookups;
+    private _field;
+    private _language;
+    /** Setter-based so options resolve however the input is set — see `refreshChoiceOptions`. */
+    set field(value: NestedFieldConfig);
+    get field(): NestedFieldConfig;
+    set language(value: string);
+    get language(): string;
+    control: AbstractControl;
+    readonly: boolean;
+    masked: boolean;
+    /** Inline `options`, or the field's named list resolved through the registry (§6.3). */
+    readonly options: i0.WritableSignal<DropdownOption[]>;
+    readonly compareFn: (o1: unknown, o2: unknown) => boolean;
+    isObjectVal(option: DropdownOption): boolean;
+    get label(): string;
+    getOptStoredVal(option: DropdownOption): unknown;
+    getOptLabel(option: DropdownOption): string;
+    /** Read-only display — synchronous, per §6.2. See `DropdownFieldComponent.getLabel`. */
+    getLabels(values: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSelectFieldComponent, "ngx-multi-select-field", never, { "field": { "alias": "field"; "required": false; }; "language": { "alias": "language"; "required": false; }; "control": { "alias": "control"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * EntityRefFieldComponent — a select populated from a consumer-registered loader.
+ *
+ * Cascades: when `entityReference.parentField` is set, the component watches that sibling
+ * control (via `control.parent`) and reloads its own options on every parent change,
+ * clearing a now-invalid selection. It publishes the picked record on
+ * `EntityRefSelectionService` so the owning form can run `autoPatch`.
+ */
+declare class EntityRefFieldComponent implements OnInit {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    private readonly cascade;
+    private readonly selectionBus;
+    private readonly destroyRef;
+    readonly options: i0.WritableSignal<ReferenceOption[]>;
+    readonly loading: i0.WritableSignal<boolean>;
+    /** True when this field cascades but its parent has no value yet. */
+    readonly awaitingParent: i0.WritableSignal<boolean>;
+    get label(): string;
+    get placeholder(): string;
+    get parentFieldId(): string | undefined;
+    ngOnInit(): void;
+    /** Reload options against the parent's current value. */
+    reload(): Promise<void>;
+    /**
+     * Publish the selected option so autoPatch can copy from its record.
+     *
+     * Driven from `valueChanges` rather than the select's `change` event: that event is the
+     * same one the `formControl` directive listens to, so reading the control inside a
+     * template `(change)` handler can see the previous value. `valueChanges` fires after the
+     * model has updated — including Playwright `selectOption`, which updates the control
+     * through the value accessor.
+     */
+    onSelectionChange(value?: string): void;
+    private publishSelection;
+    getLabel(value: any): string;
+    private parentValue;
+    /** Reload (and drop a stale selection) whenever the parent control changes. */
+    private watchParent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityRefFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityRefFieldComponent, "ngx-entity-ref-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Renders a nested fieldset container for a group field's children. */
+declare class GroupFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    config: EntityFormConfig;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    userRoles: string[];
+    get label(): string;
+    getChildControl(childId: string): AbstractControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GroupFieldComponent, "ngx-group-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "config": { "alias": "config"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; "userRoles": { "alias": "userRoles"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Renders repeating rows for a FormArray, with Add Item and Remove. */
+declare class ArrayFieldComponent {
+    /**
+     * addItem/removeItem are public and may be called from outside this component's template,
+     * which under OnPush would not re-render. The host also watches the control, but this
+     * keeps the component correct on its own.
+     */
+    private readonly cdr;
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    config: EntityFormConfig;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    userRoles: string[];
+    private readonly fb;
+    private readonly validatorRegistry;
+    get label(): string;
+    get formArray(): FormArray;
+    getItemChildControl(itemGroup: AbstractControl, childId: string): AbstractControl;
+    addItem(): void;
+    removeItem(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayFieldComponent, "ngx-array-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "config": { "alias": "config"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; "userRoles": { "alias": "userRoles"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Image field: preview thumbnail + upload button.
+ *
+ * With `UPLOAD_HANDLER` registered the file is persisted and stored as `{ url }`; without one
+ * it is stored as `{ file }` and previewed from an object URL (revoked when replaced/destroyed).
+ */
+declare class ImageFieldComponent implements OnDestroy {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    private readonly uploads;
+    readonly uploading: i0.WritableSignal<boolean>;
+    readonly uploadError: i0.WritableSignal<string>;
+    /** Cached so an object URL is minted once per File, not once per change-detection pass. */
+    private previewSource;
+    private previewCache;
+    get label(): string;
+    previewUrl(): string | null;
+    onFileSelect(file: File | undefined): Promise<void>;
+    remove(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageFieldComponent, "ngx-image-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * File field: file input with filename display and download link.
+ * Shares the `FileRef` / `UPLOAD_HANDLER` contract with image-field via FileUploadService.
+ */
+declare class FileFieldComponent {
+    field: NestedFieldConfig;
+    control: AbstractControl;
+    language: string;
+    readonly: boolean;
+    masked: boolean;
+    private readonly uploads;
+    readonly uploading: i0.WritableSignal<boolean>;
+    readonly uploadError: i0.WritableSignal<string>;
+    get label(): string;
+    private get value();
+    fileUrl(): string | null;
+    fileName(): string | null;
+    onFileSelect(file: File | undefined): Promise<void>;
+    remove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileFieldComponent, "ngx-file-field", never, { "field": { "alias": "field"; "required": false; }; "control": { "alias": "control"; "required": false; }; "language": { "alias": "language"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { ASYNC_VALIDATOR_REGISTRY, ArrayFieldComponent, BooleanFieldComponent, COMMON_MODULES_REGISTRY, CONFIG_SOURCE, CascadeDataService, CheckboxFieldComponent, ConfigSourceService, CurrencyFieldComponent, DEFAULT_VALIDATION_MESSAGES, DateFieldComponent, DateTimeFieldComponent, DropdownFieldComponent, DynamicFieldComponent, DynamicFormComponent, DynamicRecordFormComponent, ENTITY_REF_CACHE_STORE, ENTITY_REF_REGISTRY, EmailFieldComponent, EntityRefFieldComponent, EntityRefRegistryService, EntityRefSelectionService, EntityReferenceService, FIELD_TYPE_REGISTRY, FIELD_TYPE_SETS, FieldRegistryService, FileFieldComponent, GroupFieldComponent, HOOK_REGISTRY, HookRegistryService, ImageFieldComponent, InMemoryEntityRefCacheStore, LOOKUP_REGISTRY, LookupRegistryService, MASKED_ROLES, MonthYearFieldComponent, MultiSelectFieldComponent, NumberFieldComponent, PasswordFieldComponent, RECORD_MIGRATIONS, RadioFieldComponent, RbacService, RulesEvaluationService, SYSTEM_DEFAULT_CAN_EDIT, TextFieldComponent, TextareaFieldComponent, TimeFieldComponent, UPLOAD_HANDLER, VALIDATION_MESSAGES, VALIDATOR_REGISTRY, ValidationMessagesService, ValidatorRegistryService, builtInFieldTypes, provideBuiltInFieldTypes, provideFieldTypes, provideNgxDynamicEntity, refreshChoiceOptions };
+export type { ChoiceOptionHost, ConfigSourceHandler, DynamicFieldComponentContract, EntityRefCacheStore, EntityRefSelection, HookFn, NgxDynamicEntityConfig, ValidationMessage };