@ng-forge/dynamic-forms 0.10.0-next.4 → 1.0.0-rc.2

package/types/ng-forge-dynamic-forms.d.ts

@@ -1,14 +1,13 @@
 import * as rxjs from 'rxjs';
 import * as _angular_core from '@angular/core';
-import { Type, Injector, Signal, EnvironmentInjector, WritableSignal, Provider, EnvironmentProviders, TemplateRef, InjectionToken } from '@angular/core';
+import { Type, Injector, Signal, EnvironmentInjector, WritableSignal, Provider, EnvironmentProviders, TemplateRef } from '@angular/core';
 import * as _ng_forge_dynamic_forms_internal from '@ng-forge/dynamic-forms/internal';
-import { FieldDef, FormEvent, RegisteredFieldTypes, InferFormValue as InferFormValue$1, FormConfig, FormOptions, EventBus, LazyComponentLoader, WrapperTypeDefinition, FieldTypeDefinition, DerivationLogLevel, Logger, ValueExclusionConfig, ValidationExecutionConfig, AnyAddon, WrapperFieldInputs, TextAddon, TemplateAddon, ComponentAddon, AddonActionPreset, AddonActionContext, AddonKindDefinition, FieldAddonSupport, BaseAddon, ArrayItemDefinition, NarrowFields, AvailableFieldTypes, ExtractField } from '@ng-forge/dynamic-forms/internal';
-export { ADDON_KIND_REGISTRY, AddonActionContext, AddonActionPreset, AddonKindDefinition, AddonKindSchema, AddonShapeValidator, AddonSlot, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayField, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComponentAddon, ConditionalExpression, ContainerAllowedChildren, ContainerField, ContainerFieldTypes, CssWrapper, CustomFnConfig, CustomFunction, CustomValidator, CustomValidatorConfig, DF_FIELD_TEMPLATES, DeclarativeHttpValidatorConfig, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormError, DynamicFormFieldRegistry, DynamicFormLogger, DynamicText, DynamicValue, EvaluationContext, ExtractField, FieldAddonSupport, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpValidationResponseMapping, InferFormValue, LeafFieldTypes, Logger, LogicConfig, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, NoopLogger, OrphanAddonActionContext, PageAllowedChildren, PageField, Prettify, RegisteredActionRef, RegisteredFieldTypes, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationExecutionConfig, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueType, WRAPPER_REGISTRY, WithInputSignals, WrapperConfig, WrapperTypeDefinition, evaluateNonFieldDisabled, evaluateNonFieldHidden, hasFormValue, isArrayField, isCheckedField, isContainerField, isContainerTypedField, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isValueField, isWrapperTypeDefinition, resolveDynamicValue, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled } from '@ng-forge/dynamic-forms/internal';
+import { FieldDef, FormEvent, RegisteredFieldTypes, InferFormValue as InferFormValue$1, FormConfig, FormOptions, EventBus, LazyComponentLoader, WrapperTypeDefinition, FieldTypeDefinition, DerivationLogLevel, Logger, ValueExclusionConfig, ValidationExecutionConfig, TextAddon, WrapperFieldInputs, TemplateAddon, ComponentAddon, BaseAddon, AddonTypeDefinition, AddonActionHandler, ArrayItemDefinition } from '@ng-forge/dynamic-forms/internal';
+export { AddonActionContext, AddonActionPreset, AddonSlot, AddonTypeDefinition, AnyAddon, ArrayAllowedChildren, ArrayButtonConfig, ArrayField, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseAddon, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, CheckedFieldComponent, CommonAddonActionPreset, CommonAddonSlot, ComponentAddon, ConditionalExpression, ContainerAllowedChildren, ContainerField, ContainerFieldTypes, CssWrapper, CustomFnConfig, CustomFunction, CustomValidator, CustomValidatorConfig, DF_FIELD_TEMPLATES, DeclarativeHttpValidatorConfig, DynamicFormActionRegistry, DynamicFormAddonActionPresetRegistry, DynamicFormAddonRegistry, DynamicFormAddonSlotRegistry, DynamicFormError, DynamicFormFieldRegistry, DynamicFormLogger, DynamicText, DynamicValue, EvaluationContext, ExtractField, FieldBoundAddonActionContext, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldRegistryWrappers, FieldWithValidation, FieldWrapper, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HiddenField, HiddenScalar, HiddenValue, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpValidationResponseMapping, InferFormValue, LeafFieldTypes, Logger, LogicConfig, NarrowField, NarrowFields, NextButtonOptions, NoopLogger, OrphanAddonActionContext, PageAllowedChildren, PageField, RegisteredActionRef, RegisteredFieldTypes, ResolvedValidationExecutionConfig, ResolvedValueExclusionConfig, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TemplateAddon, TextAddon, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationExecutionConfig, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueType, WithInputSignals, WrapperConfig, WrapperTypeDefinition, hasFormValue, isArrayField, isContainerField, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGroupField, isHiddenField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isWrapperTypeDefinition, resolveDynamicValue } from '@ng-forge/dynamic-forms/internal';
 import * as _angular_forms_signals from '@angular/forms/signals';
 import { FieldTree } from '@angular/forms/signals';
 import * as _angular_forms from '@angular/forms';
 import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
