import * as _angular_core from '@angular/core';
import { WritableSignal, Signal, Injector, InjectionToken, Provider, TemplateRef, OnInit, ElementRef, InputSignal, OnDestroy, InputSignalWithTransform } from '@angular/core';
import * as _modyra_core from '@modyra/core';
import { MdyFormAdapter as MdyFormAdapter$1, MdyWritableSignal, MdySignal, MdyFormState as MdyFormState$1, MdyFieldState as MdyFieldState$1, MdyFormError, MdyControlOption, ValidatorFn, MdySelectOption, MdyFormRegistry, MdyFormEngine, MdySubmitMode, MdySecurityPolicy, MdyAnyArrayDescriptor as MdyAnyArrayDescriptor$1, MdyAnyFieldDescriptor as MdyAnyFieldDescriptor$1, MdyAnyGroupDescriptor as MdyAnyGroupDescriptor$1, MdyAnyRecordDescriptor as MdyAnyRecordDescriptor$1, MdyAnyRowDescriptor as MdyAnyRowDescriptor$1, MdyArrayDescriptor as MdyArrayDescriptor$1, MdyArrayHandle as MdyArrayHandle$1, MdyArrayItemValue as MdyArrayItemValue$1, MdyFieldHandle as MdyFieldHandle$1, MdyFieldDescriptor as MdyFieldDescriptor$1, MdyFormSchema as MdyFormSchema$1, MdyGroupDescriptor as MdyGroupDescriptor$1, MdyRecordDescriptor as MdyRecordDescriptor$1, MdyRecordHandle as MdyRecordHandle$1, MdyFieldOptions as MdyFieldOptions$1, MdyTypedFormBaseOptions, MdyFormPatch as MdyFormPatch$1, MdyFormValue as MdyFormValue$1, MdyFormSubmitEvent, MdyTypedFormBase, MdySubmittedValue, MdyWiden as MdyWiden$1, MdyGroupOptions, MdyFormValidatorFn, MdyAsyncValidatorFn, MdyAsyncValidatorOptions, MdySanitizer, MdyDynamicField, MdyTimepickerViewMode, MdyTimeGranularity, MdyDynamicParseMode, MdyDynamicDiagnostic, MdyDynamicLayoutNode, MdyDynamicLayoutChild, MdyFieldError, MdyFieldConstraints, MdyDateRange, MdyMultiselectMode, MdyDiagnostics, MdyReactivity } from '@modyra/core';
export { MdyAsyncValidatorFn, MdyAsyncValidatorOptions, MdyControlOption, MdyDateRange, MdyDraftOptions, MdyDraftStorage, MdyFieldError, MdyFormError, MdyFormSubmitEvent, MdyFormValidatorFn, MdySanitizeProfile, MdySanitizer, MdySecurityPolicy, MdySecurityViolation, MdySecurityViolationKind, MdySelectOption, MdySubmitMode, ValidatorFn } from '@modyra/core';
import * as _modyra_angular from '@modyra/angular';
import * as _modyra_widgets from '@modyra/widgets';
import { MdyI18nMessages, MdyBuiltInLocale, MdyPartContract, MdyWidgetKind, MdyValueWidgetIntent, MdyOverlayCoords, MdyOverlayBranch, MdyDatepickerFieldController, MdyDaterangeFieldController, scrollChipStripByWheel, MdyTimepickerViewMode as MdyTimepickerViewMode$1, MdyTimepickerFieldIntent, MdyWidgetCommandHandlers, MdyUiCommand, MdySelectState, MdySelectFieldController, MdySelectFieldControllerOptions, MdySelectIntent } from '@modyra/widgets';
import { MdyDateLocale, MdyTimeFormat, CalendarCell, CalendarDate } from '@modyra/core/datetime';
import { SafeHtml } from '@angular/platform-browser';

/**
 * Re-brands the engine's structural signals as Angular's own.
 *
 * The engine describes reactivity through a minimal contract whose signal type is a bare `(): T`.
 * At runtime these controls are built on Angular's primitives, so the branded types are accurate —
 * and derived rather than restated, so a member added to the engine's state arrives here with no
 * edit and the two cannot describe different shapes.
 *
 * Only sound for a type whose members are all signals: a zero-argument method is structurally a
 * signal too and would be re-branded into one.
 */
type AsAngularSignals<T> = {
    readonly [K in keyof T]: T[K] extends MdyWritableSignal<infer V> ? WritableSignal<V> : T[K] extends MdySignal<infer V> ? Signal<V> : T[K];
};
/** Reactive state of a single field, with Angular-branded signals. */
type MdyFieldState<TValue> = AsAngularSignals<MdyFieldState$1<TValue>>;
/** 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>>;
}
/** Reactive state of the whole form, with Angular-branded signals. */
type MdyFormState = AsAngularSignals<MdyFormState$1>;
/**
 * The engine's adapter contract with Angular-branded reactive members.
 *
 * Extends the engine's rather than repeating it, so every method — and every method the engine
 * gains — is inherited. {@link AsAngularSignals} cannot be applied wholesale here: `getValue(): T`
 * is structurally a signal and would be re-branded into one, so the two genuinely reactive members
 * are overridden by name and nothing else is touched.
 *
 * Reset semantics, which the engine's own documentation does not fix:
 * - Fields with an explicit `[initialValue]` binding reset to that value.
 * - Fields seeded only via `[formValue]` reset to `null`; `[formValue]` is a prefill seed, not a
 *   persistent reset target.
 * - All `touched` and `dirty` states are cleared.
 */
interface MdyFormAdapter<T extends object, TSubmit = Partial<T>> extends Omit<MdyFormAdapter$1<T, TSubmit>, "state" | "value" | "getField"> {
    readonly state: MdyFormState;
    /** Reactive signal that emits the current form value on every change. */
    readonly value: Signal<T>;
    getField<K extends keyof T>(name: K): MdyFieldRef<T[K]> | null;
    errorsFor(path: keyof T | string): Signal<ReadonlyArray<MdyFormError>>;
}
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, 
    /** Injection-prevention policy for field values (see `@modyra/core` security). */
    security?: MdySecurityPolicy);
    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>, Partial<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 MdyAnyRecordDescriptor = MdyAnyRecordDescriptor$1;
type MdyAnyRowDescriptor = MdyAnyRowDescriptor$1;
type MdyArrayDescriptor<TItem> = MdyArrayDescriptor$1<TItem>;
type MdyRecordDescriptor<TItem> = MdyRecordDescriptor$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.
 */
/**
 * Typed handle for a single field, with Angular-branded signals.
 *
 * Derived from the engine's handle rather than restated. Written out member by member it drifted the
 * moment the engine gained one: `interactivity` and `readonly` arrived in the contract and not in
 * the copy, so a handle built here satisfied this file's idea of the type, compiled, and threw
 * `handle.readonly is not a function` the first time a widget controller asked.
 */
type MdyFieldHandle<TValue> = AsAngularSignals<Omit<MdyFieldHandle$1<TValue>, MdyFieldHandleCommands>> & Pick<MdyFieldHandle$1<TValue>, MdyFieldHandleCommands>;
/** The handle's imperative half: what a renderer calls, as against what it reads. */
type MdyFieldHandleCommands = "set" | "markAsTouched" | "markAsDirty";
/**
 * Typed handle for a repeatable array item, exposed on `form.f` (`form.f.items`).
 *
 * Derived from the engine's handle, like the field handle above and for the same reason: written out
 * member by member it satisfies this file's idea of the type and drifts the moment the engine gains
 * one.
 */
type MdyArrayHandle<TItemHandle, TItemValue> = AsAngularSignals<Omit<MdyArrayHandle$1<TItemHandle, TItemValue>, MdyArrayHandleCommands>> & Pick<MdyArrayHandle$1<TItemHandle, TItemValue>, MdyArrayHandleCommands>;
/** The array handle's imperative half: what a renderer calls, as against what it reads. */
type MdyArrayHandleCommands = "push" | "insert" | "remove" | "move" | "setAll" | "at";
/**
 * Typed handle for a collection keyed by data, exposed on `form.f` (`form.f.rows`).
 *
 * The core's shape with this framework's signal type — the members are the core's, and their meaning
 * is documented there.
 */
type MdyRecordHandle<TItemHandle, TItemValue> = AsAngularSignals<Omit<MdyRecordHandle$1<TItemHandle, TItemValue>, MdyRecordHandleCommands>> & Omit<Pick<MdyRecordHandle$1<TItemHandle, TItemValue>, MdyRecordHandleCommands>, "cell"> & {
    cell<TCell = unknown>(key: string, path?: string): MdyFieldHandle<TCell>;
};
/** The record handle's imperative half. */
type MdyRecordHandleCommands = "has" | "row" | "cell" | "upsert" | "remove" | "setAll" | "patch" | "rename" | "validOf";
/**
 * The handle tree for a single row — a field handle, a nested group tree, or the collection a row
 * of a record may itself hold. The two collection arms return this framework's own handle types,
 * so a nested handle carries Angular's signals exactly like a top-level one.
 */
type MdyItemHandleTree<I> = I extends MdyGroupDescriptor<infer C> ? MdyFieldHandleTree<C> : I extends MdyFieldDescriptor<infer V> ? MdyFieldHandle<V> : I extends MdyRecordDescriptor<infer R> ? MdyRecordHandle<MdyItemHandleTree<R>, MdyArrayItemValue<R>> : I extends MdyArrayDescriptor<infer A> ? MdyArrayHandle<MdyItemHandleTree<A>, MdyArrayItemValue<A>> : 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>> : S[K] extends MdyRecordDescriptor<infer I> ? MdyRecordHandle<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).
 *
 * `options.when` says the whole section is only in play under a condition — see
 * {@link MdyGroupOptions}. A wrapper that dropped it would make the Angular schema quietly poorer
 * than the one every other adapter writes.
 */
