@modyra/angular 0.2.0

package/types/modyra-angular.d.ts

@@ -0,0 +1,2385 @@
+import * as _angular_core from '@angular/core';
+import { Signal, WritableSignal, Injector, InjectionToken, Provider, TemplateRef, OnInit, ElementRef, InputSignal, OnDestroy, InputSignalWithTransform } from '@angular/core';
+import * as _modyra_core from '@modyra/core';
+import { MdyFormError, MdyFieldError, MdyFormSubmitEvent, MdyControlOption, ValidatorFn, MdySelectOption, MdyFormRegistry, MdyFormEngine, MdySubmitMode, MdyI18nMessages, MdyBuiltInLocale, MdyDateLocale, MdyAnyArrayDescriptor as MdyAnyArrayDescriptor$1, MdyAnyFieldDescriptor as MdyAnyFieldDescriptor$1, MdyAnyGroupDescriptor as MdyAnyGroupDescriptor$1, MdyArrayDescriptor as MdyArrayDescriptor$1, MdyArrayItemValue as MdyArrayItemValue$1, MdyFieldDescriptor as MdyFieldDescriptor$1, MdyFormSchema as MdyFormSchema$1, MdyGroupDescriptor as MdyGroupDescriptor$1, MdyFieldOptions as MdyFieldOptions$1, MdyTypedFormBaseOptions, MdyFormPatch as MdyFormPatch$1, MdyFormValue as MdyFormValue$1, MdyTypedFormBase, MdyWiden as MdyWiden$1, MdyFormValidatorFn, MdyAsyncValidatorFn, MdyAsyncValidatorOptions, MdyDateRange, MdyReactivity } from '@modyra/core';
+export { MdyAsyncValidatorFn, MdyAsyncValidatorOptions, MdyControlOption, MdyDateRange, MdyDraftOptions, MdyDraftStorage, MdyFieldError, MdyFormError, MdyFormSubmitEvent, MdyFormValidatorFn, MdySelectOption, MdySubmitMode, ValidatorFn } from '@modyra/core';
+import * as _modyra_angular from '@modyra/angular';
+import { MdyDynamicField } from '@modyra/core/dynamic-config';
+import * as packages_core_dist from 'packages/core/dist';
+import { OverlayPosition, OverlayAlignment, OverlayAnchor } from '@modyra/core/overlay-position';
+import { CalendarCell, CalendarDate } from '@modyra/core/date-utils';
+import * as _modyra_widgets from '@modyra/widgets';
+import { MdyUiCommand, MdySelectState, MdySelectController, MdySelectControllerOptions, MdySelectIntent } from '@modyra/widgets';
+import { MdyTimeFormat } from '@modyra/core/time-utils';
+import { SafeHtml } from '@angular/platform-browser';
+
+/**
+ * Mirrors the FieldState exposed by @angular/forms/signals.
+ * Stable public contract — isolated from upstream API changes.
+ */
+interface MdyFieldState<TValue> {
+    readonly value: WritableSignal<TValue>;
+    readonly valid: Signal<boolean>;
+    readonly touched: WritableSignal<boolean>;
+    readonly dirty: WritableSignal<boolean>;
+    readonly disabled: Signal<boolean>;
+    readonly readonly: Signal<boolean>;
+    readonly pending: Signal<boolean>;
+    readonly required: Signal<boolean>;
+    readonly errors: Signal<ReadonlyArray<MdyFieldError>>;
+}
+/** Callable that returns the FieldState for a field. */
+type MdyFieldRef<TValue> = () => MdyFieldState<TValue>;
+/**
+ * Maps a form model type `T` to a tree of field refs, mirroring the model shape.
+ * Each key of `T` becomes an `MdyFieldRef` for its corresponding value type.
+ */
+type MdyFieldTree<T extends Record<string, unknown>> = {
+    readonly [K in keyof T]: MdyFieldRef<T[K]>;
+};
+/**
+ * Interface for components that support options override (e.g. Select, Multiselect).
+ * Used by conditional directives to avoid circular dependencies.
+ */
+interface MdyOptionsControl<TValue = unknown> {
+    readonly overrideOptions: WritableSignal<readonly MdySelectOption<TValue>[] | null>;
+    readonly options: Signal<readonly MdySelectOption<TValue>[]>;
+    readonly loading: Signal<boolean>;
+    readonly loadingOverride: WritableSignal<boolean | null>;
+    /** Current search query typed in the control's search input. */
+    readonly searchQuery: Signal<string>;
+    resetSelection(): void;
+}
+interface MdyControlRendererConfig {
+    readonly label?: string;
+    readonly hint?: string;
+    readonly placeholder?: string;
+    readonly options?: ReadonlyArray<MdyControlOption<unknown>>;
+}
+interface MdyFormState {
+    readonly valid: Signal<boolean>;
+    readonly pending: Signal<boolean>;
+    readonly submitting: Signal<boolean>;
+    readonly submitCount: Signal<number>;
+    readonly canSubmit: Signal<boolean>;
+    readonly lastSubmitErrors: Signal<ReadonlyArray<MdyFormError>>;
+}
+interface MdyFormAdapter<T extends object> {
+    readonly state: MdyFormState;
+    /** Reactive signal that emits the current form value on every change. */
+    readonly value: Signal<T>;
+    getValue(): T;
+    getField<K extends keyof T>(name: K): MdyFieldRef<T[K]> | null;
+    errorsFor(path: keyof T | string): Signal<ReadonlyArray<MdyFormError>>;
+    submit(action: (value: T) => Promise<MdyFormError[] | void> | MdyFormError[] | void): Promise<void>;
+    markAllTouched(): void;
+    buildSubmitEvent(value: T): MdyFormSubmitEvent<T>;
+    /** Merge partial values into the form without touching other fields. */
+    patchValue(partial: Partial<T>): void;
+    /** Replace the entire form value. */
+    setValue(value: T): void;
+    /**
+     * Resets all fields to their declared initial values and clears touched/dirty state.
+     *
+     * Reset semantics:
+     * - Fields with an explicit `[initialValue]` binding reset to that value.
+     * - Fields seeded only via `[formValue]` (no `[initialValue]`) reset to `null`.
+     *   `[formValue]` is a prefill seed, not a persistent reset target.
+     * - All `touched` and `dirty` states are cleared to `false`.
+     */
+    reset(): void;
+}
+interface MdyFormContext {
+    readonly valid: Signal<boolean>;
+    readonly submitting: Signal<boolean>;
+    readonly submitCount: Signal<number>;
+    readonly lastSubmitErrors: Signal<ReadonlyArray<MdyFormError>>;
+}
+interface MdyFieldConfig<TValue = unknown> {
+    readonly name: string;
+    readonly validators?: ReadonlyArray<ValidatorFn<TValue>>;
+    readonly initialValue?: TValue;
+    readonly disabled?: boolean;
+}
+
+/**
+ * The flat path protocol controls and validator directives speak.
+ * Angular specialization of the framework-agnostic core registry contract.
+ */
+type MdyDeclarativeRegistry = MdyFormRegistry<Signal<boolean>>;
+/**
+ * Adapter used when `<mdy-form>` runs without an explicit [adapter] input,
+ * and the engine underneath `mdyForm()`.
+ *
+ * Since the domain-model extraction this class is a thin Angular binding of
+ * the framework-agnostic {@link MdyFormEngine} from `@modyra/core`: it feeds
+ * the engine Angular's native signal primitives (via `angularReactivity`),
+ * so every piece of form state is a real Angular signal that participates
+ * in change detection — zoneless included. All semantics (lazy fields,
+ * keyed validators, async last-wins, drafts, history, server-error
+ * snapshots) live in the engine.
+ */
+declare class MdyDeclarativeAdapter extends MdyFormEngine implements MdyFormAdapter<Record<string, unknown>>, MdyDeclarativeRegistry {
+    constructor(formValue: Signal<Record<string, unknown> | undefined>, submitMode?: Signal<MdySubmitMode>, 
+    /** Needed to run async validators, drafts and history. */
+    injector?: Injector);
+    readonly state: MdyFormState;
+    readonly value: Signal<Record<string, unknown>>;
+    readonly fieldNames: Signal<readonly string[]>;
+    readonly hasDraft: Signal<boolean>;
+    readonly canUndo: Signal<boolean>;
+    readonly canRedo: Signal<boolean>;
+    getField(name: string): MdyFieldRef<unknown> | null;
+    errorsFor(path: string): Signal<ReadonlyArray<MdyFormError>>;
+}
+
+/**
+ * Scoped to MdyFormComponent via providers[].
+ * Injected by renderer components to resolve FieldRefs.
+ */
+declare const MDY_FORM_ADAPTER: InjectionToken<MdyFormAdapter<Record<string, unknown>>>;
+/**
+ * When provided on an element injector, renderers display errors
+ * inline next to the label rather than as a block below the input.
+ */
+declare const MDY_INLINE_ERRORS: InjectionToken<boolean>;
+/**
+ * Provided by MdyFloatingLabelsDirective to enable floating labels globally on a form.
+ */
+declare const MDY_FLOATING_LABELS: InjectionToken<_modyra_angular.MdyFloatingLabelsDirective>;
+/**
+ * Global default for whether floating labels are enabled.
+ * Override at application root to change the default for all forms.
+ * Defaults to `false` (floating labels opt-in via `mdyFloatingLabels` directive).
+ */
+declare const MDY_FLOATING_LABELS_DEFAULT: InjectionToken<boolean>;
+/**
+ * Global default density for floating labels.
+ * Replicates M3 density semantics: 0 = standard 56px, negative values compact.
+ * Defaults to `-2` (48px, balanced compactness).
+ */
+declare const MDY_FLOATING_LABELS_DENSITY_DEFAULT: InjectionToken<number>;
+/**
+ * Provided by MdyFormComponent in declarative mode (no explicit [adapter] input).
+ * Validator directives inject this to register their rules on specific fields.
+ */
+declare const MDY_DECLARATIVE_REGISTRY: InjectionToken<MdyDeclarativeRegistry>;
+
+/**
+ * All static UI strings used by modyra renderers.
+ * Override by providing `MDY_I18N_MESSAGES` at the root or component level.
+ *
+ * @example
+ * providers: [{ provide: MDY_I18N_MESSAGES, useValue: { ...MDY_I18N_MESSAGES_DEFAULT, noResults: 'Nessun risultato' } }]
+ */
+declare const MDY_I18N_MESSAGES: InjectionToken<MdyI18nMessages>;
+
+interface MdyLocaleOptions {
+    /**
+     * BCP 47 tag for `Intl`-based date formatting (month/day names, first day
+     * of week). Defaults to the canonical tag of the language preset.
+     */
+    readonly dateLocale?: string;
+    /** Per-key overrides applied on top of the language preset. */
+    readonly overrides?: Partial<MdyI18nMessages>;
+}
+/**
+ * Provides both UI strings and date localisation with one call:
+ *
+ * ```ts
+ * bootstrapApplication(App, {
+ *   providers: [provideModyraLocale("it")],
+ * });
+ * ```
+ *
+ * Built-in presets: `en`, `it`, `de`, `fr`, `es`. Use `overrides` to adjust
+ * individual keys, or provide `MDY_I18N_MESSAGES` yourself for other
+ * languages (the token is a plain object of strings).
+ */
+declare function provideModyraLocale(locale: MdyBuiltInLocale, options?: MdyLocaleOptions): Provider[];
+
+/**
+ * DI token that provides locale configuration for date components.
+ *
+ * The locale shape and builder are framework-agnostic and come from
+ * `@modyra/core`; Angular keeps only the token/provider wiring here.
+ */
+declare const MDY_DATE_LOCALE: InjectionToken<MdyDateLocale>;
+
+type MdyAnyArrayDescriptor = MdyAnyArrayDescriptor$1;
+type MdyAnyFieldDescriptor = MdyAnyFieldDescriptor$1;
+type MdyAnyGroupDescriptor = MdyAnyGroupDescriptor$1;
+type MdyArrayDescriptor<TItem> = MdyArrayDescriptor$1<TItem>;
+type MdyArrayItemValue<I> = MdyArrayItemValue$1<I>;
+type MdyFieldDescriptor<TValue> = MdyFieldDescriptor$1<TValue>;
+type MdyFieldOptions<TValue> = MdyFieldOptions$1<TValue>;
+type MdyFormPatch<S extends MdyFormSchema$1> = MdyFormPatch$1<S>;
+type MdyFormSchema = MdyFormSchema$1;
+type MdyFormValue<S extends MdyFormSchema$1> = MdyFormValue$1<S>;
+type MdyGroupDescriptor<TChildren extends MdyFormSchema$1> = MdyGroupDescriptor$1<TChildren>;
+type MdyWiden<T> = MdyWiden$1<T>;
+/**
+ * Typed handle for a single field, exposed on `form.f`.
+ * Bind it to a renderer with `[field]="form.f.email"` — a typo on the
+ * handle path is a compile error, unlike the stringly `name` attribute.
+ */
+interface MdyFieldHandle<TValue> {
+    /** Flat adapter path of the field (dot-separated for nested groups). */
+    readonly path: string;
+    readonly value: Signal<TValue>;
+    readonly errors: Signal<ReadonlyArray<MdyFieldError>>;
+    readonly touched: Signal<boolean>;
+    readonly dirty: Signal<boolean>;
+    readonly valid: Signal<boolean>;
+    readonly pending: Signal<boolean>;
+    readonly required: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    set(value: TValue): void;
+    markAsTouched(): void;
+    markAsDirty(): void;
+}
+/** Typed handle for a repeatable array item, exposed on `form.f` (`form.f.items`). */
+interface MdyArrayHandle<TItemHandle, TItemValue> {
+    readonly path: string;
+    readonly length: Signal<number>;
+    readonly rows: Signal<ReadonlyArray<TItemHandle>>;
+    readonly errors: Signal<ReadonlyArray<MdyFieldError>>;
+    readonly valid: Signal<boolean>;
+    push(value: TItemValue): void;
+    insert(index: number, value: TItemValue): void;
+    remove(index: number): void;
+    move(from: number, to: number): void;
+    setAll(values: ReadonlyArray<TItemValue>): void;
+    at(index: number): TItemHandle | null;
+}
+/** The handle tree for a single array item — a field handle or nested group tree. */
+type MdyItemHandleTree<I> = I extends MdyGroupDescriptor<infer C> ? MdyFieldHandleTree<C> : I extends MdyFieldDescriptor<infer V> ? MdyFieldHandle<V> : never;
+/** The typed handle tree mirroring the schema shape (`form.f.address.city`). */
+type MdyFieldHandleTree<S extends MdyFormSchema> = {
+    readonly [K in keyof S]: S[K] extends MdyFieldDescriptor<infer V> ? MdyFieldHandle<V> : S[K] extends MdyGroupDescriptor<infer C> ? MdyFieldHandleTree<C> : S[K] extends MdyArrayDescriptor<infer I> ? MdyArrayHandle<MdyItemHandleTree<I>, MdyArrayItemValue<I>> : never;
+};
+/** Declares a typed leaf field of a {@link mdyForm} schema. */
+declare function field<TValue>(initial: MdyWiden<TValue>, validators?: ReadonlyArray<ValidatorFn<MdyWiden<TValue>>>, options?: MdyFieldOptions<MdyWiden<TValue>>): MdyFieldDescriptor<MdyWiden<TValue>>;
+/** Declares a nested group of fields (`address.city` paths on the adapter). */
+declare function group<TChildren extends MdyFormSchema>(children: TChildren): MdyGroupDescriptor<TChildren>;
+/** Declares a repeatable array of fields or groups (`items.0.name` paths on the adapter). */
+declare function array<TItem extends MdyAnyGroupDescriptor | MdyAnyFieldDescriptor>(item: TItem, options?: {
+    readonly initial?: ReadonlyArray<unknown>;
+    readonly validators?: ReadonlyArray<ValidatorFn<readonly unknown[]>>;
+}): MdyArrayDescriptor<TItem>;
+interface MdyFormOptions<TValue extends Record<string, unknown> = Record<string, unknown>> extends MdyTypedFormBaseOptions<TValue> {
+    readonly submitMode?: MdySubmitMode;
+    /**
+     * Needed only for async validators when `mdyForm()` is called outside an
+     * injection context; inside a field initializer it is resolved automatically.
+     */
+    readonly injector?: Injector;
+}
+/**
+ * Structural supertype of every `MdyTypedForm<S>` — what `<mdy-form [form]>`
+ * accepts without caring about the concrete schema type. Mirrors
+ * `MdyFormAdapter` with schema-agnostic value types.
+ */
+interface MdyTypedFormLike extends MdyDeclarativeRegistry {
+    readonly state: MdyFormState;
+    readonly value: Signal<Record<string, unknown>>;
+    getValue(): Record<string, unknown>;
+    getField(name: string): MdyFieldRef<unknown> | null;
+    errorsFor(path: string): Signal<ReadonlyArray<MdyFormError>>;
+    submit(action: (value: Record<string, unknown>) => Promise<MdyFormError[] | void> | MdyFormError[] | void): Promise<void>;
+    markAllTouched(): void;
+    buildSubmitEvent(value: never): MdyFormSubmitEvent<Record<string, unknown>>;
+    patchValue(partial: never): void;
+    setValue(value: never): void;
+    reset(): void;
+}
+/**
+ * Creates a typed, signal-based form model from a schema.
+ *
+ * ```ts
+ * const form = mdyForm({
+ *   email: field("", [required(), email()]),
+ *   age: field<number | null>(null, [min(18)]),
+ *   address: group({ city: field(""), zip: field("") }),
+ * });
+ *
+ * form.f.email.value();        // Signal<string>
+ * form.f.address.city.set("Rome");
+ * form.getValue().age;         // number | null — typos do not compile
+ * ```
+ * ```html
+ * <mdy-form [form]="form" (submitted)="onSubmit($event)">
+ *   <mdy-control-text [field]="form.f.email" label="Email" />
+ * </mdy-form>
+ * ```
+ */
+declare function mdyForm<S extends MdyFormSchema>(schema: S, options?: MdyFormOptions<MdyFormValue<S>>): MdyTypedForm<S>;
+/**
+ * Typed form model over the flat {@link MdyDeclarativeAdapter}.
+ *
+ * Inherits all framework-agnostic behavior from {@link MdyTypedFormBase} in
+ * `@modyra/core`; this class only adds Angular signal narrowing and the
+ * injector-aware constructor.
+ */
+declare class MdyTypedForm<S extends MdyFormSchema> extends MdyTypedFormBase<S, MdyFieldHandle<unknown>, Signal<boolean>> implements MdyFormAdapter<MdyFormValue<S>>, MdyDeclarativeRegistry {
+    protected readonly _adapter: MdyDeclarativeAdapter;
+    readonly state: MdyFormState;
+    readonly f: MdyFieldHandleTree<S>;
+    readonly value: Signal<MdyFormValue<S>>;
+    constructor(schema: S, options?: MdyFormOptions<MdyFormValue<S>>);
+    getField<K extends keyof MdyFormValue<S>>(name: K): MdyFieldRef<MdyFormValue<S>[K]> | null;
+    getField(name: string): MdyFieldRef<unknown> | null;
+    errorsFor(path: keyof MdyFormValue<S> | string): Signal<ReadonlyArray<MdyFormError>>;
+    get canUndo(): Signal<boolean>;
+    get canRedo(): Signal<boolean>;
+    get hasDraft(): Signal<boolean>;
+    get fieldNames(): Signal<readonly string[]>;
+    protected _buildHandle(path: string): MdyFieldHandle<unknown>;
+}
+
+/**
+ * Pure state-manager for a dynamically-sized list of repeating sub-forms.
+ *
+ * Manages the items array (add/remove) and collects values/validity from
+ * `<mdy-form>` content children. The consumer renders the forms directly
+ * in its own template so Angular DI works correctly for renderer components.
+ *
+ * Usage:
+ * ```html
+ * <mdy-form-array #arr [initialItems]="items">
+ *   @for (item of arr.items(); track item._id; let idx = $index) {
+ *     <mdy-form [formValue]="item.value">
+ *       <mdy-control-text name="nome" label="Nome" />
+ *       <button type="button" (click)="arr.remove(idx)">Remove</button>
+ *     </mdy-form>
+ *   }
+ * </mdy-form-array>
+ * <button (click)="arr.add()">Add</button>
+ * ```
+ *
+ * Read results with `arr.getValue()` and validity with `arr.isValid()`.
+ */
+declare class MdyFormArrayComponent<T extends Record<string, unknown>> {
+    /** Seed values for the initial rows. Re-setting this input resets all rows. */
+    readonly initialItems: _angular_core.InputSignal<readonly T[]>;
+    private _nextId;
+    /**
+     * Reactive items list — bind this in the consumer's `@for` to drive the rows.
+     * Each entry carries a stable `_id` for `track` and the row seed `value`.
+     * Seeds are `Partial<T>`: rows added without a value start empty and get
+     * completed by the user (B43 — no unsound `Partial<T> as T` cast).
+     */
+    readonly items: WritableSignal<Array<{
+        _id: number;
+        value: Partial<T>;
+    }>>;
+    /** All `<mdy-form>` content children, in DOM order. */
+    private readonly _forms;
+    /** Aggregated validity signal — `true` when every row form is valid. */
+    readonly state: Signal<{
+        valid: boolean;
+    }>;
+    /** Returns `true` when every row form is valid. */
+    isValid(): boolean;
+    /**
+     * Collects and returns the current value of every row form, in DOM order.
+     * Rows are typed `Partial<T>`: a row whose controls have not all been
+     * filled genuinely lacks those keys. Validate with `isValid()` before
+     * treating entries as complete `T` (B43).
+     */
+    getValue(): Array<Partial<T>>;
+    /** Appends a new row pre-filled with the given partial value. */
+    add(value?: Partial<T>): void;
+    /** Removes the row at the given index. */
+    remove(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyFormArrayComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyFormArrayComponent<any>, "mdy-form-array", never, { "initialItems": { "alias": "initialItems"; "required": false; "isSignal": true; }; }, {}, ["_forms"], ["*"], true, never>;
+}
+
+/**
+ * Host component for a declarative signal-driven form.
+ *
+ * Provides the adapter to all descendant renderer components via DI.
+ *
+ * **Explicit adapter mode** (existing API, unchanged):
+ * ```html
+ * <mdy-form [adapter]="adapter" (submitted)="handle($event)">…</mdy-form>
+ * ```
+ *
+ * **Declarative mode** (no adapter needed):
+ * ```html
+ * <mdy-form [formValue]="{ age: 18 }" (submitted)="handle($event)">
+ *   <mdy-control-text name="email" mdyRequired mdyEmail />
+ *   <mdy-control-number name="age" [mdyMin]="18" />
+ * </mdy-form>
+ * ```
+ */
+declare class MdyFormComponent<T extends Record<string, unknown>> implements MdyFormAdapter<T>, MdyDeclarativeRegistry {
+    /** Explicit adapter — if omitted the form creates one automatically. */
+    readonly adapter: _angular_core.InputSignal<MdyFormAdapter<T> | undefined>;
+    /**
+     * Typed form model created with `mdyForm()`. Takes precedence over the
+     * internal declarative adapter; `[adapter]` still wins over both.
+     * `[formValue]` is ignored in this mode — initial values live in the schema.
+     */
+    readonly form: _angular_core.InputSignal<(MdyFormAdapter<T> & MdyDeclarativeRegistry) | undefined>;
+    readonly action: _angular_core.InputSignal<((value: T) => Promise<MdyFormError[] | void> | MdyFormError[] | void) | undefined>;
+    /**
+     * Default values for declarative mode.
+     * Per-control [initialValue] takes precedence over this.
+     */
+    readonly formValue: _angular_core.InputSignal<Partial<Record<string, unknown>> | undefined>;
+    /** Submit behaviour for declarative mode (ignored when adapter is provided). */
+    readonly submitMode: _angular_core.InputSignal<MdySubmitMode>;
+    /**
+     * Form-level (cross-field) validators for declarative mode. Build them
+     * with `crossField()`; errors land on the involved fields (or on the form
+     * with `path: null`). With `[form]`/`[adapter]` declare validators on the
+     * model instead.
+     */
+    readonly formValidators: _angular_core.InputSignal<readonly MdyFormValidatorFn<Record<string, unknown>>[]>;
+    /**
+     * Declarative-mode draft autosave: persists the form value under this key
+     * (localStorage) and restores it on init; cleared after an error-free
+     * submit. With `[form]`/`[adapter]` configure the draft on the model.
+     */
+    readonly draftKey: _angular_core.InputSignal<string | undefined>;
+    readonly submitted: _angular_core.OutputEmitterRef<MdyFormSubmitEvent<T>>;
+    private readonly _declarativeAdapter;
+    /** Last seed applied from [formValue] — used to diff per key (B2). */
+    private _lastSeed;
+    /** One-shot guard for the registry-incompatible [adapter] dev warning. */
+    private _warnedAdapterRegistry;
+    constructor();
+    claimField(name: string): void;
+    removeField(name: string): void;
+    /** Active adapter: [adapter] wins, then [form], then the internal one. */
+    private get _active();
+    /**
+     * Registry target for controls/directives. Must resolve to the same object
+     * as {@link _active}: claims and validators registered on a different
+     * adapter than the one whose value is displayed would silently diverge
+     * (required not applied, wrong field released on destroy).
+     */
+    private get _registry();
+    addValidators<V>(name: string, validators: ReadonlyArray<ValidatorFn<V>>, isRequired?: boolean): void;
+    upsertValidators<V>(name: string, key: string, validators: ReadonlyArray<ValidatorFn<V>>, marksRequired?: boolean): void;
+    removeValidators(name: string, key: string): void;
+    upsertAsyncValidators<V>(name: string, key: string, validators: ReadonlyArray<MdyAsyncValidatorFn<V>>, options?: MdyAsyncValidatorOptions): void;
+    setInitialValue(name: string, value: unknown): void;
+    setDisabled(name: string, disabled: Signal<boolean>): void;
+    setReadonly(name: string, readonly: Signal<boolean>): void;
+    get state(): MdyFormState;
+    /**
+     * Reactive flat field paths of the active adapter (empty for a custom
+     * `[adapter]` that does not expose them) — used by the devtools.
+     */
+    get fieldNames(): Signal<readonly string[]>;
+    get value(): Signal<T>;
+    getValue(): T;
+    getField<K extends keyof T>(name: K): MdyFieldRef<T[K]> | null;
+    errorsFor(path: keyof T | string): Signal<ReadonlyArray<MdyFormError>>;
+    submit(action: (value: T) => Promise<MdyFormError[] | void> | MdyFormError[] | void): Promise<void>;
+    markAllTouched(): void;
+    buildSubmitEvent(value: T): MdyFormSubmitEvent<T>;
+    patchValue(partial: Partial<T>): void;
+    setValue(value: T): void;
+    reset(): void;
+    protected handleSubmit(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyFormComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyFormComponent<any>, "mdy-form", never, { "adapter": { "alias": "adapter"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "action": { "alias": "action"; "required": false; "isSignal": true; }; "formValue": { "alias": "formValue"; "required": false; "isSignal": true; }; "submitMode": { "alias": "submitMode"; "required": false; "isSignal": true; }; "formValidators": { "alias": "formValidators"; "required": false; "isSignal": true; }; "draftKey": { "alias": "draftKey"; "required": false; "isSignal": true; }; }, { "submitted": "submitted"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Marks an `<mdy-form>` as inspectable by the devtools overlay:
+ *
+ * ```html
+ * <mdy-form [form]="form" mdyDevtools>…</mdy-form>
+ * ```
+ *
+ * Press the hotkey (default **Ctrl+Shift+D**, see `MDY_DEVTOOLS_HOTKEY`) to
+ * toggle a draggable overlay inspecting the form that currently has focus
+ * (fallback: the last registered form). Close it with ✕ or Escape.
+ */
+declare class MdyDevtoolsDirective {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyDevtoolsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyDevtoolsDirective, "mdy-form[mdyDevtools]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Floating, draggable window around the devtools panel — opened by
+ * {@link MdyFormsDevtoolsService} via a keyboard shortcut. Drag it by the
+ * title bar; the ✕ button (or Escape while it has focus) closes it.
+ */
+declare class MdyFormsDevtoolsOverlayComponent {
+    readonly form: _angular_core.InputSignal<MdyTypedFormLike>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly _offset;
+    protected readonly translate: _angular_core.WritableSignal<string>;
+    private _dragging;
+    private _start;
+    protected onDragStart(event: PointerEvent): void;
+    protected onDragMove(event: PointerEvent): void;
+    protected onDragEnd(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyFormsDevtoolsOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyFormsDevtoolsOverlayComponent, "mdy-forms-devtools-overlay", never, { "form": { "alias": "form"; "required": true; "isSignal": true; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+interface DevtoolsFieldRow {
+    readonly path: string;
+    readonly value: string;
+    readonly valid: boolean;
+    readonly touched: boolean;
+    readonly dirty: boolean;
+    readonly pending: boolean;
+    readonly errors: readonly string[];
+}
+/**
+ * Live inspector for a form model — the universal "why is my form
+ * invalid?" debugging pain, answered in one panel.
+ *
+ * ```html
+ * @if (isDevMode) {
+ *   <mdy-forms-devtools [form]="form" [fields]="[form.f.email, form.f.address.city]" />
+ * }
+ * ```
+ *
+ * Shows the live value (JSON, `File`s serialized), the form state signals
+ * (valid/pending/submitting/submitCount/canSubmit), the last submit errors
+ * and a per-field row (value, valid/touched/dirty/pending, error messages
+ * with their origin) for every handle passed in `[fields]`. Values of
+ * sensitive-looking fields (password, token, card…) are masked; add more
+ * paths via `[maskFields]`. Render it behind `isDevMode()` — it ships no
+ * providers, and it is only bundled when your code imports it (standard
+ * tree shaking: unused imports are dropped by the production build).
+ */
+declare class MdyFormsDevtoolsComponent {
+    /** The form model to inspect (an `mdyForm()` result or any adapter). */
+    readonly form: _angular_core.InputSignal<MdyTypedFormLike>;
+    /**
+     * Typed handles to show as per-field rows (`[form.f.email, …]`).
+     * When omitted, the rows are derived automatically from the form's
+     * registered field names.
+     */
+    readonly fields: _angular_core.InputSignal<readonly MdyFieldHandle<unknown>[]>;
+    /** Start with the body expanded (the overlay opens it this way). */
+    readonly expanded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Extra field paths whose values are masked in the panel, in addition
+     * to the built-in heuristic (paths containing password/token/card/…).
+     */
+    readonly maskFields: _angular_core.InputSignal<readonly string[]>;
+    /**
+     * Field paths hidden from the devtools entirely — no row and no key in
+     * the JSON view (masking shows `•••`; excluding shows nothing).
+     */
+    readonly excludeFields: _angular_core.InputSignal<readonly string[]>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly nameFilter: _angular_core.WritableSignal<string>;
+    protected readonly onlyInvalid: _angular_core.WritableSignal<boolean>;
+    protected readonly onlyTouched: _angular_core.WritableSignal<boolean>;
+    protected readonly onlyDirty: _angular_core.WritableSignal<boolean>;
+    protected readonly onlyPending: _angular_core.WritableSignal<boolean>;
+    protected readonly state: Signal<{
+        valid: boolean;
+        pending: boolean;
+        submitting: boolean;
+        submitCount: number;
+        canSubmit: boolean;
+    }>;
+    protected readonly valueJson: Signal<string>;
+    protected readonly submitErrors: Signal<string[]>;
+    protected readonly rows: Signal<readonly DevtoolsFieldRow[]>;
+    protected readonly filteredRows: Signal<DevtoolsFieldRow[]>;
+    protected copyText(text: string): void;
+    private _isMasked;
+    private _displayValue;
+    /** Masks sensitive-looking keys and drops excluded ones in the JSON view. */
+    private _maskDeep;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyFormsDevtoolsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyFormsDevtoolsComponent, "mdy-forms-devtools", never, { "form": { "alias": "form"; "required": true; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "maskFields": { "alias": "maskFields"; "required": false; "isSignal": true; }; "excludeFields": { "alias": "excludeFields"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Hotkey that toggles the devtools overlay, as `modifier+…+key`
+ * (`ctrl`, `shift`, `alt`, `meta` plus a single key). Default
+ * `ctrl+shift+d` — note this collides with a built-in browser shortcut
+ * in some browsers (e.g. bookmark-all-tabs); override it when that
+ * matters: `{ provide: MDY_DEVTOOLS_HOTKEY, useValue: "ctrl+alt+i" }`.
+ * Provide `null` (or `""`) to disable the hotkey entirely — the overlay
+ * stays reachable via {@link MdyFormsDevtoolsService.toggle}.
+ */
+declare const MDY_DEVTOOLS_HOTKEY: InjectionToken<string | null>;
+/**
+ * Registry + launcher for the devtools overlay. `mdyDevtools` on an
+ * `<mdy-form>` registers the form; the hotkey (default Ctrl+Shift+D)
+ * toggles a draggable overlay inspecting the **selected** form — the
+ * registered form containing the focused element, or the last registered
+ * one as a fallback. Also usable programmatically via {@link toggle}.
+ */
+declare class MdyFormsDevtoolsService {
+    private readonly _appRef;
+    private readonly _injector;
+    private readonly _hotkey;
+    private readonly _registrations;
+    private _overlay;
+    private _listening;
+    private _previousFocus;
+    /** Registers an inspectable form (called by the `mdyDevtools` directive). */
+    register(element: HTMLElement, form: MdyTypedFormLike): void;
+    unregister(element: HTMLElement): void;
+    /** Opens the overlay on the selected (or given) form; closes it if open. */
+    toggle(form?: MdyTypedFormLike): void;
+    open(form: MdyTypedFormLike): void;
+    close(): void;
+    /** The registered form containing the focused element, else the last one. */
+    private _selectForm;
+    private _setupHotkey;
+    private _teardownHotkey;
+    private readonly _onKeydown;
+    private _matchesHotkey;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyFormsDevtoolsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MdyFormsDevtoolsService>;
+}
+
+/**
+ * Runtime form rendering from a serializable config — CMS, form builders,
+ * low-code scenarios. The config is a discriminated union
+ * ({@link MdyDynamicField}), so invalid kind/property combinations do not
+ * compile when the config is authored in TypeScript, and validators are a
+ * JSON-safe subset mapped to the library's pure validator functions.
+ *
+ * ```ts
+ * readonly fields: MdyDynamicField[] = [
+ *   { kind: "text", name: "firstName", label: "First name", validators: { required: true } },
+ *   { kind: "select", name: "country", label: "Country", options: [...] },
+ *   { kind: "slider", name: "budget", label: "Budget", min: 0, max: 100 },
+ * ];
+ * ```
+ * ```html
+ * <mdy-dynamic-form [fields]="fields" (submitted)="save($event)" />
+ * ```
+ */
+declare class MdyDynamicFormComponent {
+    /** Serializable field configs, rendered in order. */
+    readonly fields: _angular_core.InputSignal<readonly MdyDynamicField[]>;
+    /** Re-emitted from the inner `<mdy-form>`. */
+    readonly submitted: _angular_core.OutputEmitterRef<MdyFormSubmitEvent<Record<string, unknown>>>;
+    /** Inner form — exposed so consumers can call getValue()/reset()/submit(). */
+    readonly form: _angular_core.Signal<MdyFormComponent<Record<string, unknown>>>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyDynamicFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyDynamicFormComponent, "mdy-dynamic-form", never, { "fields": { "alias": "fields"; "required": true; "isSignal": true; }; }, { "submitted": "submitted"; }, never, ["*"], true, never>;
+}
+
+/**
+ * One step of an `<mdy-form-wizard>`.
+ *
+ * The step declares which fields it owns via `[fields]` (names or typed
+ * handles): the wizard gates navigation on their validity and marks them
+ * touched when the user tries to advance past an invalid step.
+ *
+ * Inactive steps are hidden, **not destroyed** — their controls stay
+ * registered on the form, so values and validators survive navigation.
+ */
+declare class MdyWizardStepComponent {
+    /** Step title shown in the wizard progress header. */
+    readonly label: _angular_core.InputSignal<string>;
+    /**
+     * Fields owned by this step — names (`"email"`) or typed handles
+     * (`form.f.email`). Used for per-step validation.
+     */
+    readonly fields: _angular_core.InputSignal<readonly (string | MdyFieldHandle<unknown>)[]>;
+    /** Resolved adapter paths of the step's fields. */
+    readonly fieldNames: Signal<readonly string[]>;
+    /** Set by the parent wizard. */
+    readonly isActive: _angular_core.WritableSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyWizardStepComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyWizardStepComponent, "mdy-wizard-step", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Multi-step wizard over a single `<mdy-form>`.
+ *
+ * Place it inside the form and declare the steps as content children; the
+ * wizard shows one step at a time (hidden, not destroyed), gates "Next" on
+ * the validity of the active step's `[fields]`, and renders a progress
+ * header plus navigation buttons.
+ *
+ * ```html
+ * <mdy-form [form]="form" (submitted)="save($event)">
+ *   <mdy-form-wizard (finished)="onFinished()">
+ *     <mdy-wizard-step label="Account" [fields]="[form.f.email, form.f.password]">
+ *       <mdy-control-text [field]="form.f.email" label="Email" />
+ *       …
+ *     </mdy-wizard-step>
+ *     <mdy-wizard-step label="Address" [fields]="[form.f.address.city]">…</mdy-wizard-step>
+ *   </mdy-form-wizard>
+ * </mdy-form>
+ * ```
+ *
+ * `finished` fires on the last step's confirm button — typically you call
+ * `form.submit(...)` or submit the surrounding form there.
+ */
+declare class MdyFormWizardComponent {
+    protected readonly i18n: packages_core_dist.MdyI18nMessages;
+    private readonly adapter;
+    protected readonly steps: Signal<readonly MdyWizardStepComponent[]>;
+    private readonly _activeIndex;
+    /** Index of the currently visible step. */
+    readonly activeIndex: Signal<number>;
+    /** True while the last step is active. */
+    readonly isLast: Signal<boolean>;
+    /** 0..1 progress across the steps (for progress bars). */
+    readonly progress: Signal<number>;
+    /** Validity of the currently active step's declared fields. */
+    readonly activeStepValid: Signal<boolean>;
+    /** Fires after every successful navigation with the new index. */
+    readonly stepChange: _angular_core.OutputEmitterRef<number>;
+    /** Fires when the user confirms the last step. */
+    readonly finished: _angular_core.OutputEmitterRef<void>;
+    constructor();
+    /** Advances (or fires `finished` on the last step) if the step is valid. */
+    next(): void;
+    previous(): void;
+    /** Jumps to a step: backwards freely, forwards only across valid steps. */
+    goTo(index: number): void;
+    /** True when every step before `index` is valid. */
+    protected canJumpTo(index: number): boolean;
+    private _stepValid;
+    private _touchStep;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyFormWizardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyFormWizardComponent, "mdy-form-wizard", never, {}, { "stepChange": "stepChange"; "finished": "finished"; }, ["steps"], ["*"], true, never>;
+}
+
+/**
+ * Chips Directive to enhance select/multiselect options.
+ *
+ * Provides Material 3 styling and behavior for "Input Chips" or "Filter Chips".
+ */
+declare class MdyChipsDirective {
+    /** Whether the chip is currently selected/active. */
+    readonly selected: _angular_core.InputSignal<boolean>;
+    /** Whether the chip shows a removal (X) icon. */
+    readonly removable: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyChipsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyChipsDirective, "[mdyChips]", never, { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that automatically filters options of a host select/multiselect
+ * based on the value of another field in the same form.
+ *
+ * Usage:
+ * ```html
+ * <mdy-select name="country" [options]="countries" />
+ * <mdy-select name="province"
+ *   [mdyDependsOn]="'country'"
+ *   [mdyOptionsMap]="provincesByCountry" />
+ * ```
+ */
+declare class MdyConditionalOptionsDirective<TValue = unknown> {
+    /** Name of the form field that this control depends on. */
+    readonly mdyDependsOn: _angular_core.InputSignal<string>;
+    /**
+     * Map of options keyed by the dependent field's value,
+     * or a function that returns options given the value.
+     */
+    readonly mdyOptionsMap: _angular_core.InputSignal<Record<string | number, readonly MdySelectOption<TValue>[]> | ((val: unknown) => readonly MdySelectOption<TValue>[])>;
+    private readonly adapter;
+    private readonly host;
+    /** Sentinel distinguishing "no previous run" from a legitimate undefined value. */
+    private static readonly UNSET;
+    private previousVal;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyConditionalOptionsDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyConditionalOptionsDirective<any>, "[mdyDependsOn]", never, { "mdyDependsOn": { "alias": "mdyDependsOn"; "required": true; "isSignal": true; }; "mdyOptionsMap": { "alias": "mdyOptionsMap"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Optional wrapper component for form controls.
+ *
+ * Provides a styled container with data-field attribute.
+ * Error display is handled by each renderer component directly.
+ *
+ * Usage:
+ * ```html
+ * <mdy-control name="firstName">
+ *   <mdy-text name="firstName" label="First Name" />
+ * </mdy-control>
+ * ```
+ */
+declare class MdyControlComponent {
+    readonly name: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyControlComponent, "mdy-control", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Marks a template or element as an input prefix (leading content).
+ */
+declare class MdyPrefixDirective {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyPrefixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyPrefixDirective, "[mdyPrefix]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marks a template or element as an input suffix (trailing content).
+ */
+declare class MdySuffixDirective {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdySuffixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdySuffixDirective, "[mdySuffix]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marks a template or element as supporting text (helper text).
+ */
+declare class MdySupportingTextDirective {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdySupportingTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdySupportingTextDirective, "[mdySupportingText]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract base class for all renderer components.
+ *
+ * Injects the nearest MdyFormAdapter (provided by MdyFormComponent)
+ * and resolves the field state by name. Provides convenience computed
+ * signals that concrete renderers bind in their templates.
+ */
+declare abstract class MdyBaseControl<TValue = unknown> implements OnInit {
+    protected readonly hostElement: ElementRef<any>;
+    private readonly _destroyRef;
+    private prefixObserver?;
+    /** Field name currently claimed on the registry (tracks name changes). */
+    private _claimedName;
+    constructor();
+    /**
+     * Field name for declarative (`name`-based) mode.
+     * Optional when a typed `[field]` handle is bound instead.
+     */
+    readonly name: InputSignal<string>;
+    /**
+     * Typed field handle from an `mdyForm()` schema — the type-safe
+     * alternative to the stringly `name` attribute:
+     * `<mdy-control-text [field]="form.f.email" />`.
+     * Accepts the nullable variant too: adapter fields start as `null`
+     * (e.g. Zod-derived handles are `T | null`) and every renderer already
+     * treats `null` as "empty". The control only reads the handle's path.
+     */
+    readonly field: InputSignal<MdyFieldHandle<TValue> | MdyFieldHandle<TValue | null> | undefined>;
+    /** Resolved adapter path: the handle's path or the `name` input. */
+    protected readonly effectiveName: Signal<string>;
+    /** The label text for the form control. */
+    readonly label: InputSignal<string>;
+    /** Opt-in or opt-out of floating labels on a per-control basis, overriding the form-level directive. */
+    readonly floatingLabel: InputSignal<boolean | undefined>;
+    /**
+     * Optional initial value for declarative mode.
+     * Takes precedence over [formValue] set on the parent <mdy-form>.
+     */
+    readonly initialValue: InputSignal<unknown>;
+    private readonly adapter;
+    private readonly _declarativeRegistry;
+    /** True when MdyInlineErrorsDirective is applied to this element. */
+    protected readonly inlineErrors: boolean;
+    private readonly globalFloatingLabels;
+    /** Marks the field as required for assistive technology. */
+    readonly ariaRequired: InputSignal<boolean>;
+    /** Marks the field as disabled for assistive technology (auto-derived from field state). */
+    readonly ariaDisabled: InputSignal<boolean | undefined>;
+    /** Leading content (icon/text) provided via `mdyPrefix` directive. */
+    protected readonly prefix: Signal<MdyPrefixDirective | undefined>;
+    /** Trailing content (icon/text/button) provided via `mdySuffix` directive. */
+    protected readonly suffix: Signal<MdySuffixDirective | undefined>;
+    /** Supporting text (helper text) provided via `mdySupportingText` directive. */
+    protected readonly supportingText: Signal<MdySupportingTextDirective | undefined>;
+    /**
+     * Inert state served while `name`/`[field]` are still unresolved. Input
+     * signals are not set during construction, so any computed chained to
+     * {@link fieldState} (value, errors, …) must stay readable there instead
+     * of throwing; the constructor effect reports controls that are STILL
+     * unresolved after init. Per instance — never shared.
+     */
+    private _detachedState?;
+    private _detached;
+    /** Resolved field state — reactive to name/[field] changes. */
+    protected readonly fieldState: Signal<MdyFieldState<TValue>>;
+    readonly value: Signal<TValue>;
+    protected readonly errors: Signal<ReadonlyArray<MdyFieldError>>;
+    protected readonly touched: Signal<boolean>;
+    protected readonly dirty: Signal<boolean>;
+    protected readonly isDisabled: Signal<boolean>;
+    protected readonly isValid: Signal<boolean>;
+    protected readonly hasErrors: Signal<boolean>;
+    /** Effective aria-disabled: explicit input overrides field state. */
+    protected readonly effectiveAriaDisabled: Signal<boolean>;
+    /** Whether the field is required (deduced from validators). */
+    protected readonly isRequired: Signal<boolean>;
+    /** Error messages joined as a single string for inline display. */
+    protected readonly inlineErrorText: Signal<string>;
+    /** Whether the field should display a floating label. */
+    protected readonly isFloatingLabel: Signal<boolean>;
+    setValue(newValue: TValue): void;
+    protected markAsTouched(): void;
+    protected markAsDirty(): void;
+    /** Generate a unique ID for template label/input association. */
+    protected static nextId(): number;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyBaseControl<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyBaseControl<any>, never, never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "initialValue": { "alias": "initialValue"; "required": false; "isSignal": true; }; "ariaRequired": { "alias": "ariaRequired"; "required": false; "isSignal": true; }; "ariaDisabled": { "alias": "ariaDisabled"; "required": false; "isSignal": true; }; }, {}, ["prefix", "suffix", "supportingText"], never, true, never>;
+}
+
+/**
+ * Block error list displayed below a form control.
+ *
+ * Renders a `<ul>` of validation error messages. Used when
+ * `mdyInlineErrors` is **not** applied to a renderer.
+ *
+ * ```html
+ * <mdy-error-list [fieldId]="fieldId" [errors]="errors()" />
+ * ```
+ */
+declare class MdyErrorListComponent {
+    readonly fieldId: _angular_core.InputSignal<string>;
+    readonly errors: _angular_core.InputSignal<readonly MdyFieldError[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyErrorListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyErrorListComponent, "mdy-error-list", never, { "fieldId": { "alias": "fieldId"; "required": true; "isSignal": true; }; "errors": { "alias": "errors"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Inline error icon with hover/focus tooltip.
+ *
+ * Renders a warning triangle SVG that reveals the error message on
+ * hover or keyboard focus. Used inside labels when `mdyInlineErrors`
+ * is applied to a renderer.
+ *
+ * ```html
+ * <mdy-inline-error-icon [errorText]="inlineErrorText()" />
+ * ```
+ */
+declare class MdyInlineErrorIconComponent {
+    readonly errorText: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyInlineErrorIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyInlineErrorIconComponent, "mdy-inline-error-icon", never, { "errorText": { "alias": "errorText"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Attribute directive that switches a renderer to inline error display.
+ *
+ * When applied to a renderer component, errors are shown in parentheses
+ * next to the label instead of as a block below the input.
+ *
+ * ```html
+ * <mdy-control-text name="email" label="Email" mdyInlineErrors />
+ * ```
+ */
+declare class MdyInlineErrorsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyInlineErrorsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyInlineErrorsDirective, "[mdyInlineErrors]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Shared label + optional inline-error-icon block.
+ *
+ * Eliminates the duplicated `@if (label()) { <label>...</label> }` pattern
+ * that was copy-pasted across every renderer component.
+ *
+ * ```html
+ * <mdy-control-label
+ *   [label]="label()"
+ *   [forId]="fieldId"
+ *   [showInlineError]="inlineErrors && touched() && hasErrors()"
+ *   [errorText]="inlineErrorText()"
+ * />
+ * ```
+ */
+declare class MdyControlLabelComponent {
+    /** The label text. If empty, renders nothing. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** The `id` of the input this label is associated with (maps to `[for]`). */
+    readonly forId: _angular_core.InputSignal<string>;
+    /**
+     * Optional `id` rendered on the `<label>` itself, so group renderers
+     * (radio, segmented) can reference it via `aria-labelledby` (B33).
+     */
+    readonly labelId: _angular_core.InputSignal<string>;
+    /** When `true`, the inline error icon is rendered inside the label. */
+    readonly showInlineError: _angular_core.InputSignal<boolean>;
+    /** Error text passed to the inline error icon tooltip. */
+    readonly errorText: _angular_core.InputSignal<string>;
+    /** Whether to show a required asterisk. */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /** Whether the field is filled (has a value). */
+    readonly filled: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyControlLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyControlLabelComponent, "mdy-control-label", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "forId": { "alias": "forId"; "required": false; "isSignal": true; }; "labelId": { "alias": "labelId"; "required": false; "isSignal": true; }; "showInlineError": { "alias": "showInlineError"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "filled": { "alias": "filled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Structural directive to mark an `<ng-template>` as the custom option
+ * template for `MdySelectComponent`.
+ *
+ * The template receives the option as implicit context.
+ *
+ * ```html
+ * <mdy-control-select name="country" [options]="countries">
+ *   <ng-template mdyOption let-opt>
+ *     {{ opt.value | uppercase }} — {{ opt.label }}
+ *   </ng-template>
+ * </mdy-control-select>
+ * ```
+ */
+declare class MdyOptionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyOptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyOptionDirective, "[mdyOption]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that automatically manages the loading state of an options-based control.
+ * It sets the loading state to true until the options signal emits a non-empty array
+ * for the first time, or until the timeout elapses — a legitimately empty list
+ * must not spin forever (B24).
+ *
+ * Usage:
+ * <mdy-control-select [options]="myOptions()" mdyOptionsAutoLoading />
+ */
+declare class MdyOptionsAutoLoadingDirective {
+    private readonly control;
+    private readonly hasLoaded;
+    private timer;
+    /**
+     * Milliseconds to wait for a non-empty options list before clearing the
+     * loading state anyway (an empty result is a valid outcome). 0 disables
+     * the timeout.
+     */
+    readonly mdyOptionsAutoLoadingTimeout: _angular_core.InputSignalWithTransform<number, unknown>;
+    constructor();
+    private armTimeout;
+    private clearTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyOptionsAutoLoadingDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyOptionsAutoLoadingDirective, "[mdyOptionsAutoLoading]", never, { "mdyOptionsAutoLoadingTimeout": { "alias": "mdyOptionsAutoLoadingTimeout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * MdyGlassDirective
+ *
+ * Applies a "Liquid Glass" effect to the host element using backdrop-filters,
+ * semi-transparent backgrounds, and specular highlights.
+ *
+ * The visual appearance is driven by CSS variables (--mdy-glass-*) which are
+ * defined in the theme layer (e.g., modyra-ios.css).
+ *
+ * Usage:
+ * <div mdyGlass [intensity]="'high'">...</div>
+ */
+declare class MdyGlassDirective {
+    /** Optional override for the blur amount (e.g., '10px' or 'blur(10px)') */
+    readonly blur: _angular_core.InputSignal<string | undefined>;
+    /** Intensity of the glass effect. Themes can use this to adjust blur/opacity. */
+    readonly intensity: _angular_core.InputSignal<"low" | "medium" | "high">;
+    /** Optional background color override to tint the glass. */
+    readonly glassColor: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyGlassDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyGlassDirective, "[mdyGlass]", never, { "blur": { "alias": "blur"; "required": false; "isSignal": true; }; "intensity": { "alias": "intensity"; "required": false; "isSignal": true; }; "glassColor": { "alias": "glassColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Async options loader: receives the current search query. */
+type MdyOptionsLoader<TValue = unknown> = (query: string) => Promise<ReadonlyArray<MdySelectOption<TValue>>>;
+/**
+ * Server-side option loading for select/multiselect.
+ *
+ * Runs the loader on every (debounced) search-query change — including the
+ * initial empty query — with the control's loading state driven for the
+ * whole debounce+fetch window and last-wins semantics on stale responses.
+ *
+ * ```html
+ * <mdy-control-select
+ *   name="city"
+ *   searchable
+ *   [mdyLoadOptions]="searchCities"
+ *   [mdyLoadOptionsDebounce]="300"
+ * />
+ * ```
+ * ```ts
+ * searchCities: MdyOptionsLoader<string> = async (q) =>
+ *   (await api.cities(q)).map(c => ({ value: c.id, label: c.name }));
+ * ```
+ */
+declare class MdyLoadOptionsDirective {
+    private readonly control;
+    readonly mdyLoadOptions: _angular_core.InputSignal<MdyOptionsLoader<unknown>>;
+    /** Milliseconds of typing inactivity before the loader runs. Default 300. */
+    readonly mdyLoadOptionsDebounce: _angular_core.InputSignal<number>;
+    private _runId;
+    private _timer;
+    /**
+     * Reload only when the query changes: an inline-lambda loader gets a new
+     * identity on every change detection and would otherwise refetch in a
+     * loop (R22). A loader identity change alone does not retrigger.
+     */
+    private _lastQuery;
+    constructor();
+    private _schedule;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyLoadOptionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyLoadOptionsDirective, "[mdyLoadOptions]", never, { "mdyLoadOptions": { "alias": "mdyLoadOptions"; "required": true; "isSignal": true; }; "mdyLoadOptionsDebounce": { "alias": "mdyLoadOptionsDebounce"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A simple, zero-dependency live announcer for sending polite
+ * messages to screen readers when UI state changes (e.g. popups open/close).
+ */
+declare class MdyA11yAnnouncer implements OnDestroy {
+    private ariaLiveElement;
+    private pendingTimer;
+    constructor();
+    /**
+     * Announces a message to screen readers.
+     */
+    announce(message: string): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyA11yAnnouncer, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MdyA11yAnnouncer>;
+}
+
+/**
+ * Abstract base class for components that have an overlay popup (select, pickers).
+ *
+ * Handles:
+ * - Open/close state management via `open` signal.
+ * - Dynamic positioning (above/below/overlay) via `computeOverlayPosition`.
+ * - Outside click detection to close the popup.
+ * - `wrapper` viewChild for position calculations.
+ */
+declare abstract class MdyOverlayControl<TValue> extends MdyBaseControl<TValue> {
+    /** Signal tracking if the overlay is currently open. */
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    /** Computed position of the overlay (below, above, or fixed overlay for mobile). */
+    protected readonly position: _angular_core.WritableSignal<OverlayPosition>;
+    /** Computed alignment of the overlay (left, right). */
+    protected readonly alignment: _angular_core.WritableSignal<OverlayAlignment>;
+    /** Whether the overlay should match the anchor width or expand based on content. */
+    readonly widthMode: _angular_core.InputSignal<"match-anchor" | "auto-content">;
+    /** Minimum horizontal space required for the overlay. Default 250px. */
+    readonly minWidth: _angular_core.InputSignal<number>;
+    /** Viewport coordinates for fixed positioning. */
+    protected readonly coords: _angular_core.WritableSignal<{
+        readonly top?: number | undefined;
+        readonly bottom?: number | undefined;
+        readonly left?: number | undefined;
+        readonly right?: number | undefined;
+        readonly width?: number | undefined;
+    }>;
+    /**
+     * Max-height of the overlay panel in px, frozen at open time.
+     * Set once in openOverlay(), never updated during scroll.
+     * Exposed as --mdy-overlay-max-height on the host.
+     */
+    protected readonly maxHeight: _angular_core.WritableSignal<number>;
+    /** The wrapper element used to anchor the overlay and detect outside clicks. */
+    protected readonly wrapperRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    /** Reference to the host element for position calculation. */
+    protected readonly hostRef: ElementRef<any>;
+    protected readonly announcer: MdyA11yAnnouncer;
+    private readonly overlayI18n;
+    constructor();
+    /**
+     * Override to provide a custom anchor for overlay positioning.
+     *
+     * - Return an `HTMLElement` for live rect computation + scroll-aware space.
+     * - Return a `DOMRect` for a virtual/custom anchor area (viewport-only space).
+     * - Return `null` (default) to use the host element.
+     *
+     * @example
+     * // Anchor to a specific inner element instead of the whole host:
+     * protected override overlayAnchor(): OverlayAnchor | null {
+     *   return this.inputRef()?.nativeElement ?? null;
+     * }
+     *
+     * @example
+     * // Anchor to a custom area:
+     * protected override overlayAnchor(): OverlayAnchor | null {
+     *   return new DOMRect(x, y, width, height);
+     * }
+     */
+    protected overlayAnchor(): OverlayAnchor | null;
+    private get anchor();
+    /**
+     * Toggles the overlay state.
+     * Pass the triggering UIEvent (mouse, touch, keyboard) so the popup can
+     * anchor to the correct corner and resolve the scroll ancestor via event.target.
+     */
+    protected toggleOverlay(event?: Event): void;
+    /** Minimum space required below or above to anchor the overlay. Default 128px. */
+    protected readonly minSpace: number;
+    /** Preferred vertical position. Defaults to 'below'. */
+    protected readonly preferredPosition: "above" | "below";
+    protected openOverlay(event?: Event): void;
+    private scrollFrameId;
+    private resizeFrameId;
+    protected readonly handleScroll: () => void;
+    protected readonly handleResize: () => void;
+    /** Computes max-height for the overlay given a resolved position and coords. */
+    private computeMaxHeight;
+    /** Recalculates the position of the currently open overlay. */
+    protected updatePosition(): void;
+    /** Closes the overlay. */
+    protected closeOverlay(): void;
+    /** Removes all document/window listeners registered while open. */
+    private teardownGlobalListeners;
+    /**
+     * Hook called just before the overlay opens.
+     * Useful for syncing draft values or search queries.
+     */
+    protected onBeforeOpen(): void;
+    /** Bound handler registered on document only while the overlay is open (B31). */
+    private readonly handleDocumentClick;
+    /** Escape closes the open overlay regardless of where focus is (R19). */
+    private readonly handleDocumentKeydown;
+    /**
+     * Handler for document clicks while the overlay is open.
+     * Closes the overlay if the click is outside the wrapper element.
+     */
+    protected onDocumentClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyOverlayControl<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyOverlayControl<any>, never, never, { "widthMode": { "alias": "widthMode"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract base class for controls that have both an overlay and a list of options.
+ *
+ * Centralizes:
+ * - `options` input
+ * - `searchable` input
+ * - `overrideOptions` signal (for dynamic/conditional options)
+ * - `searchQuery` signal
+ * - `effectiveOptions` computed (merges input + override)
+ * - `resetSelection` logic
+ */
+declare abstract class MdyOptionsOverlayControl<TValue, TOptionValue = unknown> extends MdyOverlayControl<TValue> implements MdyOptionsControl<TOptionValue> {
+    /** The list of options available for selection. */
+    readonly options: _angular_core.InputSignal<readonly MdySelectOption<TOptionValue>[]>;
+    /** Whether the options are currently being loaded asynchronously. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Customizable loading text. Defaults to i18n messages. */
+    readonly loadingText: _angular_core.InputSignal<string | null>;
+    /** Whether a search input should be displayed in the dropdown/overlay. */
+    readonly searchable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Internal options override (used by conditional/filter directives). */
+    readonly overrideOptions: _angular_core.WritableSignal<readonly MdySelectOption<TOptionValue>[] | null>;
+    /** Internal loading override (used by async directives). */
+    readonly loadingOverride: _angular_core.WritableSignal<boolean | null>;
+    /** Current search query string. */
+    readonly searchQuery: _angular_core.WritableSignal<string>;
+    /** Emits every time the search input changes — consumable by host directives. */
+    readonly searchChanged: _angular_core.OutputEmitterRef<string>;
+    /**
+     * Effective options used for rendering: uses `overrideOptions` if provided,
+     * otherwise falls back to the `options` input.
+     */
+    protected readonly effectiveOptions: _angular_core.Signal<readonly MdySelectOption<TOptionValue>[]>;
+    /**
+     * Effective loading state: uses `loadingOverride` if provided,
+     * otherwise falls back to the `loading` input.
+     */
+    readonly effectiveLoading: _angular_core.Signal<boolean>;
+    /** Reset the control value to its empty state. */
+    abstract resetSelection(): void;
+    closeOverlay(): void;
+    protected onSearchInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyOptionsOverlayControl<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyOptionsOverlayControl<any, any>, never, never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; }, { "searchChanged": "searchChanged"; }, never, never, true, never>;
+}
+
+/**
+ * Opt-in directive to enable Material-style floating labels for all descendant
+ * modyra controls.
+ *
+ * Usage:
+ * ```html
+ * <mdy-form [mdyFloatingLabels]="true" [mdyFloatingLabelsDensity]="-3">
+ *   ...
+ * </mdy-form>
+ * ```
+ */
+declare class MdyFloatingLabelsDirective {
+    /** Enables or disables floating labels for descendants. Defaults to the value of `MDY_FLOATING_LABELS_DEFAULT`. */
+    readonly mdyFloatingLabels: _angular_core.InputSignal<boolean>;
+    /**
+     * Density scaling for the floating labels, replicating M3 density behavior.
+     * 0 is standard M3 (56px), negative values make it more compact.
+     * Defaults to the value of `MDY_FLOATING_LABELS_DENSITY_DEFAULT`.
+     */
+    readonly mdyFloatingLabelsDensity: _angular_core.InputSignal<number>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyFloatingLabelsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyFloatingLabelsDirective, "mdy-form[mdyFloatingLabels], form[mdyFloatingLabels]", never, { "mdyFloatingLabels": { "alias": "mdyFloatingLabels"; "required": false; "isSignal": true; }; "mdyFloatingLabelsDensity": { "alias": "mdyFloatingLabelsDensity"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Checkbox renderer component.
+ *
+ * ```html
+ * <mdy-control-checkbox name="acceptTerms" label="I accept the terms" />
+ * ```
+ */
+declare class MdyCheckboxComponent extends MdyBaseControl<boolean> {
+    protected readonly fieldId: string;
+    protected onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyCheckboxComponent, "mdy-control-checkbox", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Color picker renderer component.
+ *
+ * ```html
+ * <mdy-control-colors name="primaryColor" label="Brand Color" />
+ * ```
+ */
+declare class MdyColorsComponent extends MdyOverlayControl<string> {
+    protected readonly i18n: packages_core_dist.MdyI18nMessages;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly presets: _angular_core.InputSignal<readonly string[]>;
+    protected readonly fieldId: string;
+    /** Separate id for the HEX text input — the accessible label target. */
+    protected readonly hexInputId: string;
+    protected onBeforeOpen(): void;
+    protected onBlur(event: FocusEvent): void;
+    protected onInput(event: Event): void;
+    protected onHexBlur(event: FocusEvent): void;
+    protected onTextInput(event: Event): void;
+    protected selectColor(color: string): void;
+    /** Case-insensitive hex comparison: #FFF and #fff are the same color (B26). */
+    protected isActiveColor(color: string): boolean;
+    private updateValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyColorsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyColorsComponent, "mdy-control-colors", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A single day cell in the calendar grid.
+ *
+ * Handles rendering, selection highlight, today indicator,
+ * disabled state, and click/keyboard interaction.
+ *
+ * ```html
+ * <mdy-calendar-cell
+ *   [cell]="cell"
+ *   [isSelected]="true"
+ *   [isToday]="false"
+ *   [isFocused]="false"
+ *   [isDisabled]="false"
+ *   (picked)="onPick($event)"
+ * />
+ * ```
+ */
+declare class MdyCalendarCellComponent {
+    readonly cell: _angular_core.InputSignal<CalendarCell>;
+    readonly isSelected: _angular_core.InputSignal<boolean>;
+    readonly isToday: _angular_core.InputSignal<boolean>;
+    readonly isFocused: _angular_core.InputSignal<boolean>;
+    readonly isDisabled: _angular_core.InputSignal<boolean>;
+    /** Emits the picked date when the cell is activated. */
+    readonly picked: _angular_core.OutputEmitterRef<CalendarDate>;
+    private readonly elementRef;
+    /** Focuses the host element of this cell. */
+    focus(): void;
+    protected onSelect(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyCalendarCellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyCalendarCellComponent, "mdy-calendar-cell", never, { "cell": { "alias": "cell"; "required": true; "isSignal": true; }; "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "isToday": { "alias": "isToday"; "required": false; "isSignal": true; }; "isFocused": { "alias": "isFocused"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; }, { "picked": "picked"; }, never, never, true, never>;
+}
+
+/**
+ * Month grid component — renders the 7-column × 6-row calendar body.
+ *
+ * Receives the currently displayed year/month, selected date, focused date,
+ * and min/max bounds. Emits when a date is picked or focus changes via
+ * keyboard navigation.
+ *
+ * ```html
+ * <mdy-calendar-grid
+ *   [year]="2026"
+ *   [month]="3"
+ *   [selectedDate]="selected"
+ *   [focusedDate]="focused"
+ *   [minDate]="min"
+ *   [maxDate]="max"
+ *   (datePicked)="onPick($event)"
+ * />
+ * ```
+ */
+declare class MdyCalendarGridComponent {
+    readonly year: _angular_core.InputSignal<number>;
+    readonly month: _angular_core.InputSignal<number>;
+    readonly selectedDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly focusedDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly minDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly maxDate: _angular_core.InputSignal<CalendarDate | null>;
+    /** Emits the date the user picked (clicked or pressed Enter/Space). */
+    readonly datePicked: _angular_core.OutputEmitterRef<CalendarDate>;
+    private readonly cellsRef;
+    /** Focuses the cell corresponding to the given date. */
+    focusDate(date: CalendarDate): void;
+    private readonly locale;
+    private readonly todayDate;
+    /** 42 cells for the month grid. */
+    private readonly cells;
+    /** Cells split into 6 rows of 7. */
+    protected readonly rows: _angular_core.Signal<readonly (readonly CalendarCell[])[]>;
+    /** Day-of-week header names ordered by firstDayOfWeek. */
+    protected readonly orderedDayNames: _angular_core.Signal<readonly string[]>;
+    /** Short day names for aria-label on weekday headers. */
+    protected readonly orderedDayNamesShort: _angular_core.Signal<readonly string[]>;
+    protected isCellSelected(cell: CalendarCell): boolean;
+    protected isCellToday(cell: CalendarCell): boolean;
+    protected isCellFocused(cell: CalendarCell): boolean;
+    protected isCellDisabled(cell: CalendarCell): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyCalendarGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyCalendarGridComponent, "mdy-calendar-grid", never, { "year": { "alias": "year"; "required": true; "isSignal": true; }; "month": { "alias": "month"; "required": true; "isSignal": true; }; "selectedDate": { "alias": "selectedDate"; "required": false; "isSignal": true; }; "focusedDate": { "alias": "focusedDate"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; }, { "datePicked": "datePicked"; }, never, never, true, never>;
+}
+
+/**
+ * Calendar header — displays the current month/year label and
+ * navigation arrows (prev/next month).
+ *
+ * ```html
+ * <mdy-calendar-header
+ *   [year]="2026"
+ *   [month]="3"
+ *   (previousMonth)="goPrev()"
+ *   (nextMonth)="goNext()"
+ * />
+ * ```
+ */
+declare class MdyCalendarHeaderComponent {
+    readonly year: _angular_core.InputSignal<number>;
+    /** 1-based month (1 = January). */
+    readonly month: _angular_core.InputSignal<number>;
+    readonly previousMonth: _angular_core.OutputEmitterRef<void>;
+    readonly nextMonth: _angular_core.OutputEmitterRef<void>;
+    readonly toggleView: _angular_core.OutputEmitterRef<void>;
+    private readonly locale;
+    protected readonly i18n: packages_core_dist.MdyI18nMessages;
+    /** Localized month name (e.g. "March", "Marzo"). */
+    protected readonly monthLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyCalendarHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyCalendarHeaderComponent, "mdy-calendar-header", never, { "year": { "alias": "year"; "required": true; "isSignal": true; }; "month": { "alias": "month"; "required": true; "isSignal": true; }; }, { "previousMonth": "previousMonth"; "nextMonth": "nextMonth"; "toggleView": "toggleView"; }, never, never, true, never>;
+}
+
+type CalendarView$1 = "calendar" | "month" | "year";
+/**
+ * Calendar container — orchestrates header navigation, grid rendering,
+ * keyboard navigation, and date selection.
+ *
+ * This component owns the "current view" state (year/month) and the
+ * focused-date for roving keyboard navigation. It does **not** manage
+ * the form field value — that responsibility stays in the renderer.
+ *
+ * ```html
+ * <mdy-calendar
+ *   [selectedDate]="selected"
+ *   [minDate]="min"
+ *   [maxDate]="max"
+ *   (datePicked)="onPick($event)"
+ * />
+ * ```
+ */
+declare class MdyCalendarComponent {
+    readonly selectedDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly minDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly maxDate: _angular_core.InputSignal<CalendarDate | null>;
+    protected readonly view: _angular_core.WritableSignal<CalendarView$1>;
+    private readonly grid;
+    private readonly injector;
+    constructor();
+    /** Manually focuses the currently focused date cell. */
+    focusFocusedDate(): void;
+    /** Accessible label for the dialog. Falls back to the i18n default. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    private readonly i18n;
+    protected readonly effectiveAriaLabel: _angular_core.Signal<string>;
+    /** Emits when the user confirms a date. */
+    readonly datePicked: _angular_core.OutputEmitterRef<CalendarDate>;
+    /** Emits on Escape — parent must close the popup. */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /** Year currently displayed. */
+    protected readonly viewYear: _angular_core.WritableSignal<number>;
+    /** Month (1-based) currently displayed. */
+    protected readonly viewMonth: _angular_core.WritableSignal<number>;
+    /** Date that has keyboard focus (roving tabindex). */
+    protected readonly focusedDate: _angular_core.WritableSignal<CalendarDate>;
+    /**
+     * Sync the view to the selected date when the popup opens.
+     * Called by the parent renderer after opening.
+     * Resets view to 'calendar'.
+     */
+    syncView(date: CalendarDate | null): void;
+    protected onToggleView(): void;
+    protected onMonthSelected(month: number): void;
+    protected onYearSelected(year: number): void;
+    protected goToPreviousMonth(): void;
+    protected goToNextMonth(): void;
+    private navigateMonth;
+    protected onDatePicked(date: CalendarDate): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyCalendarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyCalendarComponent, "mdy-calendar", never, { "selectedDate": { "alias": "selectedDate"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "datePicked": "datePicked"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Date picker renderer — M3-style docked calendar picker.
+ * Integrated with MdyControlLabelComponent.
+ */
+declare class MdyDatePickerComponent extends MdyOverlayControl<string | null> {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly minDate: _angular_core.InputSignal<string | null>;
+    readonly maxDate: _angular_core.InputSignal<string | null>;
+    readonly variant: _angular_core.InputSignal<"docked" | "modal">;
+    /**
+     * How the selected date is rendered in the input:
+     * `"localized"` uses `Intl` with the active MDY_DATE_LOCALE,
+     * `"iso"` shows the raw `YYYY-MM-DD` value. Typing accepts ISO in both modes.
+     */
+    readonly displayFormat: _angular_core.InputSignal<"iso" | "localized">;
+    protected readonly minSpace = 450;
+    protected readonly fieldId: string;
+    protected readonly i18n: packages_core_dist.MdyI18nMessages;
+    private readonly calendarRef;
+    private readonly locale;
+    private readonly injector;
+    protected readonly tempSelectedDate: _angular_core.WritableSignal<CalendarDate | null>;
+    protected readonly displayValue: _angular_core.Signal<string>;
+    protected readonly modalDisplayValue: _angular_core.Signal<string>;
+    protected readonly parsedSelectedDate: _angular_core.Signal<CalendarDate | null>;
+    protected readonly parsedMinDate: _angular_core.Signal<CalendarDate | null>;
+    protected readonly parsedMaxDate: _angular_core.Signal<CalendarDate | null>;
+    protected onBeforeOpen(): void;
+    protected applySelection(): void;
+    protected onDatePicked(date: CalendarDate, forceApply?: boolean): void;
+    protected onInputChange(event: Event): void;
+    protected onInputBlur(event: FocusEvent): void;
+    /** Manual input honours [minDate]/[maxDate] like the calendar does. */
+    private isWithinRange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyDatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyDatePickerComponent, "mdy-control-datepicker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Date range picker renderer — compact two-input calendar picker
+ * for selecting a start and end date. Integrated with MdyControlLabelComponent.
+ */
+declare class MdyDateRangePickerComponent extends MdyOverlayControl<MdyDateRange | null> {
+    readonly startPlaceholder: _angular_core.InputSignal<string>;
+    readonly endPlaceholder: _angular_core.InputSignal<string>;
+    readonly minDate: _angular_core.InputSignal<string | null>;
+    readonly maxDate: _angular_core.InputSignal<string | null>;
+    readonly variant: _angular_core.InputSignal<"docked" | "modal">;
+    readonly dateFilter: _angular_core.InputSignal<((date: string) => boolean) | null>;
+    protected readonly minSpace = 450;
+    protected readonly fieldId: string;
+    /** Which input was last focused — drives calendar sync. */
+    protected readonly lastFocused: _angular_core.WritableSignal<"end" | "start">;
+    private readonly calendarRef;
+    private readonly locale;
+    private readonly injector;
+    protected readonly i18n: packages_core_dist.MdyI18nMessages;
+    protected readonly tempStart: _angular_core.WritableSignal<CalendarDate | null>;
+    protected readonly tempEnd: _angular_core.WritableSignal<CalendarDate | null>;
+    protected readonly displayStart: _angular_core.Signal<string>;
+    protected readonly displayEnd: _angular_core.Signal<string>;
+    protected readonly modalDisplayValue: _angular_core.Signal<string>;
+    protected readonly parsedStart: _angular_core.Signal<CalendarDate | null>;
+    protected readonly parsedEnd: _angular_core.Signal<CalendarDate | null>;
+    protected readonly parsedMinDate: _angular_core.Signal<CalendarDate | null>;
+    protected readonly parsedMaxDate: _angular_core.Signal<CalendarDate | null>;
+    /** Sync calendar view to current value after DOM renders. */
+    protected onBeforeOpen(): void;
+    protected applySelection(): void;
+    protected onRangePicked(range: {
+        readonly start: CalendarDate;
+        readonly end: CalendarDate;
+    }, forceApply?: boolean): void;
+    protected onStartInput(event: Event): void;
+    protected onStartBlur(event: FocusEvent): void;
+    protected onEndInput(event: Event): void;
+    protected onEndBlur(event: FocusEvent): void;
+    /**
+     * Commit the range, enforcing end >= start, the optional [dateFilter],
+     * and the [minDate]/[maxDate] bounds — manual typing must not accept a
+     * date the calendar would forbid (B17).
+     */
+    private commitRange;
+    /** True when the ISO date lies inside [minDate, maxDate]. */
+    private isWithinBounds;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyDateRangePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyDateRangePickerComponent, "mdy-control-daterange", never, { "startPlaceholder": { "alias": "startPlaceholder"; "required": false; "isSignal": true; }; "endPlaceholder": { "alias": "endPlaceholder"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Range-aware month grid — renders a 7-column × 6-row calendar body
+ * with visual highlighting for the selected date range.
+ *
+ * Each cell can be: range-start, range-end, in-range, or none.
+ * A hover date is used to show a preview range while the user
+ * picks the second endpoint.
+ *
+ * ```html
+ * <mdy-range-calendar-grid
+ *   [year]="2026"
+ *   [month]="3"
+ *   [rangeStart]="start"
+ *   [rangeEnd]="end"
+ *   [hoverDate]="hover"
+ *   [focusedDate]="focused"
+ *   [minDate]="min"
+ *   [maxDate]="max"
+ *   (datePicked)="onPick($event)"
+ *   (dateHovered)="onHover($event)"
+ * />
+ * ```
+ */
+declare class MdyRangeCalendarGridComponent {
+    readonly year: _angular_core.InputSignal<number>;
+    readonly month: _angular_core.InputSignal<number>;
+    readonly rangeStart: _angular_core.InputSignal<CalendarDate | null>;
+    readonly rangeEnd: _angular_core.InputSignal<CalendarDate | null>;
+    /** Hover date used to preview the range before second click. */
+    readonly hoverDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly focusedDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly minDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly maxDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly dateFilter: _angular_core.InputSignal<((date: string) => boolean) | null>;
+    /** Emits the date the user picked (clicked or pressed Enter/Space). */
+    readonly datePicked: _angular_core.OutputEmitterRef<CalendarDate>;
+    /** Emits when the user hovers over a cell. */
+    readonly dateHovered: _angular_core.OutputEmitterRef<CalendarDate>;
+    private readonly cellBtns;
+    /** Focuses the grid cell corresponding to the given date. */
+    focusDate(date: CalendarDate): void;
+    private readonly locale;
+    private readonly todayDate;
+    /** 42 cells for the month grid. */
+    private readonly cells;
+    /** Cells split into 6 rows of 7. */
+    protected readonly rows: _angular_core.Signal<readonly (readonly CalendarCell[])[]>;
+    /** Day-of-week header names ordered by firstDayOfWeek. */
+    protected readonly orderedDayNames: _angular_core.Signal<readonly string[]>;
+    /** Short day names for aria-label on weekday headers. */
+    protected readonly orderedDayNamesShort: _angular_core.Signal<readonly string[]>;
+    /**
+     * Effective range, computed from rangeStart + (rangeEnd or hoverDate).
+     * Always normalised so `[0] <= [1]`.
+     */
+    private readonly effectiveRange;
+    protected isCellToday(cell: CalendarCell): boolean;
+    protected isCellFocused(cell: CalendarCell): boolean;
+    protected isCellDisabled(cell: CalendarCell): boolean;
+    /** True for either range endpoint. */
+    protected isCellRangeEndpoint(cell: CalendarCell): boolean;
+    /** True for the range start date specifically. */
+    protected isCellRangeStart(cell: CalendarCell): boolean;
+    /** True for the range end date specifically. */
+    protected isCellRangeEnd(cell: CalendarCell): boolean;
+    /** True for dates strictly between start and end. */
+    protected isCellInRange(cell: CalendarCell): boolean;
+    protected onCellClick(cell: CalendarCell): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyRangeCalendarGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyRangeCalendarGridComponent, "mdy-range-calendar-grid", never, { "year": { "alias": "year"; "required": true; "isSignal": true; }; "month": { "alias": "month"; "required": true; "isSignal": true; }; "rangeStart": { "alias": "rangeStart"; "required": false; "isSignal": true; }; "rangeEnd": { "alias": "rangeEnd"; "required": false; "isSignal": true; }; "hoverDate": { "alias": "hoverDate"; "required": false; "isSignal": true; }; "focusedDate": { "alias": "focusedDate"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; }, { "datePicked": "datePicked"; "dateHovered": "dateHovered"; }, never, never, true, never>;
+}
+
+type CalendarView = "calendar" | "month" | "year";
+/**
+ * Range calendar container — orchestrates header navigation, grid rendering,
+ * keyboard navigation, and two-step date range selection.
+ */
+declare class MdyRangeCalendarComponent {
+    readonly rangeStart: _angular_core.InputSignal<CalendarDate | null>;
+    readonly rangeEnd: _angular_core.InputSignal<CalendarDate | null>;
+    readonly minDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly maxDate: _angular_core.InputSignal<CalendarDate | null>;
+    readonly dateFilter: _angular_core.InputSignal<((date: string) => boolean) | null>;
+    /** Accessible label for the dialog. Falls back to the i18n default. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    private readonly i18n;
+    protected readonly effectiveAriaLabel: _angular_core.Signal<string>;
+    readonly rangePicked: _angular_core.OutputEmitterRef<{
+        readonly start: CalendarDate;
+        readonly end: CalendarDate;
+    }>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly grid;
+    private readonly injector;
+    constructor();
+    focusFocusedDate(): void;
+    protected readonly view: _angular_core.WritableSignal<CalendarView>;
+    protected readonly viewYear: _angular_core.WritableSignal<number>;
+    protected readonly viewMonth: _angular_core.WritableSignal<number>;
+    protected readonly focusedDate: _angular_core.WritableSignal<CalendarDate>;
+    protected readonly hoverDate: _angular_core.WritableSignal<CalendarDate | null>;
+    private readonly phase;
+    protected readonly pendingStart: _angular_core.WritableSignal<CalendarDate | null>;
+    protected readonly pendingEnd: _angular_core.WritableSignal<CalendarDate | null>;
+    protected readonly phaseHint: _angular_core.Signal<string>;
+    syncView(start: CalendarDate | null, end: CalendarDate | null): void;
+    protected onToggleView(): void;
+    protected onMonthSelected(month: number): void;
+    protected onYearSelected(year: number): void;
+    protected goToPreviousMonth(): void;
+    protected goToNextMonth(): void;
+    private navigateMonth;
+    protected onDatePicked(date: CalendarDate): void;
+    protected onDateHovered(date: CalendarDate): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyRangeCalendarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyRangeCalendarComponent, "mdy-range-calendar", never, { "rangeStart": { "alias": "rangeStart"; "required": false; "isSignal": true; }; "rangeEnd": { "alias": "rangeEnd"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "rangePicked": "rangePicked"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * File Upload renderer component.
+ */
+declare class MdyFileComponent extends MdyBaseControl<File | File[] | null> {
+    readonly accept: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    /** Maximum size per file in bytes (0 = no limit). Applies to picker and drop. */
+    readonly maxFileSize: _angular_core.InputSignal<number>;
+    /** Maximum number of files when [multiple] (0 = no limit). */
+    readonly maxFiles: _angular_core.InputSignal<number>;
+    readonly fileSelected: _angular_core.OutputEmitterRef<File | File[] | null>;
+    /** Emits the files rejected by accept/maxFileSize/maxFiles filtering. */
+    readonly filesRejected: _angular_core.OutputEmitterRef<readonly File[]>;
+    protected readonly i18n: packages_core_dist.MdyI18nMessages;
+    protected readonly fieldId: string;
+    protected readonly dragOver: _angular_core.WritableSignal<boolean>;
+    private readonly fileInput;
+    protected readonly fileNames: _angular_core.Signal<string[]>;
+    protected onFileChange(event: Event): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    protected clear(): void;
+    private processFiles;
+    /** Mirrors the native input's accept matching: .ext, type/*, exact MIME. */
+    private matchesAccept;
+    private withinSizeLimit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyFileComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyFileComponent, "mdy-control-file", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "maxFiles": { "alias": "maxFiles"; "required": false; "isSignal": true; }; }, { "fileSelected": "fileSelected"; "filesRejected": "filesRejected"; }, never, never, true, never>;
+}
+
+/**
+ * Shared base for dropdown renderers (select, multiselect).
+ *
+ * Owns the non-UI-specific concerns that the two renderers share:
+ * i18n, injector, overlay min-space, option template query, selection
+ * output, search-query lifecycle, and the reset contract. Subclasses
+ * remain responsible for their specific value model, keyboard handling,
+ * filtering and templates.
+ */
+declare abstract class MdyDropdownBase<TValue, TOptionValue = unknown> extends MdyOptionsOverlayControl<TValue, TOptionValue> implements MdyOptionsControl<TOptionValue> {
+    /** Internationalized strings used by dropdown UI. */
+    protected readonly i18n: packages_core_dist.MdyI18nMessages;
+    /** Injector for Angular effects and `afterNextRender` calls. */
+    protected readonly injector: Injector;
+    /** Minimum viewport space required to anchor the dropdown. */
+    protected readonly minSpace = 250;
+    /** Emitted when the user selects or toggles an option. */
+    readonly selectionChange: _angular_core.OutputEmitterRef<MdySelectOption<TOptionValue>>;
+    /** Custom option template provided via `<ng-template mdyOption>`. */
+    protected readonly optionTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    /** Stable field id used for labels, ARIA and option ids. */
+    protected abstract readonly fieldId: string;
+    /** Resets the control value to its empty state. */
+    abstract resetSelection(): void;
+    /** Reset the search query every time the overlay opens. */
+    protected onBeforeOpen(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyDropdownBase<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyDropdownBase<any, any>, never, never, {}, { "selectionChange": "selectionChange"; }, ["optionTpl"], never, true, never>;
+}
+
+/**
+ * Multiselect renderer component.
+ * Renders selectable filter chips and delivers ReadonlyArray<TValue>.
+ */
+declare class MdyMultiselectComponent<TValue = string> extends MdyDropdownBase<ReadonlyArray<TValue>, TValue> implements MdyOptionsControl<TValue> {
+    readonly mode: _angular_core.InputSignal<"single" | "multi">;
+    /**
+     * Optional filter predicate applied to options before display.
+     * Receives the option *value* and returns `true` to show the option.
+     * When absent, all options are shown.
+     */
+    readonly filterFn: _angular_core.InputSignal<((value: TValue) => boolean) | undefined>;
+    protected readonly fieldId: string;
+    /** Options after applying the optional `filterFn` predicate. */
+    protected readonly filteredOptions: _angular_core.Signal<readonly _modyra_angular.MdySelectOption<TValue>[]>;
+    /** Options available in the search overlay (filtered by predicate + query + mode). */
+    protected readonly searchResults: _angular_core.Signal<readonly _modyra_angular.MdySelectOption<TValue>[]>;
+    private readonly overlayInputRef;
+    /**
+     * Pre-computed count map for multi-mode.
+     * Keyed by String(value): matching is loose, consistent with the select
+     * renderer (B20), so numeric values survive string round-trips.
+     */
+    protected readonly counts: _angular_core.Signal<Map<string, number>>;
+    /** Pre-computed selection set for single-mode (loose String matching, B20). */
+    protected readonly selectedSet: _angular_core.Signal<Set<string>>;
+    protected onBeforeOpen(): void;
+    /**
+     * Override to check against the full host element rather than the narrow
+     * #wrapper (header div). The overlay panel is a DOM child of the host even
+     * when position:fixed, so host.contains() correctly excludes panel clicks.
+     */
+    protected onDocumentClick(event: Event): void;
+    protected isSelected(optValue: TValue): boolean;
+    protected onToggle(optValue: TValue): void;
+    protected countOf(optValue: TValue): number;
+    protected increment(optValue: TValue): void;
+    protected decrement(optValue: TValue): void;
+    resetSelection(): void;
+    protected onOverlaySelect(optValue: TValue): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyMultiselectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyMultiselectComponent<any>, "mdy-control-multiselect", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Number input renderer component.
+ */
+declare class MdyNumberComponent extends MdyBaseControl<number | null> {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly minValue: _angular_core.InputSignal<number | null>;
+    readonly maxValue: _angular_core.InputSignal<number | null>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly showSpinButtons: _angular_core.InputSignal<boolean>;
+    protected readonly fieldId: string;
+    protected onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyNumberComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyNumberComponent, "mdy-control-number", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "showSpinButtons": { "alias": "showSpinButtons"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Radio Group renderer component.
+ */
+declare class MdyRadioGroupComponent<TValue = unknown> extends MdyBaseControl<TValue | null> {
+    readonly options: _angular_core.InputSignal<readonly MdySelectOption<TValue>[]>;
+    readonly layout: _angular_core.InputSignal<"vertical" | "horizontal">;
+    protected readonly fieldId: string;
+    protected onSelectionChange(value: TValue): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyRadioGroupComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyRadioGroupComponent<any>, "mdy-control-radio", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Segmented Button renderer component.
+ */
+declare class MdySegmentedButtonComponent<TValue = unknown> extends MdyBaseControl<TValue | null> {
+    readonly options: _angular_core.InputSignal<readonly MdySelectOption<TValue>[]>;
+    readonly fullWidth: InputSignalWithTransform<boolean, unknown>;
+    protected readonly fieldId: string;
+    protected readonly segmentsCount: _angular_core.Signal<number>;
+    private readonly track;
+    private isDragging;
+    protected onTrackPointerDown(event: PointerEvent): void;
+    protected onTrackPointerMove(event: PointerEvent): void;
+    protected onTrackPointerUp(): void;
+    private updateSelectionFromPointer;
+    protected onSelect(value: TValue): void;
+    /** Roving tabindex: only the selected (or first) segment is tabbable. */
+    protected tabIndexFor(index: number): number;
+    private selectedIndex;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdySegmentedButtonComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdySegmentedButtonComponent<any>, "mdy-control-segmented", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Select renderer component.
+ *
+ * When a custom `<ng-template mdyOption>` is provided, renders a fully custom
+ * dropdown with HTML content in options. Otherwise falls back to a native
+ * `<select>` element.
+ */
+declare class MdySelectComponent<TValue = string> extends MdyDropdownBase<TValue | null, TValue> implements MdyOptionsControl<TValue> {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Tagging: in a searchable select, shows a "Create «query»" row when the
+     * query matches no option label. Selecting it emits `optionCreated` —
+     * the consumer adds the option to its list and sets the value.
+     */
+    readonly allowCreate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Fires with the trimmed query when the user picks the create row. */
+    readonly optionCreated: _angular_core.OutputEmitterRef<string>;
+    readonly isDisabled: Signal<boolean>;
+    private readonly runtime;
+    private selectAdapter;
+    private readonly _parkedValue;
+    readonly parkedValue: Signal<TValue | null>;
+    constructor();
+    protected readonly fieldId: string;
+    /** Whether the dropdown opens above the trigger. */
+    protected readonly dropUp: Signal<boolean>;
+    /** Whether the dropdown renders as a centered overlay (no space above or below). */
+    protected readonly overlayMode: Signal<boolean>;
+    /** Index of the keyboard-active option (for arrow navigation). */
+    protected readonly activeIndex: Signal<number>;
+    private optionKey;
+    /** The currently selected option object (for rendering in trigger). */
+    protected readonly selectedOption: Signal<MdySelectOption<TValue> | null>;
+    /** Options filtered by the current search query. */
+    protected readonly filteredOptions: Signal<readonly MdySelectOption<TValue>[]>;
+    /** Show the "create" row: tagging enabled, query set, no exact label match. */
+    protected readonly showCreateOption: Signal<boolean>;
+    protected onCreateOption(): void;
+    private readonly searchInputRef;
+    protected openOverlay(event?: Event): void;
+    closeOverlay(): void;
+    protected onBeforeOpen(): void;
+    protected selectOption(opt: MdySelectOption<TValue>): void;
+    protected onBlur(event: FocusEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onSearchInput(event: Event): void;
+    resetSelection(): void;
+    protected onNativeChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdySelectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdySelectComponent<any>, "mdy-control-select", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "allowCreate": { "alias": "allowCreate"; "required": false; "isSignal": true; }; }, { "optionCreated": "optionCreated"; }, never, never, true, never>;
+}
+
+/**
+ * Slider renderer component.
+ */
+declare class MdySliderComponent extends MdyBaseControl<number> {
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly showValue: _angular_core.InputSignal<boolean>;
+    private readonly rangeInput;
+    protected readonly fieldId: string;
+    constructor();
+    protected onInput(event: Event): void;
+    protected onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdySliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdySliderComponent, "mdy-control-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Text input renderer component.
+ *
+ * ```html
+ * <mdy-control-text name="firstName" label="First Name" placeholder="Enter name" />
+ * ```
+ */
+declare class MdyTextComponent extends MdyBaseControl<string> implements OnInit {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly type: _angular_core.InputSignal<string>;
+    readonly autocomplete: _angular_core.InputSignal<string | null>;
+    protected readonly fieldId: string;
+    private fieldController?;
+    private readonly destroyRef;
+    protected readonly fieldView: _angular_core.Signal<_modyra_widgets.MdyWidgetViewContract | undefined>;
+    protected readonly inputAriaInvalid: _angular_core.Signal<string | number | boolean>;
+    protected readonly inputAriaRequired: _angular_core.Signal<string | number | boolean>;
+    protected readonly inputAriaDescribedby: _angular_core.Signal<string | number | true | null>;
+    ngOnInit(): void;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyTextComponent, "mdy-control-text", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Textarea renderer component.
+ */
+declare class MdyTextareaComponent extends MdyBaseControl<string | null> {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly rows: _angular_core.InputSignal<number>;
+    protected readonly fieldId: string;
+    protected onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyTextareaComponent, "mdy-control-textarea", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Toggle (switch) renderer component.
+ */
+declare class MdyToggleComponent extends MdyBaseControl<boolean> {
+    protected readonly fieldId: string;
+    protected onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyToggleComponent, "mdy-control-toggle", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Timepicker renderer — M3-style input with clock overlay.
+ */
+declare class MdyTimepickerComponent extends MdyOverlayControl<string | null> {
+    protected readonly i18n: packages_core_dist.MdyI18nMessages;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /**
+     * Value and display format: `"12h"` uses `"hh:mm AM/PM"` strings,
+     * `"24h"` uses `"HH:mm"` (00-23). The clock overlay adapts (no AM/PM
+     * toggle, 0-23 hour input) — the field value follows this format.
+     */
+    readonly format: _angular_core.InputSignal<MdyTimeFormat>;
+    protected readonly minSpace = 450;
+    protected readonly effectivePlaceholder: _angular_core.Signal<string>;
+    protected readonly fieldId: string;
+    protected readonly draftValue: _angular_core.WritableSignal<string | null>;
+    private readonly injector;
+    protected onBeforeOpen(): void;
+    protected onTimePicked(time: string): void;
+    protected confirmPicker(): void;
+    /**
+     * Commit-style parsing on `change` (blur/Enter), not on every keystroke:
+     * updating the value mid-typing made the `[value]` binding rewrite the
+     * input and wipe the user's text (R4). Unparsable text leaves the value
+     * untouched — the blur handler reverts the display.
+     */
+    protected onInputChange(event: Event): void;
+    protected onInputFocus(event: FocusEvent): void;
+    protected onInputBlur(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyTimepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyTimepickerComponent, "mdy-control-timepicker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Lightweight component to render SVGs from the shared icon library.
+ */
+declare class MdyIconComponent {
+    private readonly sanitizer;
+    /** Name of the icon to render from the MDY_ICONS registry. */
+    readonly name: _angular_core.InputSignal<"SEARCH" | "CHECKMARK" | "CHEVRON_DOWN" | "CHEVRON_LEFT" | "CHEVRON_RIGHT" | "CLOSE" | "PLUS" | "MINUS" | "CALENDAR" | "CLOCK" | "SPIN_UP" | "SPIN_DOWN" | "ERROR" | "LOADER">;
+    readonly strokeWidth: _angular_core.InputSignal<number>;
+    protected readonly iconData: _angular_core.Signal<{
+        readonly viewBox: "0 0 20 20";
+        readonly content: "<circle cx=\"8.5\" cy=\"8.5\" r=\"5.5\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.5\"/><line x1=\"12.5\" y1=\"12.5\" x2=\"17\" y2=\"17\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 24 24";
+        readonly content: "<polyline points=\"6 12 10 16 18 8\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 24 24";
+        readonly content: "<path d=\"M7 10l5 5 5-5\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 24 24";
+        readonly content: "<path d=\"M15 18l-6-6 6-6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 24 24";
+        readonly content: "<path d=\"M9 18l6-6-6-6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 12 12";
+        readonly content: "<line x1=\"3\" y1=\"3\" x2=\"9\" y2=\"9\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\"/><line x1=\"9\" y1=\"3\" x2=\"3\" y2=\"9\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 12 12";
+        readonly content: "<line x1=\"3\" y1=\"6\" x2=\"9\" y2=\"6\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\"/><line x1=\"6\" y1=\"3\" x2=\"6\" y2=\"9\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 12 12";
+        readonly content: "<line x1=\"3\" y1=\"6\" x2=\"9\" y2=\"6\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 24 24";
+        readonly content: "<rect x=\"2\" y=\"4\" width=\"20\" height=\"18\" rx=\"2\" ry=\"2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><line x1=\"16\" y1=\"2\" x2=\"16\" y2=\"6\" stroke=\"currentColor\" stroke-width=\"2\"/><line x1=\"8\" y1=\"2\" x2=\"8\" y2=\"6\" stroke=\"currentColor\" stroke-width=\"2\"/><line x1=\"2\" y1=\"10\" x2=\"22\" y2=\"10\" stroke=\"currentColor\" stroke-width=\"2\"/>";
+    } | {
+        readonly viewBox: "0 0 24 24";
+        readonly content: "<circle cx=\"12\" cy=\"12\" r=\"10\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><polyline points=\"12 6 12 12 16 14\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 16 16";
+        readonly content: "<polyline points=\"4,10 8,6 12,10\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 16 16";
+        readonly content: "<polyline points=\"4,6 8,10 12,6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/>";
+    } | {
+        readonly viewBox: "0 0 24 24";
+        readonly content: "<circle cx=\"12\" cy=\"12\" r=\"10\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><line x1=\"12\" y1=\"8\" x2=\"12\" y2=\"12\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/><circle cx=\"12\" cy=\"16\" r=\"1\" fill=\"currentColor\"/>";
+    } | {
+        readonly viewBox: "0 0 24 24";
+        readonly content: "<path d=\"M12 2v4M12 18v4M4.93 4.93l2.83 2.83M16.24 16.24l2.83 2.83M2 12h4M18 12h4M4.93 19.07l2.83-2.83M16.24 7.76l2.83-2.83\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/>";
+    }>;
+    protected readonly safeContent: _angular_core.Signal<SafeHtml>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyIconComponent, "mdy-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Declaratively disables a field by name within an MdyDeclarativeAdapter. */
+declare class MdyDisabledDirective {
+    private readonly registry;
+    private readonly attrName;
+    /** Target field name — resolved from the host's attribute or [name] binding. */
+    readonly name: _angular_core.InputSignal<string>;
+    readonly mdyDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly fieldName;
+    private _lastField;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyDisabledDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyDisabledDirective, "[mdyDisabled]", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "mdyDisabled": { "alias": "mdyDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Shared base for declarative validator directives.
+ *
+ * Resolves the target field from either the static `name` attribute or a
+ * dynamic `[name]` binding (the directive declares its own `name` input, so
+ * Angular delivers the same binding the renderer receives — B11), and keeps
+ * the registered validators in sync with the directive inputs: every change
+ * re-runs {@link buildValidators} and swaps the previous set via a per-instance
+ * key. On destroy (or when the target field changes) the validators owned by
+ * this instance are removed (B12).
+ */
+declare abstract class MdyValidatorBaseDirective {
+    private readonly _registry;
+    private readonly _attrName;
+    /**
+     * Target field name. Populated automatically from the host's `name`
+     * attribute or `[name]` binding — no need to set it explicitly.
+     */
+    readonly name: _angular_core.InputSignal<string>;
+    private readonly _fieldName;
+    private readonly _key;
+    private _lastField;
+    /**
+     * Returns the current validator set for this directive.
+     * Called inside a reactive context: reading inputs here makes the
+     * registration re-run when they change.
+     * Validators are typed contravariantly (`ValidatorFn<never>`) so concrete
+     * directives can return validators for their specific value type.
+     */
+    protected abstract buildValidators(): {
+        readonly validators: ReadonlyArray<ValidatorFn<never>>;
+        readonly marksRequired?: boolean;
+    };
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyValidatorBaseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyValidatorBaseDirective, never, never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Validates e-mail format in declarative mode.
+ *
+ * ```html
+ * <mdy-control-text name="email" mdyEmail />
+ * <mdy-control-text name="email" [mdyEmail]="'Formato non valido'" />
+ * ```
+ */
+declare class MdyEmailDirective extends MdyValidatorBaseDirective {
+    /** Optional custom error message. */
+    readonly mdyEmail: _angular_core.InputSignal<string | undefined>;
+    protected buildValidators(): {
+        validators: _modyra_core.ValidatorFn<string | null>[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyEmailDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyEmailDirective, "[mdyEmail]", never, { "mdyEmail": { "alias": "mdyEmail"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Validates maximum length in declarative mode.
+ *
+ * ```html
+ * <mdy-control-text name="bio" [mdyMaxLength]="200" />
+ * <mdy-control-text name="bio" [mdyMaxLength]="200" mdyMaxLengthMessage="Troppo lungo" />
+ * ```
+ */
+declare class MdyMaxLengthDirective extends MdyValidatorBaseDirective {
+    readonly mdyMaxLength: _angular_core.InputSignal<string | number>;
+    readonly mdyMaxLengthMessage: _angular_core.InputSignal<string | undefined>;
+    protected buildValidators(): {
+        validators: _modyra_core.ValidatorFn<string | readonly unknown[]>[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyMaxLengthDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyMaxLengthDirective, "[mdyMaxLength]", never, { "mdyMaxLength": { "alias": "mdyMaxLength"; "required": true; "isSignal": true; }; "mdyMaxLengthMessage": { "alias": "mdyMaxLengthMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Validates numeric maximum in declarative mode.
+ *
+ * ```html
+ * <mdy-control-number name="age" [mdyMax]="99" />
+ * <mdy-control-number name="age" [mdyMax]="99" mdyMaxMessage="Valore troppo alto" />
+ * ```
+ */
+declare class MdyMaxDirective extends MdyValidatorBaseDirective {
+    readonly mdyMax: _angular_core.InputSignal<string | number>;
+    readonly mdyMaxMessage: _angular_core.InputSignal<string | undefined>;
+    protected buildValidators(): {
+        validators: _modyra_core.ValidatorFn<number | null>[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyMaxDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyMaxDirective, "[mdyMax]", never, { "mdyMax": { "alias": "mdyMax"; "required": true; "isSignal": true; }; "mdyMaxMessage": { "alias": "mdyMaxMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Validates minimum length in declarative mode.
+ *
+ * ```html
+ * <mdy-control-text name="username" [mdyMinLength]="3" />
+ * <mdy-control-text name="username" [mdyMinLength]="3" mdyMinLengthMessage="Troppo corto" />
+ * ```
+ */
+declare class MdyMinLengthDirective extends MdyValidatorBaseDirective {
+    readonly mdyMinLength: _angular_core.InputSignal<string | number>;
+    readonly mdyMinLengthMessage: _angular_core.InputSignal<string | undefined>;
+    protected buildValidators(): {
+        validators: _modyra_core.ValidatorFn<string | readonly unknown[]>[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyMinLengthDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyMinLengthDirective, "[mdyMinLength]", never, { "mdyMinLength": { "alias": "mdyMinLength"; "required": true; "isSignal": true; }; "mdyMinLengthMessage": { "alias": "mdyMinLengthMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Validates numeric minimum in declarative mode.
+ *
+ * ```html
+ * <mdy-control-number name="age" [mdyMin]="18" />
+ * <mdy-control-number name="age" [mdyMin]="18" mdyMinMessage="Devi essere maggiorenne" />
+ * ```
+ */
+declare class MdyMinDirective extends MdyValidatorBaseDirective {
+    readonly mdyMin: _angular_core.InputSignal<string | number>;
+    readonly mdyMinMessage: _angular_core.InputSignal<string | undefined>;
+    protected buildValidators(): {
+        validators: _modyra_core.ValidatorFn<number | null>[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyMinDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyMinDirective, "[mdyMin]", never, { "mdyMin": { "alias": "mdyMin"; "required": true; "isSignal": true; }; "mdyMinMessage": { "alias": "mdyMinMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Validates a RegExp pattern in declarative mode.
+ *
+ * ```html
+ * <mdy-control-text name="code" [mdyPattern]="codeRegex" />
+ * <mdy-control-text name="code" [mdyPattern]="codeRegex" mdyPatternMessage="Formato non valido" />
+ * ```
+ */
+declare class MdyPatternDirective extends MdyValidatorBaseDirective {
+    readonly mdyPattern: _angular_core.InputSignal<string | RegExp>;
+    readonly mdyPatternMessage: _angular_core.InputSignal<string | undefined>;
+    protected buildValidators(): {
+        validators: _modyra_core.ValidatorFn<string | null>[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyPatternDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyPatternDirective, "[mdyPattern]", never, { "mdyPattern": { "alias": "mdyPattern"; "required": true; "isSignal": true; }; "mdyPatternMessage": { "alias": "mdyPatternMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Marks a control as required in declarative mode.
+ *
+ * ```html
+ * <mdy-control-text name="email" mdyRequired />
+ * <mdy-control-text name="email" [mdyRequired]="'Email obbligatoria'" />
+ * ```
+ */
+declare class MdyRequiredDirective extends MdyValidatorBaseDirective {
+    /** Optional custom error message — pass as binding: [mdyRequired]="'...'" */
+    readonly mdyRequired: _angular_core.InputSignal<string | undefined>;
+    protected buildValidators(): {
+        validators: _modyra_core.ValidatorFn<unknown>[];
+        marksRequired: boolean;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyRequiredDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MdyRequiredDirective, "[mdyRequired]", never, { "mdyRequired": { "alias": "mdyRequired"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Binds the framework-agnostic form engine to Angular's native signals: the
+ * engine's state IS Angular signal state, so templates, `computed`s and
+ * zoneless change detection react to it with no bridging layer.
+ *
+ * Effects need an {@link Injector}; without one the reactivity reports
+ * `canEffect: false` and the engine skips effect-dependent features
+ * (async validators, drafts, history) with a warning — matching the
+ * behavior of constructing the adapter without an injector.
+ */
+declare function angularReactivity(injector?: Injector): MdyReactivity;
+
+/**
+ * Angular runtime for Modyra widget commands.
+ *
+ * Provides framework-specific execution of UI commands produced by headless
+ * widget controllers: focus scheduling after render, scrolling, announcements,
+ * and overlay/open coordination.
+ */
+
+/** Maps a widget part name to an element reference. */
+type MdyElementRefMap = ReadonlyMap<string, ElementRef<HTMLElement> | undefined>;
+/** Lookup for item elements inside a part (e.g. options inside listbox). */
+type MdyItemRefLookup = (part: string, key: string) => ElementRef<HTMLElement> | undefined;
+/** Handlers for command side effects that need host/component cooperation. */
+interface MdyAngularCommandHandlers {
+    /** Called for open-overlay / close-overlay. */
+    setOpen(open: boolean): void;
+    /** Called for emit-change. */
+    onChange?(): void;
+    /** Called for mark-touched. */
+    onTouched?(): void;
+    /** Called for mark-dirty. */
+    onDirty?(): void;
+}
+/**
+ * Executes a list of UI commands in an Angular runtime context.
+ *
+ * Focus/scroll operations are deferred with `afterNextRender` so they run
+ * after the DOM has been updated by change detection.
+ */
+declare class MdyWidgetRuntime {
+    private readonly injector;
+    private readonly announcer;
+    execute(commands: readonly MdyUiCommand[], elements: MdyElementRefMap, itemLookup: MdyItemRefLookup, handlers: MdyAngularCommandHandlers): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyWidgetRuntime, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MdyWidgetRuntime>;
+}
+
+/**
+ * Angular adapter for the Modyra headless select controller.
+ *
+ * Bridges the framework-agnostic controller with Angular-specific command
+ * execution and signal integration. The host component creates an instance,
+ * feeds it DOM refs and callbacks, and reads the reactive view contract.
+ */
+
+interface MdyAngularSelectAdapterOptions<TValue> extends Omit<MdySelectControllerOptions<TValue>, "onChange"> {
+    readonly onChange?: (value: TValue | null) => void;
+}
+declare class MdyAngularSelectAdapter<TValue = string> {
+    private readonly controller;
+    private readonly runtime;
+    /** Reactive Angular signal wrapping the controller state. */
+    readonly state: Signal<MdySelectState<TValue>>;
+    /** Reactive Angular signal wrapping the view/ARIA contract. */
+    readonly view: Signal<ReturnType<MdySelectController<TValue>["view"]>>;
+    /** Current open state, useful for binding to the overlay panel. */
+    readonly open: Signal<boolean>;
+    /** Registry of part element refs. */
+    private readonly elements;
+    /** Registry of item element refs keyed by `part:key`. */
+    private readonly itemElements;
+    /** Callbacks to the host component. */
+    private handlers;
+    constructor(options: MdyAngularSelectAdapterOptions<TValue>, runtime: MdyWidgetRuntime, injector: Injector);
+    /** Register a part element ref. */
+    registerPart(name: string, ref: ElementRef<HTMLElement>): void;
+    /** Register an item element ref (e.g. an option). */
+    registerItem(part: string, key: string, ref: ElementRef<HTMLElement>): void;
+    /** Connect host callbacks for command execution. */
+    connectHandlers(handlers: MdyAngularCommandHandlers): void;
+    /** Dispatch an intent and execute the resulting commands. */
+    dispatch(intent: MdySelectIntent): void;
+    /** Set the selected value programmatically. */
+    setValue(value: TValue | null): void;
+    /** Replace the option list. */
+    setOptions(options: readonly MdySelectOption<TValue>[]): void;
+    /** Update the open state programmatically without emitting commands. */
+    setOpen(open: boolean): void;
+    /** Update the disabled state. */
+    setDisabled(disabled: boolean): void;
+    /** Update the readonly state. */
+    setReadonly(readonly: boolean): void;
+    /** Update the invalid state. */
+    setInvalid(invalid: boolean): void;
+    /** Update the loading state. */
+    setLoading(loading: boolean): void;
+    /** Release resources. */
+    destroy(): void;
+    private lookupItem;
+}
+
+export { MDY_DATE_LOCALE, MDY_DECLARATIVE_REGISTRY, MDY_DEVTOOLS_HOTKEY, MDY_FLOATING_LABELS, MDY_FLOATING_LABELS_DEFAULT, MDY_FLOATING_LABELS_DENSITY_DEFAULT, MDY_FORM_ADAPTER, MDY_I18N_MESSAGES, MDY_INLINE_ERRORS, MdyA11yAnnouncer, MdyAngularSelectAdapter, MdyBaseControl, MdyCalendarCellComponent, MdyCalendarComponent, MdyCalendarGridComponent, MdyCalendarHeaderComponent, MdyCheckboxComponent, MdyChipsDirective, MdyColorsComponent, MdyConditionalOptionsDirective, MdyControlComponent, MdyControlLabelComponent, MdyDatePickerComponent, MdyDateRangePickerComponent, MdyDeclarativeAdapter, MdyDevtoolsDirective, MdyDisabledDirective, MdyDynamicFormComponent, MdyEmailDirective, MdyErrorListComponent, MdyFileComponent, MdyFloatingLabelsDirective, MdyFormArrayComponent, MdyFormComponent, MdyFormWizardComponent, MdyFormsDevtoolsComponent, MdyFormsDevtoolsOverlayComponent, MdyFormsDevtoolsService, MdyGlassDirective, MdyIconComponent, MdyInlineErrorIconComponent, MdyInlineErrorsDirective, MdyLoadOptionsDirective, MdyMaxDirective, MdyMaxLengthDirective, MdyMinDirective, MdyMinLengthDirective, MdyMultiselectComponent, MdyNumberComponent, MdyOptionDirective, MdyOptionsAutoLoadingDirective, MdyOptionsOverlayControl, MdyOverlayControl, MdyPatternDirective, MdyPrefixDirective, MdyRadioGroupComponent, MdyRangeCalendarComponent, MdyRangeCalendarGridComponent, MdyRequiredDirective, MdySegmentedButtonComponent, MdySelectComponent, MdySliderComponent, MdySuffixDirective, MdySupportingTextDirective, MdyTextComponent, MdyTextareaComponent, MdyTimepickerComponent, MdyToggleComponent, MdyTypedForm, MdyValidatorBaseDirective, MdyWidgetRuntime, MdyWizardStepComponent, angularReactivity, array, field, group, mdyForm, provideModyraLocale };
+export type { MdyAngularCommandHandlers, MdyAngularSelectAdapterOptions, MdyAnyArrayDescriptor, MdyAnyFieldDescriptor, MdyAnyGroupDescriptor, MdyArrayDescriptor, MdyArrayHandle, MdyArrayItemValue, MdyControlRendererConfig, MdyDeclarativeRegistry, MdyElementRefMap, MdyFieldConfig, MdyFieldDescriptor, MdyFieldHandle, MdyFieldHandleTree, MdyFieldOptions, MdyFieldRef, MdyFieldState, MdyFieldTree, MdyFormAdapter, MdyFormContext, MdyFormOptions, MdyFormPatch, MdyFormSchema, MdyFormState, MdyFormValue, MdyGroupDescriptor, MdyItemHandleTree, MdyItemRefLookup, MdyLocaleOptions, MdyOptionsControl, MdyOptionsLoader, MdyTypedFormLike };
+//# sourceMappingURL=modyra-angular.d.ts.map