-import { FormSchema } from '@ng-forge/dynamic-forms/schema';
 
 /** Resolved field ready for rendering with ngComponentOutlet / DfFieldOutlet. */
 interface ResolvedField {
@@ -47,6 +46,7 @@ declare class FormResetEvent implements FormEvent {
     readonly type: "form-reset";
 }
 
+/** Event emitted when the active page of a paged form changes. */
 declare class PageChangeEvent implements FormEvent {
     /** The current page index (0-based) */
     readonly currentPageIndex: number;
@@ -85,8 +85,34 @@ declare class PageNavigationStateChangeEvent implements FormEvent {
 }
 
 /**
- * Dynamic form component — renders a form based on configuration.
- * Delegates state management to `FormStateManager`.
+ * Renders a form from a {@link FormConfig}. Attribute component on a native
+ * `<form>` element (selector `form[dynamic-form]`); state management is
+ * delegated to `FormStateManager`.
+ *
+ * Provide a UI adapter once via {@link provideDynamicForm} (for example
+ * `provideDynamicForm(...withMaterialFields())`), then bind a config and
+ * listen for `submitted`. Field-value types are inferred from the config when
+ * it is authored with `as const satisfies FormConfig`.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   imports: [DynamicForm],
+ *   template: `<form [dynamic-form]="config" (submitted)="onSubmit($event)"></form>`,
+ * })
+ * export class SignInComponent {
+ *   config = {
+ *     fields: [
+ *       { key: 'email', type: 'input', value: '', label: 'Email', required: true, email: true },
+ *       { type: 'submit', key: 'submit', label: 'Sign in' },
+ *     ],
+ *   } as const satisfies FormConfig;
+ *
+ *   onSubmit(value: InferFormValue<typeof this.config.fields>) {
+ *     console.log(value); // inferred: { email: string }
+ *   }
+ * }
+ * ```
  */
 declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFieldTypes[], TModel extends Record<string, unknown> = InferFormValue$1<TFields> & Record<string, unknown>> {
     /** Form configuration defining the structure, validation, and behavior. */
@@ -97,7 +123,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     value: _angular_core.ModelSignal<Partial<TModel> | undefined>;
     /**
      * How lenient the addon validator is on `config.fields[...].addons`.
-     * `'inline'` (default) keeps everything; `'json'` drops code-only kinds
+     * `'inline'` (default) keeps everything; `'json'` drops code-only types
      * with a warning. Read at form init and on every config swap — change
      * `source` AND the config to force re-validation mid-flight.
      */
@@ -147,7 +173,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     /** Default values computed from field definitions */
     defaultValues: WritableSignal<TModel>;
     /** The Angular Signal Form instance */
-    form: Signal<FieldTree<TModel, string | number>>;
+    form: Signal<FieldTree<TModel, string | number, "writable">>;
     /** Current form values (reactive) */
     formValue: Signal<TModel | (TModel extends infer T ? T extends TModel ? T extends _angular_forms.AbstractControl<unknown, infer TValue extends unknown, any> ? TValue : never : never : never)>;
     /** Whether the form is currently valid */
@@ -167,6 +193,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     /** Collects errors from async field component loading for error boundary patterns */
     fieldLoadingErrors: WritableSignal<FieldLoadingError[]>;
     /** Whether to render the form template */
+    private derivationReady;
     shouldRender: Signal<boolean>;
     /** Resolved fields ready for rendering */
     protected resolvedFields: Signal<ResolvedField[]>;
@@ -180,7 +207,7 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     validityChange: _angular_core.OutputRef<boolean>;
     /** Emits when form dirty state changes. */
     dirtyChange: _angular_core.OutputRef<boolean>;
-    /** Emits form values when submitted (via SubmitEvent) and form is valid. */
+    /** Emits form values when submitted (via FormSubmitEvent) and form is valid. */
     submitted: _angular_core.OutputRef<Partial<TModel>>;
     /** Emits when form is reset to default values. */
     reset: _angular_core.OutputRef<FormResetEvent>;
@@ -451,77 +478,6 @@ declare function withLegacyStatusClasses(): DynamicFormFeature<'legacy-status-cl
 /** Zero-cost type carrier used in wrapper registrations. */
 declare function wrapperProps<T>(): T;
 
-/**
- * Dispatcher component that renders an addon by looking up its `kind` in
- * `ADDON_KIND_REGISTRY` and instantiating the registered component.
- */
-declare class DfAddonSlot {
-    private readonly registry;
-    private readonly logger;
-    private readonly hostInjector;
-    readonly addon: _angular_core.InputSignal<AnyAddon>;
-    /**
-     * Optional read-only view of the host field's mapped inputs — same shape
-     * wrappers receive (`field?: ReadonlyFieldTree`, `key`, `props`, etc.).
-     * Forwarded to kind components so they can read field state without
-     * re-injecting `FIELD_SIGNAL_CONTEXT` and rebuilding context themselves.
-     */
-    readonly fieldInputs: _angular_core.InputSignal<WrapperFieldInputs | undefined>;
-    /**
-     * Pre-resolved `hidden` signal supplied by the host field. When provided,
-     * the dispatcher reads this instead of re-resolving `addon.hidden` —
-     * lets the host (e.g., `prime-input`) share a single subscription per
-     * Observable-typed `hidden` between its own visibility filter and the
-     * slot's `[style.display]` binding.
-     */
-    readonly hidden: _angular_core.InputSignal<Signal<boolean> | undefined>;
-    /** `slot` HTML attribute forwarded to host — needed for Ionic shadow projection. */
-    protected readonly slotAttr: Signal<_ng_forge_dynamic_forms.AddonSlot>;
-    protected readonly className: Signal<string | null>;
-    /**
-     * Locally-resolved `hidden` signal — always reflects `addon.hidden`
-     * regardless of whether the host supplied a pre-resolved signal.
-     * Populated via `explicitEffect` so `resolveDynamicValue` (which may call
-     * `toSignal` for Observable-typed values) does NOT run inside a reactive
-     * context (NG0602). The WeakMap caches per `hidden`-value identity, so
-     * swapping `addon` inputs that share the same Observable reuses the
-     * subscription instead of leaking a fresh one per swap.
-     */
-    private readonly _hiddenByValue;
-    private readonly _resolvedHidden;
-    /**
-     * `hidden` resolved from `DynamicValue<boolean>` to a flat `Signal<boolean>`.
-     * Prefers the host-supplied signal when present (avoids duplicate `toSignal`
-     * subscriptions for Observable-typed `hidden`); falls back to the locally-
-     * resolved signal, which is always populated by the addon-tracking effect.
-     */
-    protected readonly isHidden: Signal<boolean>;
-    /**
-     * Latest async-loaded `{ kind, component }` pair. Tagging the result with
-     * its kind lets `resolvedComponent` filter stale loads structurally — no
-     * monotonic token needed. When `addon.kind` changes mid-load, the prior
-     * load still completes and writes here, but the computed ignores it
-     * because the recorded kind no longer matches the current one.
-     */
-    private readonly asyncLoaded;
-    /**
-     * Resolved kind component — composed declaratively from two sources of
-     * truth: the registry's synchronous cache (warm hits, e.g., a second
-     * `<df-addon-slot>` for an already-loaded kind) and the kind-tagged async
-     * loader result. Reading `addon().kind` first makes the computed react to
-     * addon swaps and naturally invalidate stale async-load results.
-     */
-    protected readonly resolvedComponent: Signal<Type<unknown> | undefined>;
-    /** Inputs passed to the kind component — addon plus the wrapper-style host bag. */
-    protected readonly kindInputs: Signal<{
-        addon: AnyAddon;
-        fieldInputs: WrapperFieldInputs | undefined;
-    }>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DfAddonSlot, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DfAddonSlot, "df-addon-slot", never, { "addon": { "alias": "addon"; "required": true; "isSignal": true; }; "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
 /**
  * Marks an `<ng-template>` projected into `<df-dynamic-form>` content as
  * available to template addons by name.
@@ -535,7 +491,7 @@ declare class DfTemplate {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DfTemplate, "ng-template[dfTemplate]", ["dfTemplate"], { "dfTemplate": { "alias": "dfTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/** Renderer for the universal `text` addon kind. */
+/** Renderer for the universal `text` addon type. */
 declare class TextAddonComponent {
     readonly addon: _angular_core.InputSignal<TextAddon>;
     /** Accepted for contract uniformity — `NgComponentOutlet` setInput is strict; every kind must declare it. */
@@ -544,7 +500,7 @@ declare class TextAddonComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextAddonComponent, "df-text-addon", never, { "addon": { "alias": "addon"; "required": true; "isSignal": true; }; "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/** Renderer for the universal `template` addon kind. */
+/** Renderer for the universal `template` addon type. */
 declare class TemplateAddonComponent {
     private readonly templates;
     private readonly logger;
@@ -562,7 +518,7 @@ declare class TemplateAddonComponent {
 }
 
 /**
- * Renderer for the universal `component` addon kind.
+ * Renderer for the universal `component` addon type.
  *
  * @codeOnly The `component` loader is a function; this kind is dropped in
  * lenient validation when the config originated from JSON.
@@ -588,107 +544,11 @@ declare class ComponentAddonComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ComponentAddonComponent, "df-component-addon", never, { "addon": { "alias": "addon"; "required": true; "isSignal": true; }; "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/**
- * Optional collaborators a preset may need beyond the base context. Passed
- * by the button kind component which has access to its own DI scope.
- */
-interface PresetCollaborators {
-    /** Per-field input-type override signal — populated only inside an input field. */
-    readonly typeOverride?: WritableSignal<string | undefined>;
-    /** Writer that pushes a value into the host field's tree. */
-    readonly fieldValueSetter?: (next: unknown) => void;
-    /**
-     * Read the host field's configured default value (from the form's
-     * `defaultValues` map keyed by `field.key`). Used by the `'reset'`
-     * preset; absent when the addon is rendered outside an active field
-     * context, in which case `'reset'` falls back to clearing.
-     */
-    readonly fieldDefaultValueGetter?: () => unknown;
-    /**
-     * Baseline configured input type (from `props().type`), read at preset-run
-     * time. Used by `toggle-password-visibility` to refuse to corrupt
-     * `'email'`/`'number'`/etc. inputs into `'password'` when no override is
-     * yet set.
-     */
-    readonly baselineType?: () => string | undefined;
-    /** Logger for warnings about presets that can't be fulfilled in this context. */
-    readonly logger: Logger;
-}
-/**
- * Apply a built-in preset action against the addon's host field. Shared
- * across all adapters — each adapter's `ADDON_PRESET_HANDLER` provider
- * delegates here.
- *
- * @param adapterLabel Used in warnings — `'Material'` / `'Bootstrap'` / etc.
- * @param fieldLabel   Used in warnings — `'mat-input'` / `'bs-input'` / etc.
- */
-declare function runPresetAction(preset: AddonActionPreset, ctx: AddonActionContext, collaborators: PresetCollaborators, adapterLabel: string, fieldLabel: string): Promise<void>;
-
-/**
- * Cache for resolved addon-kind components.
- *
- * @internal
- */
-declare const ADDON_KIND_COMPONENT_CACHE: InjectionToken<Map<string, Type<unknown>>>;
-/**
- * Public shape returned by {@link injectAddonKindRegistry}. Pinned explicitly
- * so the API extractor doesn't churn between versions when the inner factory
- * gets refactored.
- */
-interface AddonKindRegistryRef {
-    getKind(kind: string): AddonKindDefinition | undefined;
-    hasKind(kind: string): boolean;
-    getKindNames(): string[];
-    loadKindComponent(kind: string): Promise<Type<unknown>>;
-    getLoadedKindComponent(kind: string): Type<unknown> | undefined;
-    readonly raw: ReadonlyMap<string, AddonKindDefinition>;
-}
-/** Injection function for accessing the addon kind registry. */
-declare function injectAddonKindRegistry(): AddonKindRegistryRef;
-
-/** One entry per field type that declares addon support. */
-interface FieldAddonSupportEntry {
-    readonly name: string;
-    readonly slots: FieldAddonSupport['slots'];
-    readonly allowedKinds: FieldAddonSupport['allowedKinds'];
-}
-/**
- * Walk `FIELD_REGISTRY` and return every field type that opted into addons
- * (i.e., declared `addons` on its `FieldTypeDefinition`).
- *
- * @Component({ ... })
- * class FormBuilder {
- *   protected readonly addonable = injectFieldsSupportingAddons();
- *
- *   constructor() {
- *     // -> [{ name: 'prime-input', slots: ['prefix', 'suffix'], allowedKinds: [...] }, ...]
- *   }
- * }
- * ```
- */
-declare function injectFieldsSupportingAddons(): FieldAddonSupportEntry[];
-
-/** Register a custom addon kind with the form. */
-declare function withCustomAddon<T extends BaseAddon>(definition: AddonKindDefinition<T>): DynamicFormFeature<'addons'>;
+/** Register a custom addon type with the form. */
+declare function withCustomAddon<T extends BaseAddon>(definition: AddonTypeDefinition<T>): DynamicFormFeature<'addons'>;
 
-/** Handler signature for user-registered addon actions. */
-type AddonActionHandler<TValue = unknown> = (ctx: AddonActionContext<TValue>) => void;
-/**
- * Multi-provider token populated by `provideAddonActions({...})` calls.
- * `ADDON_ACTION_REGISTRY` aggregates these into a single name → handler map.
- *
- * @internal
- */
-declare const ADDON_ACTION_HANDLERS: InjectionToken<readonly Record<string, AddonActionHandler<unknown>>[]>;
 /**
- * Form-scoped name → handler map. Read by adapter button kinds at click
- * time for `actionRef: 'name'` lookups. Provided at form scope (not root)
- * because `ADDON_ACTION_HANDLERS` is form-scoped via `provideAddonActions`.
- */
-declare const ADDON_ACTION_REGISTRY: InjectionToken<ReadonlyMap<string, AddonActionHandler<unknown>>>;
-
-/**
- * Typed feature returned by {@link provideAddonActions}. Carries the
+ * Typed feature returned by {@link withAddonActions}. Carries the
  * registered handler keys as a phantom type so consumers can derive the
  * `DynamicFormActionRegistry` augmentation in one line instead of hand-typing
  * every key.
@@ -698,16 +558,7 @@ type AddonActionsFeature<K extends string = string> = DynamicFormFeature<'addon-
     readonly __handlerKeys?: K;
 };
 /** Register named action handlers reachable via JSON-driven addon configs. */
-declare function provideAddonActions<const H extends Record<string, AddonActionHandler>>(handlers: H): AddonActionsFeature<keyof H & string>;
-
-/**
- * Multi-provider token used by `withCustomAddon(...)` features to contribute
- * addon kind definitions. `provideDynamicForm` aggregates all values into
- * the form-scoped `ADDON_KIND_REGISTRY` map.
- *
- * @internal
- */
-declare const ADDON_KIND_DEFINITIONS: InjectionToken<readonly AddonKindDefinition<_ng_forge_dynamic_forms.BaseAddon<_ng_forge_dynamic_forms.AddonSlot>>[]>;
+declare function withAddonActions<const H extends Record<string, AddonActionHandler>>(handlers: H): AddonActionsFeature<keyof H & string>;
 
 /** Reason an addon was dropped during validation. */
 type AddonWarning = {
@@ -725,55 +576,30 @@ type AddonWarning = {
     slot: string;
     allowedSlots: readonly string[];
 } | {
-    type: 'unknown-kind';
+    type: 'unknown-type';
     fieldKey: string;
-    kind: string;
-    registeredKinds: readonly string[];
+    addonType: string;
+    registeredTypes: readonly string[];
 } | {
-    type: 'kind-not-allowed';
+    type: 'type-not-allowed';
     fieldKey: string;
     fieldType: string;
-    kind: string;
-    allowedKinds: readonly string[];
+    addonType: string;
+    allowedTypes: readonly string[];
 } | {
     type: 'shape-violation';
     fieldKey: string;
-    kind: string;
+    addonType: string;
     reason: string;
 } | {
-    type: 'code-only-kind-in-json';
+    type: 'code-only-type-in-json';
     fieldKey: string;
-    kind: string;
+    addonType: string;
 } | {
     type: 'code-only-action-in-json';
     fieldKey: string;
     reason: string;
 };
-/** Render an `AddonWarning` to a developer-friendly message. */
-declare function formatAddonWarning(w: AddonWarning): string;
-
-/**
- * Walk a field's addons; return the survivors plus a list of warnings for
- * anything dropped.
- *
- * @param field        The field to validate.
- * @param fieldRegistry Snapshot of `FIELD_REGISTRY` map.
- * @param kindRegistry  Snapshot of `ADDON_KIND_REGISTRY` map.
- * @param source       Whether the config originated from JSON (lenient drop
- *                      of code-only kinds) or inline TypeScript.
- */
-declare function validateFieldAddons(field: FieldDef<unknown>, fieldRegistry: ReadonlyMap<string, FieldTypeDefinition>, kindRegistry: ReadonlyMap<string, AddonKindDefinition>, source: 'json' | 'inline'): {
-    addons: AnyAddon[];
-    warnings: AddonWarning[];
-};
-/**
- * Recursively walk a field tree, validating each field's addons. Returns a
- * sanitized copy of the input field array plus accumulated warnings.
- */
-declare function walkAndValidateAddons(fields: readonly FieldDef<unknown>[], fieldRegistry: ReadonlyMap<string, FieldTypeDefinition>, kindRegistry: ReadonlyMap<string, AddonKindDefinition>, source: 'json' | 'inline'): {
-    fields: FieldDef<unknown>[];
-    warnings: AddonWarning[];
-};
 
 /** Options accepted by {@link sanitizeFormConfig}. */
 interface SanitizeFormConfigOptions {
@@ -792,7 +618,7 @@ interface SanitizedFormConfig {
 }
 /**
  * Walk a `FormConfig`, validate every field's addons against the active
- * `FIELD_REGISTRY` and `ADDON_KIND_REGISTRY`, and return a sanitized copy
+ * `FIELD_REGISTRY` and `ADDON_TYPE_REGISTRY`, and return a sanitized copy
  * plus a list of dropped-addon warnings.
  *
  * @Component({ ... })
@@ -808,28 +634,18 @@ interface SanitizedFormConfig {
  * ```
  */
 declare function sanitizeFormConfig(config: FormConfig, options?: SanitizeFormConfigOptions): SanitizedFormConfig;
-/**
- * Default warning sink. Pass a `DynamicFormLogger` to route through the
- * form's configured logger (respects `NoopLogger` opt-out); omit it to
- * fall back to `console.warn` for build-time / admin-UI use cases that
- * run outside an Angular injection context.
- */
-declare function logAddonWarnings(warnings: readonly AddonWarning[], logger?: Logger): void;
-/**
- * DI-free variant of {@link sanitizeFormConfig} for tooling that lives
- * outside Angular's injector — build-time linters, MCP-side checks, CLI
- * scripts.
- */
-declare function sanitizeFormConfigPure(config: FormConfig, fieldRegistry: ReadonlyMap<string, _ng_forge_dynamic_forms_internal.FieldTypeDefinition>, kindRegistry: ReadonlyMap<string, _ng_forge_dynamic_forms_internal.AddonKindDefinition>, options?: SanitizeFormConfigOptions): SanitizedFormConfig;
 
-declare class SubmitEvent implements FormEvent {
+/** Event dispatched to submit the form (the action behind a `submit` button). */
+declare class FormSubmitEvent implements FormEvent {
     readonly type: "submit";
 }
 
+/** Event dispatched to advance a paged form to the next page. */
 declare class NextPageEvent implements FormEvent {
     readonly type: "next-page";
 }
 
+/** Event dispatched to return a paged form to the previous page. */
 declare class PreviousPageEvent implements FormEvent {
     readonly type: "previous-page";
 }
@@ -1062,29 +878,5 @@ interface ArrayItemContext {
     formValue?: unknown;
 }
 
-/**
- * Type-safe form config builder that ensures schema matches field structure.
- *
- * @typeParam TFields - The field definitions array (narrowed via `as const`)
- * @typeParam TProps - Optional form-level default props type
- * @param config - The form configuration object
- * @returns The same configuration with proper type inference
- */
-declare function formConfig<const TFields extends NarrowFields, TProps extends object = Record<string, unknown>>(config: Omit<FormConfig<TFields, InferFormValue$1<TFields>, TProps>, 'schema'> & {
-    schema?: FormSchema<InferFormValue$1<TFields>>;
-}): FormConfig<TFields, InferFormValue$1<TFields>, TProps>;
-
-/**
- * Creates a typed field configuration with helpful error messages for common mistakes.
- *
- * @param type - The field type (e.g., 'input', 'select', 'group')
- * @param config - The field configuration (excluding the 'type' property)
- * @returns A properly typed field configuration
- * @throws DynamicFormError if the configuration contains common mistakes
- */
-declare function createField<T extends AvailableFieldTypes>(type: T, config: Omit<ExtractField<T>, 'type'>): ExtractField<T>;
-/** Shorthand alias for createField */
-declare const field: typeof createField;
-
-export { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_KIND_COMPONENT_CACHE, ADDON_KIND_DEFINITIONS, AppendArrayItemEvent, BUILT_IN_FIELDS, ComponentAddonComponent, ConsoleLogger, DfAddonSlot, DfTemplate, DynamicForm, EventDispatcher, FormClearEvent, FormResetEvent, InsertArrayItemEvent, MoveArrayItemEvent, NextPageEvent, PageChangeEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, ShiftArrayItemEvent, SubmitEvent, TemplateAddonComponent, TextAddonComponent, arrayEvent, createField, createWrappers, field, formConfig, formatAddonWarning, injectAddonKindRegistry, injectFieldsSupportingAddons, isWrappersBundle, logAddonWarnings, provideAddonActions, provideDynamicForm, runPresetAction, sanitizeFormConfig, sanitizeFormConfigPure, validateFieldAddons, walkAndValidateAddons, withCustomAddon, withEventFormValue, withLegacyStatusClasses, withLoggerConfig, withValidationExecutionDefaults, withValueExclusionDefaults, wrapperProps };
-export type { AddonActionHandler, AddonActionsFeature, AddonWarning, ArrayItemContext, ArrayItemDefinitionTemplate, ExtractFieldDefs, ExtractFormValue, FieldAddonSupportEntry, InferWrapperRegistry, PresetCollaborators, SanitizeFormConfigOptions, SanitizedFormConfig, WrapperRegistration, WrappersBundle };
+export { AppendArrayItemEvent, BUILT_IN_FIELDS, ComponentAddonComponent, ConsoleLogger, DfTemplate, DynamicForm, EventDispatcher, FormClearEvent, FormResetEvent, FormSubmitEvent, InsertArrayItemEvent, MoveArrayItemEvent, NextPageEvent, PageChangeEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, ShiftArrayItemEvent, TemplateAddonComponent, TextAddonComponent, arrayEvent, createWrappers, isWrappersBundle, provideDynamicForm, sanitizeFormConfig, withAddonActions, withCustomAddon, withEventFormValue, withLegacyStatusClasses, withLoggerConfig, withValidationExecutionDefaults, withValueExclusionDefaults, wrapperProps };
+export type { AddonActionsFeature, AddonWarning, ArrayItemContext, ArrayItemDefinitionTemplate, ExtractFieldDefs, ExtractFormValue, InferWrapperRegistry, SanitizeFormConfigOptions, SanitizedFormConfig, WrapperRegistration, WrappersBundle };