declare function group<TChildren extends MdyFormSchema>(children: TChildren, options?: MdyGroupOptions): MdyGroupDescriptor<TChildren>;
/** Declares a repeatable array of fields or groups (`items.0.name` paths on the adapter). */
declare function array<TItem extends MdyAnyRowDescriptor>(item: TItem, options?: {
    readonly initial?: ReadonlyArray<unknown>;
    readonly validators?: ReadonlyArray<ValidatorFn<readonly unknown[]>>;
}): MdyArrayDescriptor<TItem>;
/** Declares a collection keyed by data (`rows.a3f9.name` paths on the adapter). */
declare function record<TItem extends MdyAnyRowDescriptor>(item: TItem, options?: {
    readonly initial?: Readonly<Record<string, unknown>>;
    readonly validators?: ReadonlyArray<ValidatorFn<Readonly<Record<string, unknown>>>>;
}): MdyRecordDescriptor<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>;
    /** Every field except the disabled ones — what a submit actually sends. */
    submitValue(): Partial<Record<string, unknown>>;
    getField(name: string): MdyFieldRef<unknown> | null;
    errorsFor(path: string): Signal<ReadonlyArray<MdyFormError>>;
    submit(action: (value: Partial<Record<string, unknown>>) => Promise<MdyFormError[] | void> | MdyFormError[] | void): Promise<void>;
    markAllTouched(): void;
    buildSubmitEvent(value: never): MdyFormSubmitEvent<Record<string, unknown>, Partial<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>, MdySubmittedValue<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 does not contain 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>, TSubmit = Partial<T>> implements MdyFormAdapter<T, TSubmit>, MdyDeclarativeRegistry {
    /** Explicit adapter — if omitted the form creates one automatically. */
    readonly adapter: _angular_core.InputSignal<MdyFormAdapter<T, TSubmit> | 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, TSubmit> & MdyDeclarativeRegistry) | undefined>;
    /**
     * The submit action.
     *
     * Receives `Partial<T>`, not `T`: a disabled field is not submitted, and any field may be
     * disabled at runtime. Read a key defensively rather than assuming the form's shape.
     */
    readonly action: _angular_core.InputSignal<((value: TSubmit) => 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, TSubmit>>;
    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();
    /** Where the deferred draft start is scheduled from; the constructor is an injection context. */
    private readonly _draftInjector;
    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;
    setSanitizer(name: string, sanitizer: MdySanitizer): void;
    setDisabled(name: string, disabled: Signal<boolean>): void;
    setInactive(name: string, inactive: Signal<boolean>): void;
    setReadonly(name: string, readonly: Signal<boolean>): void;
    get state(): MdyFormState;
    /** Class vocabulary for the form's own parts, from the widget contract rather than spelled here. */
    protected readonly formErrorsClass: string;
    protected readonly formErrorItemClass: string;
    /** What the form has to say about itself: the refusals no field will show. */
    protected formErrors(): ReadonlyArray<MdyFormError>;
    /**
     * Reactive flat field paths of the active adapter — used by the devtools. Empty for a custom
     * `[adapter]` with no notion of membership to report.
     */
    get fieldNames(): Signal<readonly string[]>;
    get value(): Signal<T>;
    getValue(): T;
    /** Every field except the disabled ones — what a submit actually sends. */
    submitValue(): TSubmit;
    getField<K extends keyof T>(name: K): MdyFieldRef<T[K]> | null;
    errorsFor(path: keyof T | string): Signal<ReadonlyArray<MdyFormError>>;
    submit(action: (value: TSubmit) => Promise<MdyFormError[] | void> | MdyFormError[] | void): Promise<void>;
    markAllTouched(): void;
    /** Forwarded like every other adapter member: the form the component wraps is the one that counts it. */
    reportEntry(name: string, problem: string | null): void;
    buildSubmitEvent(value: TSubmit): MdyFormSubmitEvent<T, TSubmit>;
    patchValue(partial: Partial<T>): void;
    setValue(value: T): void;
    reset(): void;
    protected handleSubmit(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyFormComponent<any, any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyFormComponent<any, 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.
     *
     * A collection is walked like anything else, by the indexed paths its rows occupy: a row's field
     * is `items.0.password` here exactly as it is in the table above, so one rule answers for both
     * views. Left as a leaf, an array handed back its rows whole — and a password inside one was
     * printed in the panel this masking exists to keep it out of.
     */
    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>;
}

declare class MdyDynamicFormComponent {
    protected readonly defaultFormat: MdyTimeFormat;
    protected readonly initialView = "dial";
    /** The palette the contract suggests, for a document that names none. */
    protected readonly defaultPresets: readonly string[];
    /** An options field's own members, read from the union the template narrows by `kind`. */
    protected asOptions(field: MdyDynamicField): {
        readonly searchable?: boolean;
        readonly reorderable?: boolean;
        readonly mode?: "single" | "multi";
    };
    /**
     * The rest of what a document may say about a field, read from the union the template narrows by
     * `kind`.
     *
     * A member a document declares, a component reads and a case does not bind is a capability that
     * parses, validates and reaches no control — the shape that left `searchable` dropped and a
     * document asking for a filter getting a native chooser. These are the ones the audit found.
     */
    protected asMore(field: MdyDynamicField): {
        readonly presets?: readonly string[];
        readonly accept?: string;
        readonly multiple?: boolean;
        readonly minDate?: string;
        readonly maxDate?: string;
    };
    /** A timepicker's own members, read from the union the template narrows by `kind`. */
    protected asTime(field: MdyDynamicField): {
        readonly format?: MdyTimeFormat;
        readonly viewMode?: MdyTimepickerViewMode;
        readonly granularity?: MdyTimeGranularity;
        readonly animateHand?: boolean;
        readonly showUnavailable?: boolean;
    };
    /**
     * Serializable field configs, rendered in order.
     *
     * Optional because {@link MdyDynamicFormComponent.document} is the other way in. One of the two is
     * given; a component handed neither renders nothing, which is what an empty list already meant.
     */
    readonly fields: _angular_core.InputSignal<readonly MdyDynamicField[]>;
    /**
     * A document as it arrived — from a server, a CMS, a model — read by this component.
     *
     * The component is named for the dynamic contract and took only the *parsed* half of it, so a host
     * rendering one server document on this adapter and another wrote the parse step twice, with the
     * strict-mode diagnostics and the refusal of a partial form as the part most easily forgotten.
     *
     * Untrusted by construction: it is parsed here, and in strict mode a document carrying any error
     * renders nothing rather than the part of itself that happened to be well formed. The diagnostics
     * are emitted either way, so a host can show them.
     */
    readonly document: _angular_core.InputSignal<unknown>;
    /**
     * What tells this form's ids apart from another form's built from the same document.
     *
     * Ids come from the field's path, so two forms of one document claim one set of them (ADR 0135).
     * A consumer placing controls by hand scopes each of them; a consumer of this component places
     * none — it builds its own — so the scope is taken here, at the door a document arrives through,
     * and forwarded to every control this form renders.
     */
    readonly idScope: _angular_core.InputSignal<string>;
    /**
     * This instance's identity, for the scope registry to key on.
     *
     * An empty object, held for the component's lifetime. What the registry needs is something that is
     * *this form and no other* — the component itself would do, and an object with no other purpose
     * cannot acquire one.
     */
    private readonly scopeIdentity;
    /**
     * The scope actually used: the one bound, or one derived when nothing was bound.
     *
     * The comment on `idScope` has always said the scope is taken here, at the door a document arrives
     * through. It was not: the default was empty, so two of these on one page claimed one set of ids
     * and every reference in the second resolved into the first — a person using a screen reader in the
     * second form heard the help text of a field they were not looking at. The page shows nothing and
     * nothing throws: it is answering a different question correctly.
     *
     * Derived the way the framework-free renderer derives it, from the same primitive, so a document
     * behaves the same whichever renderer draws it. Only a *live* scope pushes the next one along, so a
     * form that has gone takes its scope with it and the form that replaces it reads as the one before.
     *
     * A consumer binding `idScope` still decides: this fills the silence, it does not overrule.
     *
     * **Asked of the live set rather than of the document**, which is the difference between here and
     * the framework-free renderer. There, mounting is a call and the first form has written its ids
     * before the second asks. Here both are computed in one change-detection pass, before either has
     * rendered anything — so a form looking for its neighbour's ids in the DOM finds an empty page and
     * takes the same scope. The component knows what is live at a moment the document does not.
     */
    protected readonly resolvedScope: Signal<string>;
    /**
     * Where this form keeps what has been typed but not sent, and `undefined` for a form that keeps
     * nothing.
     *
     * Forwarded to the inner form rather than declared again. The other renderers of a document take
     * the same option at their own door, and a component that accepted a document and dropped this
     * silently was a form asked to keep a draft that kept nothing and said nothing about it.
     */
    readonly draftKey: _angular_core.InputSignal<string | undefined>;
    /** How the document is read. `strict` refuses a document with any error; `lenient` renders what parsed. */
    readonly parseMode: _angular_core.InputSignal<MdyDynamicParseMode>;
    /** What reading {@link MdyDynamicFormComponent.document} found, emitted whenever the document changes. */
    readonly diagnostics: _angular_core.OutputEmitterRef<readonly MdyDynamicDiagnostic[]>;
    /**
     * The document, read — or `null` when none was given and the pre-parsed inputs are the source.
     *
     * A computed rather than an effect: the fields and the layout are two readings of one parse, and
     * parsing once per read of each would answer two different documents for one input.
     */
    protected readonly parsed: Signal<_modyra_core.MdyDynamicFormParseResult | null>;
    /**
     * What is rendered: the document's fields when there is one, the input's otherwise.
     *
     * The input's are checked, because nothing upstream has checked them. A document arrives through a
     * parser that drops what the contract will not carry; a field list handed over directly arrives as
     * it was written, and a list naming one field twice built a form with one of that name and a
     * control for each — so the second control wrote into the first control's field, over what a person
     * had typed, and the entry after the pair was not drawn at all. The check is the same one the other
     * renderer's field-list door makes, and it refuses rather than repairs: which of two fields sharing
     * a name is the real one is not something a renderer can know.
     */
    protected readonly renderedFields: Signal<readonly MdyDynamicField[]>;
    /** The layout the same way, so a document that is refused arranges nothing either. */
    protected readonly renderedLayout: Signal<readonly MdyDynamicLayoutNode[]>;
    /**
     * What a field starts as when the config names no initial value.
     *
     * The answer is the contract's, not this template's: spelling it per kind here made a third table
     * beside the one the rule reads, and the three did not agree.
     */
    protected emptyFor(field: MdyDynamicField): unknown;
    /**
     * Contract v2 layout: sections and column rows, nestable. Fields the layout names render inside
     * it; anything it does not mention still renders, after — a partial layout arranges the part it
     * describes rather than hiding the rest.
     */
    readonly layout: _angular_core.InputSignal<readonly MdyDynamicLayoutNode[]>;
    /** The class vocabulary is the contract's, so every adapter draws the same grid. */
    protected readonly layoutClasses: Readonly<{
        section: "mdy-layout-section";
        sectionLabel: "mdy-layout-legend";
        columns: "mdy-layout-columns";
        column: "mdy-layout-column";
    }>;
    /** Fields no layout node claims, rendered after the arranged ones. */
    protected readonly unplacedFields: Signal<MdyDynamicField[]>;
    /**
     * The field a slot names, or `null` when the child is a nested layout node.
     *
     * A bare string and a v3 `{ ref }` slot name a field the same way; the slot merely also says where
     * it sits. Answering with the name rather than a type guard keeps the template to one branch for
     * both spellings, which is what stops the two drifting apart.
     */
    protected fieldNameOf(child: MdyDynamicLayoutChild): string | null;
    /**
     * A column's own placement, from the first child inside it that asks for one.
     *
     * A slot and a section answer the same way: a section occupying a column is a column like any
     * other, which is how a group in a row is laid out for a screen size.
     */
    protected columnStyle(column: ReadonlyArray<MdyDynamicLayoutChild>): Record<string, string>;
    protected fieldByName(name: string): MdyDynamicField | undefined;
    /** The track count the foundation divides a column row by. */
    protected columnRowStyle(node: MdyDynamicLayoutNode): Record<string, string>;
    /** Re-emitted from the inner `<mdy-form>`. */
    readonly submitted: _angular_core.OutputEmitterRef<MdyFormSubmitEvent<Record<string, unknown>, Partial<Record<string, unknown>>>>;
    /** Inner form — exposed so consumers can call getValue()/reset()/submit(). */
    readonly form: Signal<MdyFormComponent<Record<string, unknown>, Partial<Record<string, unknown>>>>;
    private readonly _injector;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyDynamicFormComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyDynamicFormComponent, "mdy-dynamic-form", never, { "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "document": { "alias": "document"; "required": false; "isSignal": true; }; "idScope": { "alias": "idScope"; "required": false; "isSignal": true; }; "draftKey": { "alias": "draftKey"; "required": false; "isSignal": true; }; "parseMode": { "alias": "parseMode"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, { "diagnostics": "diagnostics"; "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: _modyra_widgets.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 {
    /**
     * What the chip wears, from the contract's vocabulary rather than from three literals here.
     *
     * A class spelled in a template is a renderer deciding what a chip is; the next one spells it
     * differently, and the theme's rule quietly styles nothing.
     */
    protected readonly classes: _angular_core.Signal<string>;
    /** 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 readonly _injector;
    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 | null> | MdyFieldHandle<TValue> | undefined>;
    /** Resolved adapter path: the handle's path or the `name` input. */
    protected readonly effectiveName: Signal<string>;
    /**
     * Which form on the page this control belongs to, where a host renders more than one.
     *
     * Unset is the ordinary case. Set, it scopes every id this control publishes, so two forms built
     * from the same document do not both claim `when__label`. A single character neither part may
     * contain joins them, so two distinct scopes cannot produce one id.
     */
    readonly idScope: InputSignal<string>;
    /** What a control with no field falls back to. Not stable across mounts, because nothing about
     *  such a control is. */
    private readonly mountId;
    /**
     * The id every part of this control is built from.
     *
     * Derived from the field's own path (ADR 0135), so the same document renders the same ids every
     * time: a consumer can write `aria-describedby="when__label"` in their own markup, a stylesheet or
     * a test can name one, and server-rendered markup agrees with a client mount. A mount counter is a
     * property of what else was on the page first, and made every one of those a guess.
     *
     * Two fields called `when` on one page collide, visibly, and that is the better failure: two
     * counters never collide and never mean anything either. `idScope` is what a host with two forms
     * uses to keep them apart.
     */
    protected get fieldId(): string;
    /** The label text for the form control. */
    readonly label: InputSignal<string>;
    /**
     * The control's name when nothing visible carries it — a cell in a table, a control in a toolbar
     * whose column or icon says what it is to someone who can see it.
     *
     * Read only while `label` is empty. A visible label already names the control natively, and a
     * second name over the top of it is what makes the spoken name disagree with the written one.
     */
    readonly ariaLabel: InputSignal<string | null>;
    /**
     * The name on the control element.
     *
     * The explicit one when it is given, otherwise the visible label's text. Naming the control from
     * the label as well as through `for` is redundant on paper and load-bearing in practice: the
     * label element also holds the required marker, so a name computed from its content carries an
     * asterisk the user's word does not — and anything matching on the name exactly, a test or an
     * assistive tool's find-by-name, then misses the control the user is asking for.
     */
    /**
     * What this control is announced as.
     *
     * The order is the contract's: a spoken name a document wrote, the visible label, and the field's
     * own name when there is neither. A control with none of the three is announced as its role and
     * nothing else — a text box, on a form of them — and the field name is the one thing always
     * present, so it is a poor name and better than no name.
     */
    protected readonly controlAriaLabel: Signal<string | null>;
    /**
     * Which attribute names this control, asked of the contract rather than answered per renderer.
     *
     * Two names on one element is not two names: the computation takes `aria-labelledby` and stops, so
     * an `aria-label` beside it is text nobody hears — and a renderer writing `aria-label` where the
     * field has a visible caption replaces the words a person is reading with words only a reader
     * hears. ADR 0175.
     */
    protected readonly namedBy: Signal<Readonly<Record<string, string | null>>>;
    /** 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>;
    /**
     * The form this control writes into.
     *
     * Injected optionally so the failure can name the control. Without a form above it, Angular's own
     * error reports the missing token and nothing else — true, and useless in a template with thirty
     * controls in it, because the one that is outside is exactly the one it does not name.
     */
    private readonly _adapterOrNull;
    private get adapter();
    /** What identifies this control in a message, when it has said anything about which field it is. */
    private _nameForError;
    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 projectedSupportingText: Signal<MdySupportingTextDirective | undefined>;
    /**
     * The line under the control, as a value rather than a projected template.
     *
     * Projection is how a hand-written host supplies it; this is how a **document** does. A field
     * declaring `supportingText` had no route to the slot in this adapter, so the words existed in the
     * contract and reached three renderers of four.
     */
    readonly supportingText: InputSignal<string | undefined>;
    /** Whether anything at all wants the description slot — either route. */
    protected readonly hasSupportingText: Signal<boolean>;
    /**
     * 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;
    /**
     * The form that built the bound handle, when it is one this library made and it is not the form
     * enclosing this control. `null` for a `name` binding, a hand-built handle, or the ordinary case
     * of a handle from the enclosing form.
     */
    private _formOfHandle;
    /** Resolved field state — reactive to name/[field] changes. */
    protected readonly fieldState: Signal<MdyFieldState<TValue>>;
    readonly value: Signal<TValue>;
    /**
     * The errors this control shows — which is not always the errors the field holds.
     *
     * A field the form is not asking about carries no verdict on screen: the rule belongs to
     * `@modyra/widgets`, and everything below reads it from here, so the wrapper class, the label
     * state, `aria-invalid` and the error list cannot drift apart. The devtools panel deliberately
     * reads the field instead: a debugging view shows the model, not what the user is being asked.
     */
    protected readonly errors: Signal<ReadonlyArray<MdyFieldError>>;
    protected readonly touched: Signal<boolean>;
    protected readonly dirty: Signal<boolean>;
    protected readonly isDisabled: Signal<boolean>;
    /**
     * Read but not written.
     *
     * Angular had no counterpart to `isDisabled`, so no template could bind the native attribute and
     * a field a form had marked read-only kept accepting typing. `dispatchValueIntent` already fed
     * `readonly` to the scalar controller, which meant the blocking half worked while the DOM said
     * nothing — the confusing state this closes.
     */
    protected readonly isReadonly: Signal<boolean>;
    protected readonly isValid: Signal<boolean>;
    protected readonly hasErrors: Signal<boolean>;
    /**
     * The messages a person is reading right now, which is not the same list as the ones that exist.
     *
     * `errors` answers *which refusals there are*; this answers *whether they are being told yet*, and
     * a renderer painting a list is asking the second. Bound to the first, every kind printed
     * "required" under a field nobody had answered — while `aria-invalid` beside it said `false`,
     * because that one had been taught the rule and this had not. One field, two verdicts, and the one
     * a sighted person reads was the wrong one.
     *
     * The container stays reserved either way: a message arriving must not push the page down.
     */
    protected readonly errorsOnScreen: Signal<ReadonlyArray<MdyFieldError>>;
    /**
     * Whether the control announces itself as failing — the one answer for `aria-invalid`.
     *
     * Named for the question because eight templates were answering it and one of them answered
     * differently: the colours field waited for `touched`, so a screen-reader user met a control the
     * form was rejecting and the control said nothing was wrong. The rule is the contract's
     * (`showsAsInvalid`: out of play, no verdict), and `errors()` already withholds the errors of a
     * field the form is not asking about — so a template that spells its own combination is a
     * template that can disagree with both.
     */
    protected readonly paintsAsInvalid: Signal<boolean>;
    /**
     * The classes on the wrapper that holds the control, which is where a field shows it is unusable,
     * locked or wrong.
     *
     * Composed here from the contract's own table rather than spelled per template. Every renderer
     * wrote the base class and bound `--disabled` beside it, and none of them bound the other two the
     * contract lists: a field the form had refused looked exactly like one it had accepted, and a
     * field locked for review exactly like one waiting to be filled in. The error class follows
     * `paintsAsInvalid`, the same answer `aria-invalid` takes, so what a theme paints and what a
     * screen reader is told cannot disagree.
     */
    protected readonly wrapperClasses: Signal<string>;
    /**
     * Where the keyboard goes when this field leaves play under it.
     *
     * Disabling a focused element blurs it — that is the platform. What follows is this library's: the
     * person who was typing is on `<body>`, their next Tab starts at the top of the document, and
     * nothing says where they went. A document's rule reaches this without anyone clicking, when a
     * value arriving from a fetch takes the field under the cursor out of play mid-word.
     *
     * `relatedTarget === null` is the only case handled: focus went nowhere rather than to something
     * else on the page. It is read one microtask later because the control is disabled during the
     * render that blurs it, and the question is what happened after.
     */
    protected onFocusLost(event: FocusEvent): void;
    /** Effective aria-disabled: explicit input overrides field state. */
    protected readonly effectiveAriaDisabled: Signal<boolean>;
    /**
     * Whether the error list is actually in the DOM.
     *
     * The single condition every renderer template guards the list with, so that anything naming the
     * list — `aria-describedby` above all — cannot disagree with whether it was rendered. An invalid
     * but untouched field is the common case: it has errors and shows none.
     */
    /**
     * Whether the error list is in the DOM, whether or not it holds a message.
     *
     * What the templates guard on. The container is reserved under any field that can fail a rule,
     * because one that appears with the first message pushes down the field below it — the field
     * somebody leaving is moving toward, at the moment they are already moving. It stays once a message
     * clears: taking the space back is the same jump, upward.
     *
     * Distinct from {@link errorsRendered}, which stays "there is something to show". Supporting text
     * is displayed when no errors are, and folding the two together would hide the help at rest under
     * every field with a rule — an error must not take the place of the instruction that prevents it.
     */
    protected readonly errorsReserved: Signal<boolean>;
    protected readonly errorsRendered: Signal<boolean>;
    /**
     * The same question for a renderer that draws its error text beside the control rather than in a
     * list below it. One of the two is true at a time; both read the one rule, so a renderer cannot
     * show text the other would have hidden.
     */
    protected readonly inlineErrorShown: Signal<boolean>;
    /**
     * The id the supporting-text element carries, or `null` when none is rendered.
     *
     * Bound as `[id]` on that element by every renderer that draws one. Without it the text is
     * rendered, styled, and announced to nobody: a description no reference can reach is invisible to
     * assistive technology however carefully it is worded.
     */
    protected descriptionId(fieldId: string): string | null;
    /**
     * The id for `aria-describedby`, or `null` when there is nothing rendered to name.
     *
     * Takes the renderer's own `fieldId`, since each renderer mints one. The error list wins where
     * there is one, the supporting text answers otherwise, and a control with neither describes itself
     * by nothing — never by an id no element holds.
     */
    protected describedById(fieldId: string): string | null;
    /**
     * The semantic state of this control, as the shared contract projects it.
     *
     * A renderer binding `[mdyPart]="controlPart()"` receives `aria-invalid`, `aria-required`,
     * `aria-disabled` and `aria-describedby` from the shared projection, so no renderer decides for
     * itself which of a widget's states to expose.
     *
     * `errorsVisible` is answered here because the projection cannot know it: these renderers defer
     * the error list until the field is touched, so having errors is not the same as showing them.
     */
    /**
     * The values a native submit reads, for the kinds that draw no form control at all.
     *
     * A select is a button and a listbox; a multiselect is a button and a strip of chips. Neither is
     * something a form serialises, so without these inputs the browser sends nothing for the field —
     * not an empty value, nothing. Which kinds need them is the contract's answer, not this file's.
     */
    private syncHiddenSubmission;
    /**
     * The name a group of radio inputs shares.
     *
     * Two jobs in one attribute — it groups the set, and it is the key the answer arrives under — and
     * which one is at stake depends on whether this control has a form to belong to. Read from the DOM
     * rather than from state, because that is where the answer lives.
     */
    protected groupName(): string;
    /**
     * The hidden input a boolean field renders ahead of its box.
     *
     * HTML leaves an unchecked box out of the payload altogether, so without this a person who said no
     * and a form that never carried the question arrive identical at the other end. It carries `false`
     * under the field's key; when the box is checked it sends `true` after this one, and the later
     * value is the answer.
     */
    protected readonly submitFalsePart: Signal<MdyPartContract>;
    protected readonly controlPart: Signal<MdyPartContract>;
    /**
     * The kind this renderer draws.
     *
     * The projection decides from it which native constraints the control can carry, so a renderer
     * that does not say leaves a slider claiming `maxlength` and offering no range. It was typed
     * `string` and defaulted to text, which is how nine renderers came to inherit an answer none of
     * them meant; the union is what makes a wrong one unspellable.
     */
    protected readonly widgetKind: MdyWidgetKind;
    /**
     * What this renderer asks for on top of the field's rules — nothing, unless it has its own limits
     * to state. It cannot ask for more: the projection takes whichever end is tighter.
     */
    protected narrowedConstraints(): Partial<MdyFieldConstraints>;
    /** 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>;
    private readonly _valueControllers;
    /**
     * Sends scalar UI transitions through Widgets. Angular remains responsible
     * only for extracting the native DOM value and applying controller commands
     * to the form adapter.
     */
    protected dispatchValueIntent<T>(kind: MdyWidgetKind, intent: MdyValueWidgetIntent<T>): void;
    /**
     * The kind's own controller, built the first time this renderer needs it.
     *
     * Deferred rather than built in `ngOnInit`, because a field initializer is an injection context
     * and `ngOnInit` is not — and because six renderers each writing the same lifecycle is the
     * duplication that adopting a shared controller was supposed to remove, not relocate.
     */
    protected adoptFieldController<TController extends {
        destroy(): void;
    }>(create: (handle: MdyFieldHandle<TValue | null>, widgetId: string) => TController, sync?: (controller: TController) => void): () => TController | undefined;
    /**
     * A handle for the control to build its controller on, however the field was named.
     *
     * `[field]` hands one over. The `name` form does not — it resolves to the registry's state — and
     * for want of a handle every renderer kept a second way to commit its value, so the kind's
     * controller decided for one caller and the renderer decided for the other. The state carries
     * everything a handle exposes; what was missing was the shape, and the shape is written once.
     *
     * Registered against Angular's own runtime, because a controller resolves the runtime that owns
     * its handle: a synthetic one nobody claims would be observed by a vanilla runtime that cannot
     * see an Angular signal, and would render once and then never again.
     */
    private _syntheticHandle;
    private controllerHandle;
    protected dispatchValueBlur(kind: MdyWidgetKind): void;
    /**
     * The touched and dirty callbacks a widget runtime takes, answered by the owner of the value.
     *
     * A renderer that answers them itself has taken a decision the controller exists to make, and the
     * next renderer will not take it the same way. The runtime asks; this is who it reaches.
     */
    protected valueOwnerCallbacks(): {
        readonly onTouched: () => void;
        readonly onDirty: () => void;
    };
    /** Applies non-user synchronization without dirty/touched side effects. */
    protected synchronizeValue(value: TValue): void;
    setValue(newValue: TValue): void;
    protected markAsTouched(): void;
    protected markAsDirty(): void;
    /**
     * An entry the control could not read, said to the form.
     *
     * Resolved against the same form the state came from — a path means nothing without its form —
     * and silently ignored when the control is not bound, which is the state a detached control is in
     * before its name resolves.
     */
    protected reportEntry(problem: string | null): 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; }; "idScope": { "alias": "idScope"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "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; }; "supportingText": { "alias": "supportingText"; "required": false; "isSignal": true; }; }, {}, ["prefix", "suffix", "projectedSupportingText"], 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[]>;
    /**
     * The id comes from the shared factory rather than a local string, so that everything naming this
     * list — a projection's `aria-describedby` included — resolves to the element actually rendered.
     * Two spellings of one relation is how a reference silently dangles.
     */
    protected readonly errorsId: _angular_core.Signal<string>;
    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]="inlineErrorShown()"
 *   [errorText]="inlineErrorText()"
 * />
 * ```
 */
declare class MdyControlLabelComponent {
    /** The label text. If empty, renders nothing. */
    readonly label: _angular_core.InputSignal<string>;
    /**
     * Whether the field this label belongs to is failing.
     *
     * Distinct from `showInlineError`, which says *where* the message is drawn. The label used to take
     * its state from that alone, so a field showing its errors in a list below — the default — had a
     * label that never marked itself, and a theme keying off the class painted nothing on the field
     * the form had refused.
     */
    readonly hasError: _angular_core.InputSignal<boolean>;
    /** 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>;
    /**
     * The id this label carries, which is the one the projections name it by.
     *
     * Every popup's inner view is labelled by the field's own label — `aria-labelledby="<widget>__label"`
     * comes out of the widget projections — and a label with no id leaves every one of those references
     * pointing at nothing. Callers that need a different id pass `labelId`; the rest get the canonical
     * one built from the field they are labelling, rather than none.
     */
    protected readonly renderedId: _angular_core.Signal<string | null>;
    /**
     * The widget whose label this is. Falls back to what the label points at, which is the control's
     * own id for every kind that labels a control rather than a group.
     */
    readonly widgetId: _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; }; "hasError": { "alias": "hasError"; "required": false; "isSignal": true; }; "forId": { "alias": "forId"; "required": false; "isSignal": true; }; "labelId": { "alias": "labelId"; "required": false; "isSignal": true; }; "widgetId": { "alias": "widgetId"; "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<"high" | "low" | "medium">;
    /** 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>;
}

/**
 * The half of a widget controller that owns whether its popup is open.
 *
 * Structural rather than the controller's own type: five kinds answer this with five different
 * intent unions, and what the overlay needs from all of them is the same two members.
 */
interface MdyOverlayOwner {
    state(): {
        readonly open: boolean;
    };
    dispatch(intent: {
        readonly type: "open";
    } | {
        readonly type: "close";
    }): unknown;
}
/**
 * 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 ``anchorOverlay``.
 * - Outside click detection to close the popup.
 * - `wrapper` viewChild for position calculations.
 */
declare abstract class MdyOverlayControl<TValue> extends MdyBaseControl<TValue> {
    /**
     * Where "is this popup open" lives when nothing else owns it.
     *
     * A kind whose controller owns the state overrides the pair below and this cell is never read;
     * `select` has no controller and keeps it.
     */
    private readonly localOpen;
    /**
     * Whether the overlay is open, read from wherever this kind's state lives.
     *
     * A method rather than a `computed`, and the difference is not style. A `computed` evaluated
     * before the controller exists — which happens whenever a `name` has not yet resolved to a field
     * — would depend on nothing that ever changes again and would answer "closed" for the life of the
     * component. A method is re-read by each change detection pass, and every read inside it is
     * tracked by the caller's own reactive context, so the dependency is on the cell that actually
     * holds the answer.
     */
    /**
     * What a second element that opens the same overlay carries.
     *
     * The control's own projection minus the role: a combobox is the element that **holds the value**,
     * and an icon button beside it, or the second half of a range, opens the popup without being one.
     * Everything else is the same statement about the same overlay — the promise, whether it is open,
     * and what it controls — so it is read from the same place rather than written at each opener.
     */
    protected openerButtonPart(): MdyPartContract;
    /**
     * What an element beside the opener says about the overlay, which is nothing.
     *
     * `aria-haspopup` is a statement a textbox is allowed to make, and it is still a promise: it tells
     * a person operating that control that a popup opens from it. The catalogue names one opener per
     * kind, and for a range that opener is the toggle — the text inputs answer no key the contract
     * declares and no pointer, so the promise on them named a popup they cannot open. `aria-expanded`
     * and `aria-controls` were never theirs either: ARIA permits those on a combobox, and an input
     * carrying the whole projection is a critical `aria-allowed-attr` violation.
     */
    protected popupPromisePart(): MdyPartContract;
    protected open(): boolean;
    /**
     * The controller that owns this kind's open state, when one does.
     *
     * The widget contract owns the rule that a field leaving play closes its popup, and it expresses
     * that rule by writing the controller's own `open`. A renderer that keeps a second cell and
     * paints from it does not disobey the rule so much as never hear it: the contract's write lands
     * somewhere nothing renders. Naming the controller here is how a kind says that cell is the
     * state; a kind with no controller says nothing and keeps the local one.
     */
    protected overlayOwner(): MdyOverlayOwner | undefined;
    protected isOverlayOpen(): boolean;
    protected setOverlayOpen(open: boolean): void;
    /** Computed position of the overlay (below, above, or fixed overlay for mobile). */
    protected readonly position: _angular_core.WritableSignal<"above" | "overlay" | "below">;
    /** Computed alignment of the overlay (left, right). */
    protected readonly alignment: _angular_core.WritableSignal<"right" | "left">;
    /** 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<MdyOverlayCoords>;
    /** The anchoring decision an open overlay is holding; cleared when it closes. */
    private heldDecision;
    /**
     * 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>;
    /**
     * Who held focus before this overlay took it.
     *
     * The widget contract's rule rather than this directive's: focus is borrowed, and a move that is
     * not taken did not happen. Three kinds here used to dismiss onto `<body>` because the restore
     * aimed at an element the close had already removed, and `focus()` fails silently.
     */
    private readonly focus;
    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(): HTMLElement | DOMRect | null {
     *   return this.inputRef()?.nativeElement ?? null;
     * }
     *
     * @example
     * // Anchor to a custom area:
     * protected override overlayAnchor(): HTMLElement | DOMRect | null {
     *   return new DOMRect(x, y, width, height);
     * }
     */
    protected overlayAnchor(): HTMLElement | DOMRect | 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.
     */
    /**
     * The keys that open this kind, read from the table rather than named here.
     *
     * A control that binds one key by name answers that key and no other: this adapter's timepicker
     * opened on `ArrowDown` alone and its datepicker on nothing at all, while the same document on the
     * other two renderers opened on `Enter` — one control, different keys depending on which adapter
     * drew it. `MDY_WIDGET_KEYBOARD` already says which keys open which kind, including that a typeable
     * opener does not claim `Space`, and a binding gained upstream reaches this without an edit.
     */
    protected openOnDeclaredKey(event: KeyboardEvent): void;
    /**
     * Tab out of an open popup, which the contract says closes it.
     *
     * `MDY_WIDGET_KEYBOARD` declares `Tab@open: cancel` beside `Escape@open: cancel`, and the pair
     * differ in one thing: Escape puts the person back where they were, Tab lets them carry on
     * forward. Both close. A popup left open under Tab still has the keys, so the next Tab walks its
     * internals — a calendar cell, then the next cell — and someone who meant to leave the field is
     * inside it with no sign that the way out is a different key.
     *
     * Asked of the contract rather than listed here: a kind with an actions bar has a confirm button
     * inside its overlay that Tab has to be able to reach, and those kinds declare no such binding.
     * The key keeps its native meaning either way — the browser carries focus onward, and cancelling
     * it would strand the person in a panel being torn down.
     */
    protected closeOnDeclaredKey(event: KeyboardEvent): void;
    /**
     * A pointer on the control the table names as this kind's opener.
     *
     * `MDY_POPUP_OPENERS` says which part a person operates to open a popup, and for the two typeable
     * pickers that part is the field's own control rather than the button beside it. Answering the
     * button alone left the larger target — the box a person clicks to fill the field in — doing
     * nothing, on kinds whose contract says it opens the picker.
     *
     * Opens only. Clicking inside an open picker's input is a person putting the caret somewhere, not
     * asking for the panel to go away.
     */
    protected openFromControl(): void;
    protected toggleOverlay(event?: Event): void;
    /**
     * The widget this control draws, when it is one the catalog knows.
     *
     * Declaring it is what makes the anchoring come from `@modyra/widgets` — how much room the popup
     * wants, how wide it is and which edge it hangs from — instead of from numbers held here. A
     * control that leaves it unset keeps the defaults below.
     */
    protected readonly overlayKind: MdyWidgetKind | null;
    /** Minimum space required below or above to anchor the overlay. Default 128px. */
    /**
     * What a control falls back to when the catalogue does not know it.
     *
     * Not an override point any more. Four renderers carried their own number here — 450 three times
     * and 250 once — beside a spread of `overlayAnchoringFor` that lands *after* them and wins, so the
     * literals decided nothing and read as though they did. A number that looks authoritative and is
     * shadowed is worse than no number: the next reader changes it and nothing moves.
     */
    protected readonly minSpace: number;
    /** Preferred vertical position. Defaults to 'below'. */
    protected readonly preferredPosition: "above" | "below";
    /**
     * The popup's own size, measured when it opens and held while it stays open.
     *
     * `scrollHeight`/`scrollWidth` report what the content wants whatever `max-height` is currently
     * clamping the panel to, which is the question placement has to answer. Re-measuring on every
     * scroll frame would feed the clamped box back into the decision that clamped it.
     */
    private panelContent;
    private measurePanel;
    /**
     * Widgets owns anchoring; Angular only supplies measured geometry and applies what comes back.
     * `current` carries the decision an open overlay is already holding, so following the anchor
     * during scroll does not re-decide its side or height.
     */
    /**
     * Whether this control asks for the modal placement whatever the room.
     *
     * A presentation choice and nothing else: the value contract says what a field commits and when,
     * and where its popup sits never changes that. A control that wants it overrides this.
     */
    protected forceModalPlacement(): boolean;
    private anchorNow;
    protected openOverlay(event?: Event): void;
    private remeasureFrameId;
    private stopTracking;
    /**
     * Follows the anchor while the page moves under it, through the contract's own tracking.
     *
     * The two events are not the same question and this renderer had always known it: scrolling moves
     * the anchor and nothing else, so the overlay keeps the side and height it opened with, while a
     * viewport that changes size changes what fits and the decision is taken again.
     */
    private startTracking;
    /** Recalculates the position of the currently open overlay. */
    protected updatePosition(): void;
    /** Closes the overlay. */
    protected closeOverlay(restoreFocus?: boolean): void;
    private applyLifecycle;
    /** The writing direction the anchor is laid out in, read rather than assumed. */
    private overlayDirection;
    /**
     * Whether closing has left the user's focus with nowhere to be.
     *
     * Two shapes, and the second is the one that kept escaping earlier attempts:
     *
     * - Focus is still inside this widget's own portalled overlay, which is about to go.
     * - Focus is on an element that is **already detached**. A component that handles its own key
     *   press tears the popup down and triggers change detection before this directive is told, so by
     *   the time the lifecycle runs there is no portal left to be inside — only an orphaned
     *   `activeElement` pointing into a tree that is no longer in the document. A browser reports
     *   that as `<body>` a moment later; either way the user has lost their place.
     *
     * Focus that is connected and outside this widget belongs to whatever the user just clicked, and
     * is left alone — which is what keeps an outside click from having its focus stolen back.
     */
    private focusWasStranded;
    /**
     * Hosts may override when their trigger is not the first interactive element.
     *
     * The preference is a hint, not the answer: the custodian verifies it actually took focus and
     * falls through to whoever held it before, then into the widget. Overriding this to name a
     * better element is safe; overriding it to name a missing one no longer strands the user.
     */
    protected restoreOverlayTriggerFocus(): void;
    private unbindDismissal;
    private setupGlobalListeners;
    /**
     * Closes when focus has settled outside the widget's own branch.
     *
     * `focusin` on the document rather than `focusout` on an element: it reports where focus *landed*,
     * which is the question being asked, and it is one listener for a widget whose parts are in two
     * places. A `focusout` fires as focus leaves each of them, including on the way *into* the panel.
     *
     * A pointer outranks it. A drag begun inside the branch takes focus out on the way past, and
     * closing there would reinstate through the focus path exactly the dismissal the pointer policy
     * refuses.
     */
    private readonly handleFocusMovedAway;
    /** 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;
    /**
     * The contract's dismissal gesture, held once in `@modyra/widgets`.
     *
     * Registered on document only while the overlay is open. Naming an event here — as a single
     * `click` listener does — is a renderer deciding a rule the contract states, which is how the
     * same gesture came to mean different things in different adapters.
     */
    private readonly outsideDismissal;
    /** Escape closes the open overlay regardless of where focus is (R19). */
    private readonly handleDocumentKeydown;
    /**
     * The roots this widget's overlay interaction may land on.
     *
     * The wrapper by default. A kind with a part outside it — chips beside a search box — names that
     * element in `also`; it does not name its portal, which the contract follows out of the root
     * through the widget's own `aria-controls`.
     */
    protected overlayBranch(): MdyOverlayBranch;
    /** Runs when an interaction completes entirely outside. Overridden where closing needs more than the lifecycle. */
    protected dismissFromOutside(): void;
    /**
     * Whether an interaction that began inside the branch is still unresolved.
     *
     * The precedence between the two dismissal paths: while this is true, focus leaving must not
     * close. A subclass's blur handler consults it rather than deciding for itself.
     */
    protected interactionFromInside(): boolean;
    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>;
}

declare class MdyCheckboxComponent extends MdyBaseControl<boolean> {
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "label" | "supportingText" | "errors" | "requiredMarker" | "inputWrapper" | "control" | "errorItem" | "indicator" | "submitFalse">;
    protected readonly widgetKind = "checkbox";
    protected readonly widgetHasRootClass: boolean;
    private readonly controller;
    protected onChange(event: Event): void;
    protected onBlur(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyCheckboxComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyCheckboxComponent, "mdy-control-checkbox", never, {}, {}, never, never, true, never>;
}

declare class MdyColorsComponent extends MdyOverlayControl<string> {
    protected readonly popupClass: string;
    /** The widget this draws: its popup's room, width and edge come from the catalog. */
    protected readonly overlayKind: "colors";
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "toggle" | "label" | "supportingText" | "presets" | "errors" | "popup" | "requiredMarker" | "inputWrapper" | "control" | "inlineError" | "errorItem" | "customEntry" | "customTint" | "hexInput" | "nativePicker" | "preview" | "swatch">;
    protected readonly widgetKind: "colors";
    protected readonly widgetHasRootClass: boolean;
    protected readonly i18n: _modyra_widgets.MdyI18nMessages;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly presets: _angular_core.InputSignal<readonly (string | {
        readonly value: string;
        readonly label?: string;
    })[]>;
    /** The palette as value and name, however the document spelled each entry. */
    protected readonly palette: _angular_core.Signal<readonly {
        readonly value: string;
        readonly label: string;
    }[]>;
    /**
     * The kind's own controller, holding the handle and deciding what a colour act does.
     *
     * The transition, the write, the touch and whether the palette closes were four decisions taken
     * here; they are one dispatch. Keeping them here meant this renderer could answer differently from
     * the two that already asked the contract — and `colorValueTransition` being shared is not the same
     * as the *sequence* around it being shared, which is where a renderer drifts.
     */
    private readonly colors;
    /** The id the opener names, which the projected panel has to carry. */
    protected readonly popupId: _angular_core.Signal<string>;
    /** The relation between this widget's opener and the overlay it opens. */
    protected readonly openerPart: _angular_core.Signal<_modyra_widgets.MdyPartContract>;
    protected readonly hexInputId: _angular_core.Signal<string>;
    /**
     * Which side the palette ended up on, named by the catalog rather than spelled here.
     *
     * `above` and `overlay` are declared states of the colors `popup` part, so the class comes from
     * `popupPlacementClass` — the call every renderer makes.
     */
    protected readonly placementClass: _angular_core.Signal<string>;
    protected onBeforeOpen(): void;
    /**
     * Into the row the palette has just shown.
     *
     * The keys the contract declares for an open colour field belong to the swatches, and `Tab`
     * dismisses the palette — so a palette that left the keyboard on the toggle was one no keyboard
     * could reach the presets in. The swatch holding the current value is where a person is.
     */
    protected openOverlay(event?: Event): void;
    private readonly presetInjector;
    /** The swatch holding the value, or the first — where the keyboard lands when the row appears. */
    private landingSwatch;
    /** The swatches on the page, in the order the row draws them. */
    private presetSwatches;
    /**
     * Walking the swatches, which are a listbox and answer like one.
     *
     * The row is real buttons, so the reading position is the focus itself. The keys are the
     * catalogue's and so is the direction: a row runs in the writing direction, and reading
     * `ArrowLeft` as "back" is wrong in a right-to-left document.
     */
    protected onPresetKeydown(event: KeyboardEvent): void;
    protected onBlur(event: FocusEvent): void;
    protected onInput(event: Event): void;
    protected onHexBlur(event: FocusEvent): void;
    protected onTextInput(event: Event): void;
    /**
     * The colour picked by hand, kept while the field lives.
     *
     * A value the presets do not hold came from the chooser or from the hex box, and the panel keeps
     * it so that trying a preset and changing one's mind costs one press rather than the whole chooser
     * again — which is the behaviour a colour picker exists for.
     */
    private readonly remembered;
    protected readonly customColour: _angular_core.Signal<string | null>;
    /**
     * Opens the platform's own chooser, through the hidden native input that is already there.
     *
     * Clicked rather than focused: on some platforms the chooser is a separate window, and a panel
     * that closed when focus left would take this button with it and leave nothing to return to.
     */
    protected openPlatformChooser(): void;
    protected selectColor(color: string): void;
    protected isActiveColor(color: string): boolean;
    closeOverlay(): void;
    private applyColorIntent;
    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>;
}

declare class MdyCalendarCellComponent {
    readonly cell: _angular_core.InputSignal<CalendarCell>;
    /** The id the projection gives this cell, passed in rather than rebuilt here. */
    readonly cellId: _angular_core.InputSignal<string>;
    readonly isSelected: _angular_core.InputSignal<boolean>;
    readonly isToday: _angular_core.InputSignal<boolean>;
    readonly isFocused: _angular_core.InputSignal<boolean>;
    readonly isDisabled: _angular_core.InputSignal<boolean>;
    readonly picked: _angular_core.OutputEmitterRef<CalendarDate>;
    private readonly elementRef;
    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; }; "cellId": { "alias": "cellId"; "required": false; "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>;
}

declare class MdyCalendarGridComponent {
    readonly year: _angular_core.InputSignal<number>;
    readonly month: _angular_core.InputSignal<number>;
    /** The id this widget's opener names through `aria-controls`. */
    readonly gridId: _angular_core.InputSignal<string>;
    /** The widget these cells belong to, which is what their ids are built from. */
    readonly widgetId: _angular_core.InputSignal<string>;
    /** Whether the popup holding this grid is showing. A closed calendar draws no cells. */
    readonly showCells: _angular_core.InputSignal<boolean>;
    /**
     * The month on screen, which is what a calendar grid is called.
     *
     * The field's caption already names the dialog around it; naming the grid with the same words says
     * nothing a reader did not just hear, and says nothing about *which month they are in* — which is
     * the one thing that changes as they page. The published grid pattern names it this way, and one
     * renderer already did.
     */
    protected readonly gridName: _angular_core.Signal<string>;
    /** The id the projection gives one day cell, asked for rather than rebuilt. */
    protected dayId(iso: string): string;
    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>;
    readonly datePicked: _angular_core.OutputEmitterRef<CalendarDate>;
    private readonly cellsRef;
    focusDate(date: CalendarDate): void;
    private readonly locale;
    private readonly todayDate;
    private readonly cells;
    protected readonly rows: _angular_core.Signal<readonly (readonly CalendarCell[])[]>;
    protected readonly orderedDayNames: _angular_core.Signal<readonly string[]>;
    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; }; "gridId": { "alias": "gridId"; "required": false; "isSignal": true; }; "widgetId": { "alias": "widgetId"; "required": false; "isSignal": true; }; "showCells": { "alias": "showCells"; "required": false; "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>;
}

declare class MdyCalendarHeaderComponent {
    readonly year: _angular_core.InputSignal<number>;
    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: _modyra_widgets.MdyI18nMessages;
    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>;
}

declare class MdyCalendarComponent {
    /** Threaded to the grid so the opener can name it. */
    readonly gridId: _angular_core.InputSignal<string>;
    /** The widget these cells belong to, which is what their ids are built from. */
    readonly widgetId: _angular_core.InputSignal<string>;
    /** Whether the popup holding this calendar is showing; a closed one draws no cells. */
    readonly showCells: _angular_core.InputSignal<boolean>;
    readonly selectedDate: _angular_core.InputSignal<CalendarDate | null>;
    readonly minDate: _angular_core.InputSignal<CalendarDate | null>;
    readonly maxDate: _angular_core.InputSignal<CalendarDate | null>;
    /**
     * The controller for the kind, when there is a field behind this calendar.
     *
     * Which month is on screen, which cell has the keyboard and which of the three views is showing
     * are its answers. Without one — this component is public and mountable without a form — the same
     * questions are answered by signals, and both halves live in `calendarViewState` because the range
     * calendar needs exactly the same pair.
     */
    readonly controller: _angular_core.InputSignal<MdyDatepickerFieldController | undefined>;
    private readonly viewState;
    protected readonly view: _angular_core.Signal<"days" | "months" | "years">;
    private readonly grid;
    private readonly injector;
    constructor();
    focusFocusedDate(): void;
    readonly ariaLabel: _angular_core.InputSignal<string>;
    private readonly i18n;
    protected readonly effectiveAriaLabel: _angular_core.Signal<string>;
    readonly datePicked: _angular_core.OutputEmitterRef<CalendarDate>;
    readonly closed: _angular_core.OutputEmitterRef<void>;
    protected readonly viewYear: _angular_core.Signal<number>;
    protected readonly viewMonth: _angular_core.Signal<number>;
    protected readonly focusedDate: _angular_core.Signal<CalendarDate>;
    syncView(date: CalendarDate | null): void;
    /** Where the header goes, answered by the contract rather than by a branch here. */
    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, { "gridId": { "alias": "gridId"; "required": false; "isSignal": true; }; "widgetId": { "alias": "widgetId"; "required": false; "isSignal": true; }; "showCells": { "alias": "showCells"; "required": false; "isSignal": true; }; "selectedDate": { "alias": "selectedDate"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "controller": { "alias": "controller"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "datePicked": "datePicked"; "closed": "closed"; }, never, never, true, never>;
}

declare class MdyDatePickerComponent extends MdyOverlayControl<string | null> {
    protected readonly popupClass: string;
    /** The widget this draws: its popup's room, width and edge come from the catalog. */
    protected readonly overlayKind: "datepicker";
    /** The kind this draws, which decides the constraints it may carry and what its opener promises. */
    protected readonly widgetKind: "datepicker";
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "toggle" | "label" | "supportingText" | "errors" | "grid" | "gridcell" | "popup" | "requiredMarker" | "inputWrapper" | "control" | "inlineError" | "errorItem" | "calendar" | "dialogHeader" | "monthCell" | "monthPicker" | "row" | "weekday" | "weekdays" | "yearCell" | "yearPicker">;
    protected readonly widgetHasRootClass: boolean;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly minDate: _angular_core.InputSignal<string | null>;
    readonly maxDate: _angular_core.InputSignal<string | null>;
    /**
     * Where the popup sits: hung off the control, or covering the viewport.
     *
     * Presentation and nothing else. It used to mean "modal *and* confirm before committing", which
     * contradicted this kind's own value contract (`commit: "live"`); what a field commits is the
     * contract's answer and a placement never changes it.
     */
    readonly variant: _angular_core.InputSignal<"docked" | "modal">;
    protected forceModalPlacement(): boolean;
    readonly displayFormat: _angular_core.InputSignal<"iso" | "localized">;
    private readonly injector;
    protected readonly controller: () => _modyra_widgets.MdyDatepickerFieldController | undefined;
    /**
     * The text this control could not read, said to the form.
     *
     * The field holds a value its own rules accept — `null`, which nothing objects to — while the
     * person is looking at text the widget could not parse. Unreported, the form was told nothing was
     * wrong and the submit went out empty where they had typed something.
     *
     * Reported to the form rather than painted from the controller's state, so the entry is one of the
     * field's errors like any other and goes through the rule that says a control out of play carries
     * no verdict.
     */
    protected readonly entryReported: _angular_core.EffectRef;
    /** One committed date: the controller decides what the range and the field allow. */
    private commitDate;
    /** The id the opener names — the grid, which is what carries the overlay's role. */
    protected readonly popupId: _angular_core.Signal<string>;
    /** The relation between this widget's opener and the overlay it opens. */
    /**
     * What the opener says about the popup, naming whichever view is on screen.
     *
     * The day grid is one of three: choosing the month or the year replaces it, and an `aria-controls`
     * fixed on the grid then names an element that has been taken away. A reference that goes stale on
     * a view change is the same defect as one that was never right.
     */
    protected readonly openerPart: _angular_core.Signal<MdyPartContract>;
    /**
     * The same statement without the role, for the icon button beside the control.
     *
     * A combobox is the element that holds the value; the button that opens its popup is not one. What
     * it controls is the same answer as the control's, so it is taken from there rather than projected
     * again — projected again, it named the day grid while a year list was on screen.
     */
    protected openerButtonPart(): MdyPartContract;
    /** The controller's `open` is this kind's open state; see `MdyOverlayControl.overlayOwner`. */
    protected overlayOwner(): MdyOverlayOwner | undefined;
    protected readonly i18n: _modyra_widgets.MdyI18nMessages;
    private readonly calendarRef;
    private readonly locale;
    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 onDatePicked(date: CalendarDate): void;
    protected onInputChange(event: Event): void;
    protected onInputBlur(event: FocusEvent): void;
    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>;
}

declare class MdyDateRangePickerComponent extends MdyOverlayControl<MdyDateRange | null> {
    /**
     * The two ends, named through the id factory rather than joined by hand.
     *
     * A hand-joined `field-start` uses a separator the factory does not: every id this library
     * publishes is `scope__part`, and a consumer that knows the scope reaches a part by composing the
     * same way. Spelled with a hyphen, the id is still unique and still works — and is unreachable by
     * anybody who builds the name instead of reading it off the element.
     */
    protected readonly startId: _angular_core.Signal<string>;
    protected readonly endId: _angular_core.Signal<string>;
    protected readonly popupClass: string;
    /** The widget this draws: its popup's room, width and edge come from the catalog. */
    protected readonly overlayKind: "daterange";
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "toggle" | "label" | "supportingText" | "errors" | "grid" | "gridcell" | "popup" | "requiredMarker" | "inputWrapper" | "inlineError" | "errorItem" | "calendar" | "dialogHeader" | "monthCell" | "monthPicker" | "row" | "weekday" | "weekdays" | "yearCell" | "yearPicker" | "endControl" | "separator" | "startControl">;
    protected readonly widgetKind: "daterange";
    protected readonly widgetHasRootClass: boolean;
    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>;
    /**
     * Where the popup sits: hung off the control, or covering the viewport.
     *
     * Presentation and nothing else. It used to mean "modal *and* confirm before committing", which
     * contradicted this kind's own value contract (`commit: "live"`).
     */
    readonly variant: _angular_core.InputSignal<"docked" | "modal">;
    protected forceModalPlacement(): boolean;
    protected readonly controller: () => _modyra_widgets.MdyDaterangeFieldController | undefined;
    readonly dateFilter: _angular_core.InputSignal<((date: string) => boolean) | null>;
    /** The id the opener names, which the projected panel has to carry. */
    protected readonly popupId: _angular_core.Signal<string>;
    /** The relation between this widget's opener and the overlay it opens. */
    protected readonly openerPart: _angular_core.Signal<_modyra_widgets.MdyPartContract>;
    protected readonly lastFocused: _angular_core.WritableSignal<"start" | "end">;
    private readonly calendarRef;
    private readonly locale;
    private readonly injector;
    protected readonly i18n: _modyra_widgets.MdyI18nMessages;
    /**
     * What the second of the two boxes is called, read from the contract rather than composed here.
     *
     * The caption points `for` at the first — a range's caption belongs to where the range starts — so
     * nothing claims the second, and what it is called was this renderer's own decision. It built the
     * caption, an em dash and an English-shaped phrase around a translated word, which is a sentence no
     * table holds and no translation reaches as a whole.
     */
    protected readonly endControlName: _angular_core.Signal<string>;
    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>;
    protected onBeforeOpen(): void;
    /**
     * Told to the controller, which is where closing-without-choosing is recorded as an act on the
     * value. Closing through the overlay directive alone left this kind answering a question its
     * siblings answer through the contract. ADR 0167.
     */
    closeOverlay(): void;
    protected onRangePicked(range: {
        readonly start: CalendarDate;
        readonly end: CalendarDate;
    }): void;
    protected onEndpointInput(event: Event, endpoint: "start" | "end"): void;
    protected onEndpointBlur(event: FocusEvent, endpoint: "start" | "end"): void;
    private commitRange;
    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>;
}

declare class MdyRangeCalendarGridComponent {
    /** The widget these cells belong to, which is what their ids are built from. */
    readonly widgetId: _angular_core.InputSignal<string>;
    /** Whether the popup holding this grid is showing. A closed calendar draws no cells. */
    readonly showCells: _angular_core.InputSignal<boolean>;
    /**
     * The month on screen, which is what a calendar grid is called.
     *
     * The field's caption already names the dialog around it; naming the grid with the same words says
     * nothing a reader did not just hear, and says nothing about *which month they are in* — which is
     * the one thing that changes as they page. The published grid pattern names it this way, and one
     * renderer already did.
     */
    protected readonly gridName: _angular_core.Signal<string>;
    /** The id the projection gives one day cell, asked for rather than rebuilt. */
    protected dayId(iso: string): string;
    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>;
    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>;
    readonly datePicked: _angular_core.OutputEmitterRef<CalendarDate>;
    readonly dateHovered: _angular_core.OutputEmitterRef<CalendarDate>;
    private readonly cellBtns;
    focusDate(date: CalendarDate): void;
    private readonly locale;
    private readonly todayDate;
    private readonly cells;
    protected readonly rows: _angular_core.Signal<readonly (readonly CalendarCell[])[]>;
    protected readonly orderedDayNames: _angular_core.Signal<readonly string[]>;
    protected readonly orderedDayNamesShort: _angular_core.Signal<readonly string[]>;
    private readonly effectiveRange;
    protected isCellToday(cell: CalendarCell): boolean;
    protected isCellFocused(cell: CalendarCell): boolean;
    protected isCellDisabled(cell: CalendarCell): boolean;
    protected isCellRangeEndpoint(cell: CalendarCell): boolean;
    protected isCellRangeStart(cell: CalendarCell): boolean;
    protected isCellRangeEnd(cell: CalendarCell): boolean;
    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, { "widgetId": { "alias": "widgetId"; "required": false; "isSignal": true; }; "showCells": { "alias": "showCells"; "required": false; "isSignal": true; }; "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 RangePhase = "pick-start" | "pick-end";
declare class MdyRangeCalendarComponent {
    /**
     * The controller for the kind, when there is a field behind this calendar.
     *
     * What a range means — which pick opens it, which closes it, which cells fall between, what the
     * bounds refuse — is its answer. The signals below are the standalone case: this component is
     * public and mountable without a form, and that caller has no controller to ask.
     */
    /** The widget these cells belong to, which is what their ids are built from. */
    readonly widgetId: _angular_core.InputSignal<string>;
    /** Whether the popup holding this calendar is showing; a closed one draws no cells. */
    readonly showCells: _angular_core.InputSignal<boolean>;
    readonly controller: _angular_core.InputSignal<MdyDaterangeFieldController | undefined>;
    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>;
    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;
    private readonly viewState;
    protected readonly view: _angular_core.Signal<"days" | "months" | "years">;
    protected readonly viewYear: _angular_core.Signal<number>;
    protected readonly viewMonth: _angular_core.Signal<number>;
    protected readonly focusedDate: _angular_core.Signal<CalendarDate>;
    private readonly _hoverDate;
    protected readonly hoverDate: _angular_core.Signal<CalendarDate | null>;
    private readonly _phase;
    private readonly _pendingStart;
    private readonly _pendingEnd;
    protected readonly phase: _angular_core.Signal<RangePhase>;
    protected readonly pendingStart: _angular_core.Signal<CalendarDate | null>;
    protected readonly pendingEnd: _angular_core.Signal<CalendarDate | null>;
    protected readonly phaseHint: _angular_core.Signal<string>;
    syncView(start: CalendarDate | null, end: CalendarDate | null): void;
    /** Where the header goes, answered by the contract rather than by a branch here. */
    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, { "widgetId": { "alias": "widgetId"; "required": false; "isSignal": true; }; "showCells": { "alias": "showCells"; "required": false; "isSignal": true; }; "controller": { "alias": "controller"; "required": false; "isSignal": true; }; "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>;
}

declare class MdyFileComponent extends MdyBaseControl<readonly File[] | null> {
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "label" | "supportingText" | "errors" | "requiredMarker" | "control" | "errorItem" | "content" | "clear" | "dropzone" | "fileItem" | "fileList" | "rejected">;
    protected readonly widgetKind: "file";
    protected readonly widgetHasRootClass: boolean;
    /**
     * Whether the picker may be operated at all.
     *
     * A read-only file field has no word of its own — the contract declares no read-only state for
     * this kind, because the picker is the browser's and the element's role has no `aria-readonly` to
     * carry. What is expressible is that the affordance is not operable, and the field itself stays in
     * play: focusable, submitted, validated. The other two renderers already say it this way.
     */
    protected readonly cannotPick: _angular_core.Signal<boolean>;
    readonly accept: _angular_core.InputSignal<string>;
    readonly multiple: _angular_core.InputSignal<boolean>;
    readonly maxFileSize: _angular_core.InputSignal<number>;
    readonly maxFiles: _angular_core.InputSignal<number>;
    readonly fileSelected: _angular_core.OutputEmitterRef<readonly File[] | null>;
    readonly filesRejected: _angular_core.OutputEmitterRef<readonly File[]>;
    /**
     * The kind's own controller, holding the handle and deciding what a pick does.
     *
     * The rule for which candidates are taken is shared already; the sequence around it was not — what
     * gets written, whether the field is marked, what the value becomes when it is cleared. This
     * renderer answered the last one with `null` where the contract answers `[]`, on a field declared
     * as a list, so a host reading it got a shape the type does not allow.
     */
    private readonly files;
    /** What the field holds, and what its last pick turned away — a list either way. */
    protected readonly chosen: _angular_core.Signal<readonly File[]>;
    protected readonly rejectedNames: _angular_core.WritableSignal<readonly string[]>;
    protected readonly i18n: _modyra_widgets.MdyI18nMessages;
    protected readonly dragOver: _angular_core.WritableSignal<boolean>;
    private readonly fileInput;
    protected onFileChange(event: Event): void;
    protected onDragOver(event: DragEvent): void;
    protected onDrop(event: DragEvent): void;
    protected clear(): void;
    private processFiles;
    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>;
}

declare abstract class MdyDropdownBase<TValue, TOptionValue = unknown> extends MdyOptionsOverlayControl<TValue, TOptionValue> implements MdyOptionsControl<TOptionValue> {
    protected readonly i18n: _modyra_widgets.MdyI18nMessages;
    protected readonly injector: Injector;
    readonly selectionChange: _angular_core.OutputEmitterRef<MdySelectOption<TOptionValue>>;
    protected readonly optionTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
    abstract resetSelection(): void;
    protected optionKey(value: TOptionValue): string;
    protected optionFor(value: unknown): MdySelectOption<TOptionValue> | undefined;
    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>;
}

declare class MdyMultiselectComponent<TValue = string> extends MdyDropdownBase<ReadonlyArray<TValue>, TValue> implements MdyOptionsControl<TValue> {
    protected readonly popupClass: string;
    /** The chip vocabulary, so no class for one is spelled in this template. */
    /** Whether a person may rearrange what they chose. Off by default: most lists have an order nobody chose. */
    readonly reorderable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** What the option grid announces itself as — the contract's answer, not this renderer's. */
    protected readonly optionsRole: string | null;
    /** The strip is a list and a chip is an item of it — the catalogue's answer, not this file's. */
    /** The parts, so a template asks the contract for a role rather than holding one field per part. */
    protected readonly parts: Readonly<Record<"root" | "loading" | "placeholder" | "label" | "supportingText" | "options" | "option" | "errors" | "popup" | "requiredMarker" | "inputWrapper" | "inlineError" | "errorItem" | "optionLabel" | "optionCheck" | "arrow" | "empty" | "search" | "trigger" | "announcement" | "box" | "chip" | "chipMove" | "chipRemove" | "chipRow" | "chipTooltip" | "chips" | "clearAll" | "optionCount" | "optionStep" | "optionWrapper" | "overflowCount" | "wayBackAction", MdyPartContract>>;
    protected readonly chipRole: string | null;
    protected readonly chip: Readonly<{
        block: "mdy-chip";
        centered: "mdy-chip--centered";
        counter: "mdy-chip--counter";
        value: "mdy-chip--value";
        selected: "mdy-chip--selected";
        removable: "mdy-chip--removable";
        check: "mdy-chip__check";
        label: "mdy-chip__label";
        count: "mdy-chip__count";
        step: "mdy-chip__btn";
        remove: "mdy-chip__remove";
        move: "mdy-chip__move";
        wrapper: "mdy-chip-wrapper";
    }>;
    /** The widget this draws: its popup's room, width and edge come from the catalog. */
    protected readonly overlayKind: "multiselect";
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "loading" | "placeholder" | "label" | "supportingText" | "options" | "option" | "errors" | "popup" | "requiredMarker" | "inputWrapper" | "inlineError" | "errorItem" | "optionLabel" | "optionCheck" | "arrow" | "empty" | "search" | "trigger" | "announcement" | "box" | "chip" | "chipMove" | "chipRemove" | "chipRow" | "chipTooltip" | "chips" | "clearAll" | "optionCount" | "optionStep" | "optionWrapper" | "overflowCount" | "wayBackAction">;
    protected readonly widgetKind: "multiselect";
    protected readonly widgetHasRootClass: boolean;
    readonly mode: _angular_core.InputSignal<MdyMultiselectMode>;
    readonly filterFn: _angular_core.InputSignal<((value: TValue) => boolean) | undefined>;
    private readonly controller;
    /** The id the opener names, which the projected panel has to carry. */
    protected readonly chipTooltipId: _angular_core.Signal<string>;
    /**
     * The caption's id, which names the trigger where a document wrote a caption.
     *
     * Computed rather than captured: `fieldId` is settled by the host after construction, and a field
     * initializer spells the id the component had before it was given one.
     *
     * One name, never two: with a caption the trigger points at it, without one it says the words it
     * can reach. A control carrying both says only the reference. ADR 0175.
     */
    protected readonly labelId: _angular_core.Signal<string>;
    protected readonly popupId: _angular_core.Signal<string>;
    /** The relation between this widget's opener and the overlay it opens. */
    protected readonly openerPart: _angular_core.Signal<MdyPartContract>;
    /**
     * What this control paints: the declared options, plus every held value they do not contain. Read
     * from here rather than from the controller's state, which is built out of this list.
     */
    protected readonly paintedOptions: _angular_core.Signal<readonly _modyra_core.MdySelectOption<TValue>[]>;
    protected readonly filteredOptions: _angular_core.Signal<readonly _modyra_core.MdySelectOption<TValue>[]>;
    protected readonly searchResults: _angular_core.Signal<readonly _modyra_core.MdySelectOption<TValue>[]>;
    private readonly overlayInputRef;
    /**
     * Where the keyboard is in the open list — the controller's, given rather than held.
     *
     * This component kept its own index and moved it *before* asking what to take, so one ArrowDown
     * landed on the second option. A cursor is state the contract owns, and it is the third piece of
     * state this component kept a second copy of.
     */
    protected readonly activeOverlayKey: _angular_core.Signal<string | null>;
    protected onOverlayKeydown(event: KeyboardEvent): void;
    protected readonly counts: _angular_core.Signal<ReadonlyMap<string, number>>;
    protected readonly selectedSet: _angular_core.Signal<ReadonlySet<string>>;
    /** The controller's `open` is this kind's open state; see `MdyOverlayControl.overlayOwner`. */
    protected overlayOwner(): MdyOverlayOwner | undefined;
    protected onBeforeOpen(): void;
    /** The chips and the search box sit outside the wrapper, so the whole host is the boundary. */
    protected overlayBranch(): MdyOverlayBranch;
    /** Closing here also clears the search query, which `applyLifecycle` alone does not do. */
    protected dismissFromOutside(): void;
    /**
     * One selection change, decided by the controller for this kind. This renderer contributes only
     * the matched option, which is Angular's own output and nothing the contract knows about.
     */
    private commitMultiselect;
    /**
     * The classes a chip carries: the primitive, the variant its mode implies, and its state.
     *
     * `multiselectChipClasses` in @modyra/widgets answers this for every renderer, so a chip drawn
     * here and a chip drawn by another adapter are the same chip — and the foundation's variants stay
     * the only place that decides what one looks like.
     */
    protected chipClasses(selected: boolean): string;
    /**
     * The classes a chip in the field carries, which is a different chip from one in the list.
     *
     * A chip holding what was chosen is the value; a chip in the popup is an option. The catalogue
     * declares `chip` as the value chip and spells it `mdy-chip mdy-chip--value`, and this renderer
     * asked for the option appearance in both places — so a theme keying on the declared class styled
     * the renderers that emit it and silently skipped this one.
     */
    /** What the button that takes this chip off is called: the verb and the value it would remove. */
    /**
     * What a button inside a chip is called: the verb and the value it would act on.
     *
     * Every button, not only the one that removes. Read from the accessibility tree, a two-chip strip
     * offered four steppers called "One fewer" and "One more" beside two that named their value — and
     * stepping down from one is what removes it.
     */
    protected actionName(verb: string, label: string): string;
    protected valueChipClasses(): string;
    protected isSelected(optValue: TValue): boolean;
    /** How many chips the strip is hiding, measured from what the browser actually laid out. */
    protected readonly hiddenChips: _angular_core.WritableSignal<number>;
    /** The id the projection gives the option grid. */
    protected readonly optionsGridId: _angular_core.Signal<string | null>;
    /** The way to the chips the strip cannot show: the list, where every one of them is. */
    /**
     * A press on the field's own empty space, which opens the list.
     *
     * Focus goes to the opener before the list opens, not after: the opener is what carries the
     * expanded state and answers the keyboard, and a list opened with focus left on the document is
     * one the arrows cannot reach.
     */
    protected onBoxPress(event: Event): void;
    protected onOverflowPress(event: Event): void;
    /**
     * Counts what the strip is hiding, after the render that drew it.
     *
     * How many fit depends on the labels, the theme's spacing and the width the host gave the field,
     * so this is a measurement and not a derivation from the number chosen.
     */
    protected readonly measureOverflow: _angular_core.EffectRef;
    /** Every choice off at once. The press must not reach the trigger behind it and reopen the popup. */
    protected onClearAll(event: Event): void;
    /** The one way back: it puts back what the last destructive act took, whichever act that was. */
    /**
     * Puts the value back and leaves the reading position on what came back.
     *
     * The offer is withdrawn by using it, so whatever held focus is gone from the page the moment it
     * works — and a reading position on nothing sends a keyboard back to the top of the document. The
     * value restored is where a person is looking, so it is where they are put; a restore with nothing
     * to land on falls back to the opener, which is the field itself.
     */
    protected onWayBack(): void;
    /**
     * The way back, from wherever the person is standing in the field.
     *
     * Answered from the field rather than from the button that offers it: a removal leaves the reading
     * position among the chips, and a shortcut reachable only from the control at the far edge is a
     * shortcut for somebody who has already walked there.
     *
     * Not while a person is typing. Inside a text box the same gesture is the platform's own undo of
     * what they have just written, and taking it would put a value back and lose a word.
     */
    protected onUndoGesture(event: KeyboardEvent): void;
    protected onToggle(optValue: TValue): void;
    /**
     * What was chosen, one entry per distinct value with how many of it.
     *
     * Read from the value rather than from the option list, and never from the *filtered* one: the
     * order the strip shows is the order the value has, and a strip reading what a search matches
     * would empty itself as somebody typed.
     */
    protected readonly chosen: _angular_core.Signal<{
        key: string;
        value: TValue;
        label: string;
        count: number;
    }[]>;
    /**
     * The chip keys in strip order — the contract's answer, not a second reading of the tally.
     *
     * `chosen` above carries labels and counts for painting; this is the sequence a move, a drag and a
     * removal index into. Both are the same order, and taking it from the controller is what keeps
     * them one order rather than two that happen to agree.
     */
    protected readonly chipOrder: _angular_core.Signal<readonly string[]>;
    /**
     * Rearranging what was chosen, from the chip a person is looking at.
     *
     * The keys are the contract's, and so is the direction: the strip runs in the writing direction,
     * so `ArrowLeft` moves a chip *later* in a right-to-left document, and a renderer reading the key
     * rather than the binding would have to know that.
     */
    /**
     * The chip a person is carrying, and where they picked it up from.
     *
     * `from` is what `Escape` puts back: somebody who picks up the wrong chip has to be able to
     * abandon the move rather than undo it afterwards.
     */
    private grabbed;
    /** The label a chip shows, for a sentence about it. */
    private chipLabelOf;
    protected onChipKeydown(event: KeyboardEvent, optionKey: string): void;
    /**
     * Dragging a chip to a new place — the door the brief named, on the same intent as the other two.
     *
     * A threshold before it becomes a drag: a press that never travels is a press, and treating every
     * one as the beginning of a drag takes the chip's own controls away from anybody whose finger
     * moves a pixel. `pointercancel` puts it back untouched.
     */
    protected startChipDrag(event: PointerEvent, optionKey: string): void;
    /**
     * Puts DOM focus on the option the cursor is on, where there is no filter box to name it.
     *
     * With a search box the cursor is announced through `aria-activedescendant` and focus stays where
     * a person is typing. Without one there is no element to carry that reference.
     */
    /**
     * Which option the cursor is on, named from wherever focus actually is.
     *
     * Focus stays on the control while the list is open here, so the cursor has no element of its own
     * to be announced from: without this it moves and nothing says so.
     */
    /**
     * The id the projection gives one option, put on the element that draws it.
     *
     * `aria-activedescendant` names an element, and the cursor pointed at an id nothing carried: the
     * control said where the keyboard was and no such element existed, so type-ahead moved a cursor
     * that could not be announced.
     */
    /**
     * Everything the contract says about one option in the list: its id, the chip classes its mode
     * and state imply, and whether it is available.
     *
     * Taken whole rather than rebuilt from three bindings. The classes and the id were being spelled
     * here while the projection already held them — and the part of it nothing spelled was
     * `aria-disabled` and the native `disabled`, so an option a document had closed was drawn exactly
     * like one that could be chosen. The press was refused and nothing said why.
     */
    protected optionPart(value: TValue): MdyPartContract;
    protected optionDomId(value: TValue): string | null;
    protected readonly activeDescendant: _angular_core.Signal<string | null>;
    private followCursor;
    /** How many are chosen, for the field's own description. */
    /**
     * This kind describes itself by more than its supporting text.
     *
     * The base withholds the description's id unless a consumer gave the field words, and a multiselect
     * writes its own — how many are chosen — into the same element. So the sentence was on the page and
     * nothing named it: a person who cannot see the chips was told the field's name and nothing about
     * what it holds, while the text saying so sat one element away.
     */
    protected descriptionId(fieldId: string): string | null;
    /** The strip's wheel behaviour is the contract's; see `scrollChipStripByWheel`. */
    protected readonly onStripWheel: typeof scrollChipStripByWheel;
    /**
     * The pointer's way to move a chip, which is not a drag.
     *
     * WCAG 2.5.7 asks for a single-pointer path independently of the keyboard's: somebody who cannot
     * hold and drag has no way to reorder otherwise, and Alt plus the arrows does not discharge it.
     */
    protected moveByPointer(optionKey: string, by: -1 | 1): void;
    /**
     * Which chip carries the strip's single tab stop.
     *
     * A roving index: one stop for the whole strip. One stop per chip made the cost of tabbing past
     * the field grow with what it holds — twelve chosen values were twenty-six presses.
     */
    protected readonly activeChipKey: _angular_core.WritableSignal<string | null>;
    protected readonly activeChip: _angular_core.Signal<string | null>;
    private focusChip;
    /**
     * Takes a value off and puts focus where the contract says it goes.
     *
     * Left to the browser, focus lands on whatever now occupies that position — the next chip while
     * one exists, and the document at the end of the strip.
     */
    protected removeChip(optionKey: string, value: TValue, direction?: "forward" | "backward"): void;
    /**
     * The change, not the list, and nothing while the popup is open.
     *
     * Seeded from what the field already holds, because a value that arrived with the form is not
     * something the person just did.
     */
    private saidLast;
    /** A sentence to say once, for a change no selection delta describes — a move. */
    private saySoon;
    /**
     * A sentence about a grab, which no change of value follows.
     *
     * Picking a chip up and putting it down move nothing, so the computed below would not run again
     * and the sentence would sit unsaid until some unrelated change. Writable, so saying it is itself
     * the change.
     */
    private readonly grabSaid;
    /** The last destructive act, or `null` when there is nothing to go back to. */
    protected readonly wayBack: _angular_core.Signal<_modyra_widgets.MdyMultiselectWayBack | null>;
    /** What the way back is called: the act named, because one reversal covers three. */
    protected readonly wayBackName: _angular_core.Signal<string>;
    /** Which chip is being named, and where its tooltip sits in the control's own coordinates. */
    protected readonly namedChip: _angular_core.WritableSignal<string | null>;
    protected readonly chipTipAt: _angular_core.WritableSignal<number>;
    protected readonly namedChipLabel: _angular_core.Signal<string>;
    protected revealChipName(event: Event, key: string): void;
    /**
     * A focused chip is brought back into the strip, after the paint that may have narrowed it.
     *
     * The browser scrolls a focused element in once, at the moment focus lands; an affordance that
     * appears on the same beat takes its width out of the scrollport afterwards. A focused chip nobody
     * can see is a keyboard trap.
     */
    protected onChipFocused(): void;
    protected hideChipName(): void;
    protected readonly announcementText: _angular_core.Signal<string>;
    /** The words behind one option key, for a value that may no longer be held. */
    private labelOfKey;
    /**
     * The words a chosen value is shown by, falling back to its key for one the options lost.
     *
     * The key rather than `String(value)`: every plain object renders as `[object Object]` through it,
     * so a value whose option went away was labelled with a name that says nothing about what was
     * chosen. The key at least describes what the value holds.
     */
    private labelOf;
    protected countOf(optValue: TValue): number;
    protected increment(optValue: TValue): void;
    protected decrement(optValue: TValue): void;
    /**
     * The quantity, said once the pressing stops.
     *
     * A held arrow steps many times, and a region read on every step reads a backlog out after the
     * person has let go. Nothing is said for a quantity that reached zero: the value is gone, and the
     * removal has its own sentence and its own way back.
     */
    private readonly quantityVoice;
    private sayQuantity;
    /** The settled quantity sentence, which the live region shows until something replaces it. */
    protected readonly saidQuantity: _angular_core.WritableSignal<string>;
    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, { "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MdyNumberComponent extends MdyBaseControl<number | null> {
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "label" | "supportingText" | "errors" | "requiredMarker" | "inputWrapper" | "control" | "inlineError" | "errorItem" | "decrement" | "increment">;
    protected readonly widgetKind = "number";
    protected readonly widgetHasRootClass: boolean;
    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 | null>;
    /**
     * Whether this field draws the two steppers the catalogue declares for it.
     *
     * On by default, because the parts are the kind's anatomy: they carry `mdy-spin-btn`, the themes
     * paint them, and the native control's own arrows are suppressed by the foundation — so a field
     * that draws neither has no stepping affordance at all where the other renderers of this kind
     * have one. A consumer that wants the box alone turns them off.
     */
    readonly showSpinButtons: _angular_core.InputSignal<boolean>;
    /**
     * What this control asks for on top of the field's rules. It can only narrow: the projection takes
     * whichever end is tighter, so a control cannot offer a value the rules would refuse.
     */
    protected narrowedConstraints(): Partial<MdyFieldConstraints>;
    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>;
}

declare class MdyRadioGroupComponent<TValue = unknown> extends MdyBaseControl<TValue | null> {
    /**
     * The group's label, named through the id factory rather than joined by hand.
     *
     * Every id this library publishes is `scope__part`, and a consumer that knows the scope composes
     * a part name the same way. A hyphen still yields a unique id and still works — and is unreachable
     * by anybody who builds the name instead of reading it off the element.
     */
    protected readonly labelId: string;
    /**
     * Which attribute names the group, asked of the contract rather than answered here.
     *
     * Two names on one element is not two names: the computation takes `aria-labelledby` and stops, so
     * an `aria-label` beside it is text nobody hears. Spelled out per template, the pair is what gets
     * written by accident — and what three renderers each answered separately. ADR 0175.
     */
    protected readonly namedBy: _angular_core.Signal<Readonly<Record<string, string | null>>>;
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "label" | "supportingText" | "group" | "option" | "errors" | "requiredMarker" | "errorItem" | "optionControl" | "optionLabel">;
    protected readonly widgetKind: "radio";
    protected readonly widgetHasRootClass: boolean;
    readonly options: _angular_core.InputSignal<readonly MdySelectOption<TValue>[]>;
    readonly layout: _angular_core.InputSignal<"horizontal" | "vertical">;
    private readonly controller;
    protected onSelectionChange(value: TValue): void;
    protected onBlur(): 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>;
}

declare class MdySegmentedButtonComponent<TValue = unknown> extends MdyBaseControl<TValue | null> {
    /**
     * The group's label, named through the id factory rather than joined by hand.
     *
     * Every id this library publishes is `scope__part`, and a consumer that knows the scope composes
     * a part name the same way. A hyphen still yields a unique id and still works — and is unreachable
     * by anybody who builds the name instead of reading it off the element.
     */
    protected readonly labelId: string;
    /**
     * Which attribute names the group, asked of the contract rather than answered here.
     *
     * Two names on one element is not two names: the computation takes `aria-labelledby` and stops, so
     * an `aria-label` beside it is text nobody hears. Spelled out per template, the pair is what gets
     * written by accident — and what three renderers each answered separately. ADR 0175.
     */
    protected readonly namedBy: _angular_core.Signal<Readonly<Record<string, string | null>>>;
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "label" | "supportingText" | "group" | "option" | "errors" | "requiredMarker" | "errorItem" | "optionControl" | "optionCheck" | "optionText">;
    protected readonly widgetKind: "segmented";
    protected readonly widgetHasRootClass: boolean;
    readonly options: _angular_core.InputSignal<readonly MdySelectOption<TValue>[]>;
    readonly fullWidth: InputSignalWithTransform<boolean, unknown>;
    private readonly controller;
    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;
    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>;
}

declare class MdySelectComponent<TValue = string> extends MdyDropdownBase<TValue | null, TValue> implements MdyOptionsControl<TValue> {
    protected readonly popupClass: string;
    /** The widget this draws: its popup's room, width and edge come from the catalog. */
    protected readonly overlayKind: "select";
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "value" | "loading" | "placeholder" | "label" | "supportingText" | "options" | "option" | "errors" | "popup" | "requiredMarker" | "inputWrapper" | "inlineError" | "errorItem" | "arrow" | "empty" | "search" | "trigger">;
    protected readonly widgetKind: "select";
    protected readonly widgetHasRootClass: boolean;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly allowCreate: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly optionCreated: _angular_core.OutputEmitterRef<string>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly runtime;
    /**
     * Built on the first read rather than in the constructor, because it is built *on a handle* and a
     * `name` form has none until the registry resolves it. A renderer that latched before the handle
     * arrived cached nothing for the life of the component and every later interaction went nowhere.
     */
    private readonly selectAdapter;
    private readonly parkedValue;
    /**
     * What this select renders: its options, plus the value the model holds when the list does not
     * contain it. The value is not erased to make the widget consistent, so it has to be visible —
     * otherwise the control looks empty while the form holds something, and a validation message
     * refers to a value nobody can see.
     */
    protected readonly renderedOptions: _angular_core.Signal<readonly MdySelectOption<TValue>[]>;
    constructor();
    /** The id the opener names — the listbox, which is what carries the overlay's role. */
    protected readonly popupId: _angular_core.Signal<string>;
    /**
     * The ids the contract publishes, rather than a scheme of this renderer's own.
     *
     * A published id is `<widget>__<part>__<key>`, and the controller's view already spells every one
     * of them — including the key's escaping, which changed under a changeset and a `contract:diff`
     * classification. This renderer minted `pick-opt-0` from the option's *position*, so a consumer
     * reading the published format and writing a selector reached two renderers and missed this one,
     * and an id moved when the list was filtered rather than naming the same option throughout.
     */
    protected triggerId(): string;
    protected optionId(option: MdySelectOption<TValue>): string;
    protected activeOptionId(): string | null;
    /** The relation between this widget's opener and the overlay it opens. */
    protected readonly openerPart: _angular_core.Signal<_modyra_widgets.MdyPartContract>;
    protected readonly dropUp: _angular_core.Signal<boolean>;
    /**
     * Which side the list ended up on, named by the catalog rather than spelled here.
     *
     * `above` and `overlay` are declared states of the select's `popup` part, so the class comes from
     * `popupPlacementClass` — the call every renderer makes. `right` is a declared state too, and
     * the binding below still spells it: deriving it here means threading the alignment through the
     * same call, which is a change to that helper rather than to this component.
     */
    /**
     * Where the popup ended up, both halves from the contract.
     *
     * Both halves are asked for rather than spelled. Writing `mdy-select__dropdown--right` by hand
     * would duplicate the catalog's own spelling — correct and unauditable at the same time, since
     * nothing then connects the class to the contract that declares it.
     */
    protected readonly placementClass: _angular_core.Signal<string>;
    protected readonly overlayMode: _angular_core.Signal<boolean>;
    protected readonly activeIndex: _angular_core.Signal<number>;
    protected readonly selectedOption: _angular_core.Signal<MdySelectOption<TValue> | null>;
    protected readonly filteredOptions: _angular_core.Signal<readonly MdySelectOption<TValue>[]>;
    protected readonly showCreateOption: _angular_core.Signal<boolean>;
    protected onCreateOption(): void;
    private readonly searchInputRef;
    protected openOverlay(event?: Event): void;
    closeOverlay(): void;
    protected onBeforeOpen(): void;
    protected selectOption(opt: MdySelectOption<TValue>): void;
    /**
     * Focus leaving the widget closes it — `capabilities.dismissOnFocusOutside`.
     *
     * It never outranks a pointer. A drag that began inside the popup moves focus out of it on the
     * way, and closing there would reinstate, through the focus path, exactly the dismissal
     * `dismissOnOutsidePointer` refuses. `touched` still marks: the user has been here either way.
     */
    protected onBlur(event: FocusEvent): void;
    /**
     * The typeahead, held per component rather than per keystroke.
     *
     * A buffer rebuilt each key is not a buffer: this is what accumulates a word across events, and
     * what its idle timeout expires when the user stops.
     */
    private readonly typeahead;
    protected onKeydown(event: KeyboardEvent): void;
    protected onSearchInput(event: Event): void;
    resetSelection(): void;
    /**
     * Whether a held value is this option's, asked the way the contract asks it.
     *
     * `==` is identity for an object, so a fresh one from a restored draft or a refetch matched no
     * option and the control showed nothing chosen while the model held a value. The key answers both:
     * the same object, and a copy carrying the same data.
     */
    protected isChosen(optionValue: TValue): boolean;
    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>;
}

declare class MdySliderComponent extends MdyBaseControl<number> {
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "value" | "label" | "supportingText" | "errors" | "requiredMarker" | "control" | "inlineError" | "errorItem" | "track">;
    protected readonly widgetKind: "slider";
    protected readonly widgetHasRootClass: boolean;
    /**
     * The ends of the track. Left unset they are the field's own rules, and where those say nothing
     * either, what a bare `<input type="range">` assumes — a slider has to span something to be drawn.
     */
    readonly min: _angular_core.InputSignal<number | null>;
    readonly max: _angular_core.InputSignal<number | null>;
    protected readonly effectiveMin: _angular_core.Signal<number>;
    protected readonly effectiveMax: _angular_core.Signal<number>;
    readonly step: _angular_core.InputSignal<number>;
    /**
     * What this control offers of the track, which can only ever be less than the rules allow.
     *
     * Stated once, here, rather than as `min`/`max`/`step` on the input: the projection places those
     * attributes, and a template writing them too means two answers whose order decides which one the
     * user gets.
     */
    protected narrowedConstraints(): Partial<MdyFieldConstraints>;
    readonly showValue: _angular_core.InputSignal<boolean>;
    private readonly rangeInput;
    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>;
}

declare class MdyTextComponent extends MdyBaseControl<string> implements OnInit {
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "label" | "supportingText" | "prefix" | "suffix" | "errors" | "requiredMarker" | "inputWrapper" | "control" | "inlineError" | "errorItem">;
    protected readonly widgetKind = "text";
    protected readonly widgetHasRootClass: boolean;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly type: _angular_core.InputSignal<string>;
    readonly autocomplete: _angular_core.InputSignal<string | null>;
    private fieldController?;
    private readonly destroyRef;
    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>;
}

declare class MdyTextareaComponent extends MdyBaseControl<string | null> {
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "label" | "supportingText" | "errors" | "requiredMarker" | "inputWrapper" | "control" | "inlineError" | "errorItem">;
    protected readonly widgetKind = "textarea";
    protected readonly widgetHasRootClass: boolean;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly rows: _angular_core.InputSignal<number>;
    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>;
}

declare class MdyToggleComponent extends MdyBaseControl<boolean> {
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "label" | "supportingText" | "errors" | "requiredMarker" | "inputWrapper" | "control" | "inlineError" | "errorItem" | "track" | "submitFalse" | "thumb">;
    protected readonly widgetKind = "toggle";
    protected readonly widgetHasRootClass: boolean;
    private readonly controller;
    protected onChange(event: Event): void;
    protected onBlur(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MdyToggleComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MdyToggleComponent, "mdy-control-toggle", never, {}, {}, never, never, true, never>;
}

declare class MdyTimepickerComponent extends MdyOverlayControl<string | null> {
    protected readonly popupClass: string;
    /** The widget this draws: its popup's room, width and edge come from the catalog. */
    protected readonly overlayKind: "timepicker";
    protected readonly widgetContract: _modyra_widgets.MdyWidgetDefinition<"root" | "toggle" | "label" | "supportingText" | "errors" | "dialog" | "container" | "popup" | "requiredMarker" | "inputWrapper" | "control" | "inlineError" | "errorItem" | "action" | "actions" | "clock" | "content" | "dialFace" | "dialHand" | "dialNumber" | "dialUnavailable" | "dialUnavailableArc" | "header" | "hour" | "hourControl" | "minute" | "minuteControl" | "modeToggle" | "period" | "periodOption">;
    protected readonly widgetKind: "timepicker";
    protected readonly widgetHasRootClass: boolean;
    protected readonly i18n: _modyra_widgets.MdyI18nMessages;
    readonly placeholder: _angular_core.InputSignal<string>;
    /**
     * Which clock this draws — the contract's default, not this component's. Pass `"12h"` for the
     * other; a default that differs between adapters renders one document two ways.
     */
    readonly format: _angular_core.InputSignal<MdyTimeFormat>;
    /** Which view the picker opens in, and returns to on close — the view the field has. */
    readonly viewMode: _angular_core.InputSignal<MdyTimepickerViewMode$1>;
    /**
     * Which times this field offers. Absent offers every one.
     *
     * The controller is told once, at construction, so a granularity that changes after the fact does
     * not silently rebuild the draft the user is editing.
     */
    readonly granularity: _angular_core.InputSignal<MdyTimeGranularity | undefined>;
    /** Whether the dial's hand moves rather than jumps. Off by default. */
    readonly animateHand: _angular_core.InputSignal<boolean>;
    /** Whether the dial shows which stretches of its ring carry no selectable time. Off by default. */
    readonly showUnavailable: _angular_core.InputSignal<boolean>;
    protected readonly effectivePlaceholder: _angular_core.Signal<string>;
    /**
     * The text this control could not read, said to the form.
     *
     * The field holds a value its own rules accept — `null`, which nothing objects to — while the
     * person is looking at text the widget could not parse. Unreported, the form was told nothing was
     * wrong and the submit went out empty where they had typed something.
     *
     * Reported to the form rather than painted from the controller's state, so the entry is one of the
     * field's errors like any other and goes through the rule that says a control out of play carries
     * no verdict.
     */
    protected readonly entryReported: _angular_core.EffectRef;
    /** The id the opener names — the dialog, which is what carries the overlay's role. */
    protected readonly popupId: _angular_core.Signal<string>;
    /** The label element the popup is named by — the field's own, which is on the page already. */
    protected readonly labelId: _angular_core.Signal<string>;
    /** The relation between this widget's opener and the overlay it opens. */
    protected readonly openerPart: _angular_core.Signal<_modyra_widgets.MdyPartContract>;
    /** The clock's draft, which the controller owns — this kind's value contract says `confirm`. */
    protected readonly controller: () => _modyra_widgets.MdyTimepickerFieldController | undefined;
    /** Which number the face is editing — the controller's, which hands it over when a drag ends. */
    protected readonly shownField: _angular_core.Signal<"hour" | "minute">;
    /** Which view the popup is showing — the controller's, which restores the declared one on close. */
    protected readonly shownViewMode: _angular_core.Signal<MdyTimepickerViewMode$1>;
    protected readonly draftValue: _angular_core.Signal<string>;
    private readonly injector;
    /** The controller's `open` is this kind's open state; see `MdyOverlayControl.overlayOwner`. */
    protected overlayOwner(): MdyOverlayOwner | undefined;
    private readonly widgetRuntime;
    /**
     * Dispatches, and carries out what the controller asks of the DOM.
     *
     * `dispatch` returns commands — `focus`, `open-overlay`, `restore-focus` — and discarding them
     * leaves the controller's decisions unexecuted with nothing failing. The runtime applies them on
     * its own render beat.
     */
    protected send(intent: MdyTimepickerFieldIntent): void;
    protected onBeforeOpen(): void;
    /**
     * A position on the face, sent as the position it is.
     *
     * The angle and the ring travel; the controller owns what they mean. A face that reported a
     * formatted time instead would have to name it in some format, and only one of the two rings of a
     * 24-hour face has names the twelve-hour notation can write.
     */
    protected onDialPicked(pick: {
        field: "hour" | "minute";
        angle: number;
        ring: "outer" | "inner";
        phase?: "move" | "end";
    }): void;
    /** A time chosen through the number fields or the period toggle — the controller reads it. */
    protected onTimePicked(time: string): void;
    protected confirmPicker(): void;
    protected cancelPicker(): void;
    /** Both ways out of the popup: the controller decides what the draft becomes, the panel closes. */
    private finishPicker;
    protected onInputChange(event: Event): void;
    /**
     * Selects the text when there is nothing a person chose, so the first keystroke replaces it.
     *
     * Asked of the value rather than of the text: the resting display is whatever the format writes
     * midnight as, and a list of the strings it might be was a list of the twelve-hour ones — so on
     * the 24-hour clock, which is the default, the resting field was never selected.
     */
    protected onInputFocus(event: FocusEvent): void;
    /**
     * Leaving the field puts the control back in step with the value — unless there is no value.
     *
     * A time the field could not read is still what the person typed, and it is the only copy of it.
     * Replacing it with the empty string on the way out took their entry away and said nothing about
     * why, leaving a control that looks untouched and a person with nothing to correct. Held instead,
     * so the next keystroke edits what they wrote rather than starting again.
     */
    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; }; "viewMode": { "alias": "viewMode"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "animateHand": { "alias": "animateHand"; "required": false; "isSignal": true; }; "showUnavailable": { "alias": "showUnavailable"; "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<"CALENDAR" | "CLOCK" | "ERROR" | "LOADER" | "KEYBOARD" | "SEARCH" | "CHECKMARK" | "CLOSE" | "UNDO" | "PLUS" | "MINUS" | "CHEVRON_DOWN" | "CHEVRON_LEFT" | "CHEVRON_RIGHT" | "SPIN_UP" | "SPIN_DOWN">;
    readonly strokeWidth: _angular_core.InputSignal<number>;
    protected readonly iconData: _angular_core.Signal<Readonly<{
        viewBox: "0 0 24 24";
        span: "full";
        content: "<rect x=\"2\" y=\"4\" width=\"20\" height=\"18\" rx=\"2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M8 2v4M16 2v4M2 10h20\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "full";
        content: "<circle cx=\"12\" cy=\"12\" r=\"10\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M12 7v5l3.5 2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "full";
        content: "<circle cx=\"12\" cy=\"12\" r=\"10\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M12 7v6M12 17h0\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "full";
        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\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "full";
        content: "<rect x=\"2\" y=\"6\" width=\"20\" height=\"12\" rx=\"2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 10h0M10 10h0M14 10h0M18 10h0M6 14h0M9 14h6M18 14h0\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "compact";
        content: "<circle cx=\"10.5\" cy=\"10.5\" r=\"5.5\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M14.4 14.4 19 19\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "compact";
        content: "<path d=\"M5 13l4 4L19 7\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "compact";
        content: "<path d=\"M5 5l14 14M19 5L5 19\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "compact";
        content: "<path d=\"M5 9h14v10\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M9 5L5 9l4 4\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "compact";
        content: "<path d=\"M5 12h14M12 5v14\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "compact";
        content: "<path d=\"M5 12h14\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "directional";
        content: "<path d=\"M6 9l6 6 6-6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "directional";
        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";
        span: "directional";
        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 24 24";
        span: "directional";
        content: "<path d=\"M6 15l6-6 6 6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>";
    }> | Readonly<{
        viewBox: "0 0 24 24";
        span: "directional";
        content: "<path d=\"M6 9l6 6 6-6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"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[] | null>[];
    };
    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[] | null>[];
    };
    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>;
}

interface AngularReactivityOptions {
    /** Needed to run effects (async validators, drafts, history). */
    injector?: Injector | undefined;
    /**
     * `"throw"` (default): `effect()` throws {@link MdyUnsupportedCapabilityError}
     * when called without an Injector — the engine already checks
     * `capabilities.effects` before calling `effect()` for its own
     * features, so this only fires for a caller that skipped that check.
     * `"report"`: degrade to a disabled effect instead of throwing (the pre-M4
     * behavior), but always through {@link MdyDiagnostics} — never silently.
     */
    unsupported?: "throw" | "report" | undefined;
    /** Receives structured diagnostics (see `@modyra/core`'s `MDY_*` codes). */
    diagnostics?: MdyDiagnostics | undefined;
}
/**
 * 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 `capabilities.effects` reports
 * `false` and the engine skips
 * effect-dependent features (async validators, drafts, history) with a
 * warning — the capability check happens before `effect()` is ever called
 * for those. Accepts either an `Injector` directly (existing call sites) or
 * an {@link AngularReactivityOptions} bag.
 */
declare function angularReactivity(injectorOrOptions?: Injector | AngularReactivityOptions): 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.
 *
 * An alias, not a restatement: written out member by member it drifts the moment the contract gains
 * one, and the five reactivity adapters have always aliased it.
 */
type MdyAngularCommandHandlers = MdyWidgetCommandHandlers;
/**
 * 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;
    /**
     * This framework renders on change detection, so focus waits for the render it schedules. A
     * microtask would fire while the view is still the previous one.
     */
    private readonly runtime;
    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.
 */

/**
 * What this adapter needs, which is what the field controller needs.
 *
 * `onChange` is gone with the standalone controller: the field controller holds the handle and
 * writes through it, so a caller supplying its own writer would be a second thing owning the value.
 */
type MdyAngularSelectAdapterOptions<TValue> = MdySelectFieldControllerOptions<TValue>;
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<MdySelectFieldController<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;
    /** Replace the option list. */
    setOptions(options: readonly MdySelectOption<TValue>[]): void;
    /** Update the open state programmatically without emitting commands. */
    setOpen(open: boolean): void;
    /** Update the readonly state. */
    setReadonly(readonly: boolean): void;
    /** Which of the two texts under the field the trigger describes itself by. */
    setDescribedBy(shown: {
        readonly errorsVisible?: boolean;
        readonly descriptionVisible?: boolean;
    }): void;
    /** Whether the panel's contents are in the document — this renderer builds them on open. */
    setPopupRendered(rendered: 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, record };
export type { MdyAngularCommandHandlers, MdyAngularSelectAdapterOptions, MdyAnyArrayDescriptor, MdyAnyFieldDescriptor, MdyAnyGroupDescriptor, MdyAnyRecordDescriptor, MdyAnyRowDescriptor, 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, MdyRecordDescriptor, MdyRecordHandle, MdyTypedFormLike };
//# sourceMappingURL=modyra-angular.d.ts.map