@zellvora/ng-input 0.1.1

package/types/zellvora-ng-input.d.ts

@@ -0,0 +1,663 @@
+import * as _angular_core from '@angular/core';
+import { WritableSignal, Signal, Injector, Type, Provider, InjectionToken, ChangeDetectorRef, DestroyRef, EventEmitter } from '@angular/core';
+import * as _zellvora_ng_input from '@zellvora/ng-input';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors, ValidatorFn, AsyncValidatorFn } from '@angular/forms';
+
+/**
+ * Signal Validation Engine — type contracts.
+ *
+ * Validators are *pure functions* of a value (and optionally the whole form
+ * model for cross-field rules). They never touch Angular `AbstractControl`,
+ * never use Observables/Subjects/EventEmitter. The engine wraps them in
+ * `computed()` so validation re-runs automatically when the value changes.
+ */
+/** Map of error-key -> error payload, or `null` when the value is valid. */
+type ZvErrors = Record<string, unknown> | null;
+/** Synchronous validator: pure function from value (+model) to errors. */
+type ZvValidator<V = unknown, M = Record<string, unknown>> = (value: V, model: M) => ZvErrors;
+/** Asynchronous validator: e.g. server uniqueness checks. */
+type ZvAsyncValidator<V = unknown, M = Record<string, unknown>> = (value: V, model: M) => Promise<ZvErrors>;
+/** Per-control validation configuration used when declaring a form. */
+interface ZvFieldConfig<V = unknown, M = Record<string, unknown>> {
+    validators?: ZvValidator<V, M>[];
+    asyncValidators?: ZvAsyncValidator<V, M>[];
+    /** Debounce (ms) before async validators fire after the last change. */
+    debounce?: number;
+    /** Initial disabled state. */
+    disabled?: boolean;
+}
+/** Aggregate control status, mirroring familiar Angular semantics. */
+type ZvControlStatus = 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';
+
+/**
+ * Signal Form Engine — the single source of truth for the whole library.
+ *
+ * A form is a `WritableSignal<T>` model plus a lazily-created `ZvControl` per
+ * field. Every piece of derived state (value, errors, validity, status) is a
+ * `computed()`, so it recomputes automatically and never needs subscriptions,
+ * `patchValue`, `setValue`, or manual change detection.
+ *
+ * The Reactive and Template adapters wrap *this* — they add no validation or
+ * state logic of their own.
+ */
+
+/** Declarative form definition: per-field validator config. */
+type ZvFormSchema<T> = {
+    [K in keyof T]?: ZvFieldConfig<T[K], T>;
+};
+interface ZvFormOptions {
+    /**
+     * Injector used to register async-validation effects. Defaults to the
+     * ambient injector when `createForm` is called in an injection context.
+     */
+    injector?: Injector;
+}
+/** A reactive view over one field of the form model. */
+interface ZvControl<V> {
+    readonly key: string;
+    /** Current value (computed view of `model()[key]`). */
+    readonly value: Signal<V>;
+    /** Two-way friendly model alias (same as `value`). */
+    readonly model: Signal<V>;
+    readonly disabled: Signal<boolean>;
+    readonly required: Signal<boolean>;
+    readonly dirty: Signal<boolean>;
+    readonly touched: Signal<boolean>;
+    readonly pending: Signal<boolean>;
+    readonly errors: Signal<ZvErrors>;
+    readonly valid: Signal<boolean>;
+    readonly invalid: Signal<boolean>;
+    readonly status: Signal<ZvControlStatus>;
+    setValue(v: V): void;
+    update(fn: (v: V) => V): void;
+    setDisabled(disabled: boolean): void;
+    markTouched(touched?: boolean): void;
+    markDirty(dirty?: boolean): void;
+    reset(): void;
+}
+/** The form object returned by `createForm`. */
+interface ZvSignalForm<T extends Record<string, unknown>> {
+    /** The model — the writable source of truth. */
+    readonly model: WritableSignal<T>;
+    /** Get (and lazily create) a typed control for a field. */
+    control<K extends keyof T & string>(key: K): ZvControl<T[K]>;
+    readonly value: Signal<T>;
+    readonly errors: Signal<Record<string, ZvErrors>>;
+    readonly valid: Signal<boolean>;
+    readonly invalid: Signal<boolean>;
+    readonly dirty: Signal<boolean>;
+    readonly touched: Signal<boolean>;
+    readonly pending: Signal<boolean>;
+    readonly status: Signal<ZvControlStatus>;
+    patch(partial: Partial<T>): void;
+    setValue(value: T): void;
+    reset(value?: T): void;
+    markAllTouched(): void;
+}
+/**
+ * Create a Signal Form.
+ *
+ * @example
+ * const form = createForm(
+ *   { firstName: '', email: '', age: null as number | null },
+ *   { email: { validators: [ZvValidators.required, ZvValidators.email] } },
+ * );
+ * form.control('email').invalid();   // computed signal
+ */
+declare function createForm<T extends Record<string, unknown>>(initial: T, schema?: ZvFormSchema<T>, options?: ZvFormOptions): ZvSignalForm<T>;
+
+/**
+ * Built-in signal validators.
+ *
+ * Each is a pure `ZvValidator` (or a factory returning one). They are shared by
+ * the Signal Form Engine, and — via thin wrappers — by the Reactive and
+ * Template adapters, so validation logic is written exactly once.
+ */
+
+declare const ZV_PATTERNS: {
+    readonly email: RegExp;
+    readonly phone: RegExp;
+    readonly mobile: RegExp;
+    readonly url: RegExp;
+    readonly pan: RegExp;
+    readonly gst: RegExp;
+    readonly aadhaar: RegExp;
+    readonly cvv: RegExp;
+    readonly passport: RegExp;
+    readonly drivingLicense: RegExp;
+    readonly pincode: RegExp;
+    readonly ifsc: RegExp;
+    readonly swift: RegExp;
+    readonly iban: RegExp;
+    readonly time: RegExp;
+    readonly password: RegExp;
+};
+declare const ZvValidators: {
+    readonly required: ZvValidator & {
+        zvRequired: boolean;
+    };
+    readonly email: ZvValidator<unknown>;
+    readonly phone: ZvValidator<unknown>;
+    readonly mobile: ZvValidator<unknown>;
+    readonly url: ZvValidator<unknown>;
+    readonly pincode: ZvValidator<unknown>;
+    readonly cvv: ZvValidator<unknown>;
+    readonly passport: ZvValidator<unknown>;
+    readonly drivingLicense: ZvValidator<unknown>;
+    readonly ifsc: ZvValidator<unknown>;
+    readonly swift: ZvValidator<unknown>;
+    readonly iban: ZvValidator<unknown>;
+    readonly time: ZvValidator<unknown>;
+    readonly pan: ZvValidator<unknown>;
+    readonly gst: ZvValidator<unknown>;
+    readonly password: ZvValidator<unknown>;
+    readonly pattern: (p: string | RegExp) => ZvValidator;
+    readonly regex: (p: string | RegExp) => ZvValidator;
+    readonly min: (n: number) => ZvValidator<number | string | null>;
+    readonly max: (n: number) => ZvValidator<number | string | null>;
+    readonly minLength: (n: number) => ZvValidator;
+    readonly maxLength: (n: number) => ZvValidator;
+    readonly date: ZvValidator;
+    /** Minimum whole-year age relative to today. */
+    readonly age: (minYears: number) => ZvValidator;
+    readonly aadhaar: ZvValidator;
+    readonly creditCard: ZvValidator;
+    /** Max file size in bytes (works on File | File[]). */
+    readonly fileSize: (maxBytes: number) => ZvValidator;
+    /** Allowed MIME types (e.g. ['image/png','application/pdf']). */
+    readonly mimeType: (allowed: string[]) => ZvValidator;
+    /** Image max width/height (async-free: relies on already-measured dims). */
+    readonly imageSize: (maxW: number, maxH: number) => ZvValidator<{
+        width: number;
+        height: number;
+    } | null>;
+    /**
+     * Cross-field: a control validator that compares against another model key.
+     * Use as a field validator; it receives the full model as 2nd arg.
+     */
+    readonly confirm: (otherField: string, key?: string) => ZvValidator;
+};
+
+/** Shared types for all Zellvora form controls. */
+type ZvAppearance = 'outlined' | 'filled' | 'standard';
+type ZvSize = 'sm' | 'md' | 'lg' | 'compact' | 'dense';
+type ZvTheme = 'material' | 'bootstrap' | 'custom';
+type ZvColor = 'primary' | 'accent' | 'warn' | 'success' | 'info';
+type ZvStatus = 'error' | 'success' | 'warning' | 'info' | null;
+type ZvDir = 'ltr' | 'rtl';
+/** A selectable option for select / multiselect / radio. */
+interface ZvOption<T = unknown> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+    icon?: string;
+    group?: string;
+}
+/** Resolved component-wide defaults provided via ZV_INPUT_CONFIG. */
+interface ZvInputConfig {
+    appearance: ZvAppearance;
+    size: ZvSize;
+    theme: ZvTheme;
+    color: ZvColor;
+    floatingLabel: boolean;
+    dir: ZvDir;
+    clearable: boolean;
+    /** Debounce (ms) applied to value emissions for async/server validators. */
+    debounce: number;
+}
+declare const ZV_DEFAULT_CONFIG: ZvInputConfig;
+
+declare abstract class SignalControlAccessor<T = unknown> {
+    protected readonly config: _zellvora_ng_input.ZvInputConfig;
+    /** Override per concrete control: 'input' | 'select' | ... */
+    abstract readonly controlType: string;
+    readonly id: _angular_core.WritableSignal<string>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /** The Signal Form to bind to (use with `controlName`). */
+    readonly form: _angular_core.InputSignal<ZvSignalForm<Record<string, unknown>> | undefined>;
+    readonly controlName: _angular_core.InputSignal<string | undefined>;
+    readonly value: _angular_core.ModelSignal<T | null>;
+    /** Alias of `value` for `[(model)]` ergonomics. */
+    readonly modelValue: _angular_core.ModelSignal<T | null>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    readonly helperText: _angular_core.InputSignal<string | undefined>;
+    readonly errorMessage: _angular_core.InputSignal<string | undefined>;
+    readonly prefixIcon: _angular_core.InputSignal<string | undefined>;
+    readonly suffixIcon: _angular_core.InputSignal<string | undefined>;
+    readonly tooltip: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly autocomplete: _angular_core.InputSignal<string>;
+    readonly loadingText: _angular_core.InputSignal<string | undefined>;
+    readonly tabIndex: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly requiredInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly floatingLabel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly minlength: _angular_core.InputSignalWithTransform<number | undefined, number | undefined>;
+    readonly maxlength: _angular_core.InputSignalWithTransform<number | undefined, number | undefined>;
+    readonly min: _angular_core.InputSignal<string | number | Date | undefined>;
+    readonly max: _angular_core.InputSignal<string | number | Date | undefined>;
+    readonly mask: _angular_core.InputSignal<string | undefined>;
+    readonly appearance: _angular_core.InputSignal<ZvAppearance>;
+    readonly size: _angular_core.InputSignal<ZvSize>;
+    readonly theme: _angular_core.InputSignal<ZvTheme>;
+    readonly color: _angular_core.InputSignal<ZvColor>;
+    readonly dir: _angular_core.InputSignal<ZvDir>;
+    readonly variant: _angular_core.InputSignal<string | undefined>;
+    readonly density: _angular_core.InputSignal<string | undefined>;
+    readonly rounded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly statusInput: _angular_core.InputSignal<ZvStatus>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly _disabledOverride;
+    readonly change: _angular_core.OutputEmitterRef<T | null>;
+    readonly inputEvent: _angular_core.OutputEmitterRef<T | null>;
+    readonly focusEvent: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly blurEvent: _angular_core.OutputEmitterRef<FocusEvent>;
+    private readonly _touched;
+    private readonly _focused;
+    private readonly _dirty;
+    /** The bound engine control, if `[form] + controlName` are set. */
+    protected readonly boundControl: Signal<ZvControl<T> | null>;
+    readonly current: Signal<T | null>;
+    readonly disabled: Signal<boolean>;
+    /** Errors injected by the Reactive/Template adapter (no bound signal form). */
+    private readonly _externalErrors;
+    readonly errors: Signal<ZvErrors>;
+    readonly valid: Signal<boolean>;
+    readonly invalid: Signal<boolean>;
+    readonly pending: Signal<boolean>;
+    readonly dirty: Signal<boolean>;
+    readonly touched: Signal<boolean>;
+    readonly focused: Signal<boolean>;
+    readonly required: Signal<boolean>;
+    readonly status: Signal<ZvControlStatus>;
+    /** Show validation error only once the field has been interacted with. */
+    readonly showError: Signal<boolean>;
+    /** Resolved error text: explicit `errorMessage` wins, else the first error. */
+    readonly errorText: Signal<string | null>;
+    readonly hasValue: Signal<boolean>;
+    constructor();
+    protected commit(v: T | null, kind: 'input' | 'change'): void;
+    protected onFocus(ev: FocusEvent): void;
+    protected onBlur(ev: FocusEvent): void;
+    setDisabled(disabled: boolean): void;
+    /** Accept a value from a Reactive/Template control without re-emitting. */
+    acceptExternalValue(v: T | null): void;
+    /** Push validation errors computed by the adapter (same ZvValidators). */
+    setExternalErrors(e: ZvErrors): void;
+    /** Mark touched from the adapter (e.g. on blur). */
+    markTouched(): void;
+    /** Subscribe to value commits (adapter -> NgControl onChange). */
+    readonly committed: _angular_core.OutputEmitterRef<T | null>;
+    clear(): void;
+    protected readonly hostClasses: Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SignalControlAccessor<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SignalControlAccessor<any>, never, never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "controlName": { "alias": "controlName"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "modelValue": { "alias": "model"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; "isSignal": true; }; "suffixIcon": { "alias": "suffixIcon"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; "isSignal": true; }; "minlength": { "alias": "minlength"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "statusInput": { "alias": "status"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "modelValue": "modelChange"; "change": "change"; "inputEvent": "input"; "focusEvent": "focus"; "blurEvent": "blur"; "committed": "zvCommitted"; }, never, never, true, never>;
+}
+
+/**
+ * Alias a concrete control to the abstract `SignalControlAccessor` token so the
+ * Reactive/Template adapter directive can inject it from the same element.
+ */
+declare function provideSignalControl(cmp: Type<unknown>): Provider;
+
+/**
+ * App-wide defaults for every Zellvora control. Override at root or per
+ * lazy-loaded scope. Tree-shakable: the default is the bundled constant.
+ */
+declare const ZV_INPUT_CONFIG: InjectionToken<ZvInputConfig>;
+/** Provide partial overrides without restating the full config. */
+declare function provideZvInput(overrides?: Partial<ZvInputConfig>): Provider;
+
+/**
+ * Presentational wrapper: label, prefix/suffix icons, hint/error row,
+ * loading + clear affordances. Controls project their native element into it.
+ * Signal-first and OnPush — it never triggers extra change detection.
+ */
+declare class ZvFieldShell {
+    readonly for: _angular_core.InputSignal<string | undefined>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    readonly helperText: _angular_core.InputSignal<string | undefined>;
+    readonly errorText: _angular_core.InputSignal<string | null | undefined>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly prefixIcon: _angular_core.InputSignal<string | undefined>;
+    readonly suffixIcon: _angular_core.InputSignal<string | undefined>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly loadingText: _angular_core.InputSignal<string | undefined>;
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    readonly hasValue: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly clear: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvFieldShell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvFieldShell, "zv-field-shell", never, { "for": { "alias": "for"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; "isSignal": true; }; "suffixIcon": { "alias": "suffixIcon"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "hasValue": { "alias": "hasValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "clear": "clear"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Single-line text input. Signal-first: binds via `[(value)]`, or via a Signal
+ * Form using `[form]` + `controlName`.
+ *
+ * @example <zv-input [form]="form" controlName="firstName" label="First name" />
+ */
+declare class ZvInput extends SignalControlAccessor<string> {
+    readonly controlType = "input";
+    readonly inputType: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvInput, "zv-input", never, { "inputType": { "alias": "inputType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Base class shared by every Zellvora control.
+ *
+ * Implements `ControlValueAccessor` + `Validator` so the same component works
+ * unchanged across Template-Driven (`ngModel`), Reactive (`formControlName`)
+ * and Signal Forms (via the `zvSignal` directive). Internal state is held in
+ * signals, so views can run fully `OnPush` with no manual `markForCheck`.
+ *
+ * Concrete controls extend this, set `controlType`, and bind `[value]` /
+ * `(handleInput)` / `(handleBlur)` in their template.
+ */
+declare abstract class ZvBaseControl<T = unknown> implements ControlValueAccessor, Validator {
+    protected readonly config: _zellvora_ng_input.ZvInputConfig;
+    protected readonly cdr: ChangeDetectorRef;
+    protected readonly destroyRef: DestroyRef;
+    /** Override in subclass: 'input' | 'email' | 'select' ... drives styling/ARIA. */
+    abstract readonly controlType: string;
+    get id(): string;
+    name?: string;
+    label?: string;
+    placeholder: string;
+    hint?: string;
+    helperText?: string;
+    errorMessage?: string;
+    prefixIcon?: string;
+    suffixIcon?: string;
+    tooltip?: string;
+    ariaLabel?: string;
+    autocomplete: string;
+    loadingText?: string;
+    tabIndex: number;
+    clearable: boolean;
+    readonly: boolean;
+    required: boolean;
+    loading: boolean;
+    floatingLabel: boolean;
+    minlength?: number;
+    maxlength?: number;
+    min?: number | string | Date;
+    max?: number | string | Date;
+    pattern?: string | RegExp;
+    mask?: string;
+    appearance: ZvAppearance;
+    size: ZvSize;
+    theme: ZvTheme;
+    color: ZvColor;
+    dir: ZvDir;
+    status: ZvStatus;
+    protected readonly _value: WritableSignal<T | null>;
+    protected readonly _disabled: WritableSignal<boolean>;
+    protected readonly _touched: WritableSignal<boolean>;
+    protected readonly _focused: WritableSignal<boolean>;
+    /** Public readonly value signal — useful for Signal Forms & templates. */
+    readonly valueSig: _angular_core.Signal<T | null>;
+    readonly disabledSig: _angular_core.Signal<boolean>;
+    readonly focusedSig: _angular_core.Signal<boolean>;
+    /** Has content for floating-label / empty-state styling. */
+    readonly hasValue: _angular_core.Signal<boolean>;
+    /** Enables `[(value)]`. */
+    readonly valueChange: EventEmitter<T | null>;
+    readonly input: EventEmitter<T | null>;
+    readonly change: EventEmitter<T | null>;
+    readonly focus: EventEmitter<FocusEvent>;
+    readonly blur: EventEmitter<FocusEvent>;
+    /** `[(value)]` setter for direct (non-forms) usage. */
+    set value(v: T | null);
+    get value(): T | null;
+    set disabled(v: boolean);
+    get disabled(): boolean;
+    /** A writable signal holding the form model, e.g. `signal({ name: '' })`. */
+    signal?: WritableSignal<Record<string, unknown>>;
+    /** Key within the signal model this control is bound to. */
+    controlName?: string;
+    private _onChange;
+    private _onTouched;
+    private _onValidatorChange;
+    constructor();
+    /** Signal Forms: push control -> model (called from setValue). */
+    private syncToSignal;
+    writeValue(value: T | null): void;
+    registerOnChange(fn: (v: T | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    /** Override to contribute control-specific validators (email, min, etc.). */
+    protected ownValidators(): ValidatorFn[];
+    /** Call when constraint inputs change so the parent re-runs validation. */
+    protected notifyValidatorChange(): void;
+    protected setValue(v: T | null, emitInput?: boolean): void;
+    protected handleInput(v: T | null): void;
+    protected handleChange(v: T | null): void;
+    protected handleFocus(ev: FocusEvent): void;
+    protected handleBlur(ev: FocusEvent): void;
+    /** Clear button handler. */
+    clear(): void;
+    get hostClasses(): Record<string, boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvBaseControl<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZvBaseControl<any>, never, never, { "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; }; "suffixIcon": { "alias": "suffixIcon"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "floatingLabel": { "alias": "floatingLabel"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "size": { "alias": "size"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "color": { "alias": "color"; "required": false; }; "dir": { "alias": "dir"; "required": false; }; "status": { "alias": "status"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "signal": { "alias": "signal"; "required": false; }; "controlName": { "alias": "controlName"; "required": false; }; }, { "valueChange": "valueChange"; "input": "input"; "change": "change"; "focus": "focus"; "blur": "blur"; }, never, never, true, never>;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType_clearable: unknown;
+    static ngAcceptInputType_readonly: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_loading: unknown;
+    static ngAcceptInputType_floatingLabel: unknown;
+    static ngAcceptInputType_minlength: unknown;
+    static ngAcceptInputType_maxlength: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/**
+ * Base for all single-line / multi-line text controls. Subclasses set
+ * `controlType`, the native `inputType`, and any extra validators.
+ */
+declare abstract class ZvTextControlBase extends ZvBaseControl<string> {
+    /** Native input type; overridden per control (text/email/password/...). */
+    abstract readonly inputType: string;
+    maxRows: number;
+    protected onNativeInput(ev: Event): void;
+    protected onNativeChange(ev: Event): void;
+    protected ownValidators(): ValidatorFn[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvTextControlBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZvTextControlBase, never, never, { "maxRows": { "alias": "maxRows"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ZvEmail extends ZvTextControlBase {
+    readonly controlType = "email";
+    readonly inputType = "email";
+    autocomplete: string;
+    protected ownValidators(): ValidatorFn[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvEmail, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvEmail, "zv-email", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZvPassword extends ZvTextControlBase {
+    readonly controlType = "password";
+    readonly inputType = "password";
+    autocomplete: string;
+    toggle: boolean;
+    strong: boolean;
+    readonly reveal: _angular_core.WritableSignal<boolean>;
+    protected ownValidators(): ValidatorFn[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvPassword, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvPassword, "zv-password", never, { "toggle": { "alias": "toggle"; "required": false; }; "strong": { "alias": "strong"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_toggle: unknown;
+    static ngAcceptInputType_strong: unknown;
+}
+
+declare class ZvNumber extends ZvBaseControl<number> {
+    readonly controlType = "number";
+    step: number;
+    protected onInput(ev: Event): void;
+    protected ownValidators(): ValidatorFn[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvNumber, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvNumber, "zv-number", never, { "step": { "alias": "step"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_step: unknown;
+}
+
+declare class ZvTextarea extends ZvTextControlBase {
+    readonly controlType = "textarea";
+    readonly inputType = "textarea";
+    rows: number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvTextarea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvTextarea, "zv-textarea", never, { "rows": { "alias": "rows"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_rows: unknown;
+}
+
+/**
+ * Wraps the native date input for full a11y + parity, normalizing the value to
+ * an ISO `yyyy-MM-dd` string. Swap the inner element for a custom calendar
+ * without touching the CVA contract.
+ */
+declare class ZvDatepicker extends ZvBaseControl<string> {
+    readonly controlType = "datepicker";
+    protected onInput(ev: Event): void;
+    protected ownValidators(): ValidatorFn[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvDatepicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvDatepicker, "zv-datepicker", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZvTimepicker extends ZvBaseControl<string> {
+    readonly controlType = "timepicker";
+    protected onInput(ev: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvTimepicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvTimepicker, "zv-timepicker", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Single-select with virtual-scrolled listbox + keyboard support.
+ * Accepts either `ZvOption[]` or a raw `T[]` via `bindLabel`/`bindValue`.
+ */
+declare class ZvSelect<T = unknown> extends SignalControlAccessor<T> {
+    readonly controlType = "select";
+    readonly items: _angular_core.InputSignal<ZvOption<T>[] | T[]>;
+    readonly bindLabel: _angular_core.InputSignal<string>;
+    readonly bindValue: _angular_core.InputSignal<string>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    readonly options: _angular_core.Signal<ZvOption<T>[]>;
+    readonly selectedLabel: _angular_core.Signal<string>;
+    toggle(): void;
+    pick(o: ZvOption<T>): void;
+    onKeydown(ev: KeyboardEvent): void;
+    trackByValue: (_: number, o: ZvOption<T>) => unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvSelect<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvSelect<any>, "zv-select", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "bindLabel": { "alias": "bindLabel"; "required": false; "isSignal": true; }; "bindValue": { "alias": "bindValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ZvMultiselect<T = unknown> extends ZvBaseControl<T[]> {
+    readonly controlType = "multiselect";
+    items: ZvOption<T>[] | T[];
+    bindLabel: string;
+    bindValue: string;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    get options(): ZvOption<T>[];
+    readonly summary: _angular_core.Signal<string>;
+    isSelected: (v: T) => boolean;
+    toggle(): void;
+    picktoggle(o: ZvOption<T>): void;
+    trackByValue: (_: number, o: ZvOption<T>) => T;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvMultiselect<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvMultiselect<any>, "zv-multiselect", never, { "items": { "alias": "items"; "required": false; }; "bindLabel": { "alias": "bindLabel"; "required": false; }; "bindValue": { "alias": "bindValue"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ZvCheckbox extends ZvBaseControl<boolean> {
+    readonly controlType = "checkbox";
+    protected onToggle(ev: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvCheckbox, "zv-checkbox", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZvRadio<T = unknown> extends ZvBaseControl<T> {
+    readonly controlType = "radio";
+    items: ZvOption<T>[] | T[];
+    bindLabel: string;
+    bindValue: string;
+    get options(): ZvOption<T>[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvRadio<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvRadio<any>, "zv-radio", never, { "items": { "alias": "items"; "required": false; }; "bindLabel": { "alias": "bindLabel"; "required": false; }; "bindValue": { "alias": "bindValue"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ZvSwitch extends ZvBaseControl<boolean> {
+    readonly controlType = "switch";
+    protected onToggle(ev: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvSwitch, "zv-switch", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZvPin extends ZvBaseControl<string> {
+    readonly controlType = "pin";
+    length: number;
+    masked: boolean;
+    get cells(): number[];
+    digitAt(i: number): string;
+    onCell(i: number, ev: Event): void;
+    onKey(i: number, ev: KeyboardEvent): void;
+    private focusCell;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvPin, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvPin, "zv-pin", never, { "length": { "alias": "length"; "required": false; }; "masked": { "alias": "masked"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_length: unknown;
+}
+
+declare class ZvUpload extends ZvBaseControl<File[]> {
+    readonly controlType = "upload";
+    multiple: boolean;
+    accept: string;
+    readonly dragging: _angular_core.WritableSignal<boolean>;
+    readonly files: _angular_core.WritableSignal<File[]>;
+    onPick(ev: Event): void;
+    onDrop(ev: DragEvent): void;
+    private commit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvUpload, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZvUpload, "zv-upload", never, { "multiple": { "alias": "multiple"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_multiple: unknown;
+}
+
+declare class ZvControlValueAccessor implements ControlValueAccessor {
+    private readonly host;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZvControlValueAccessor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZvControlValueAccessor, "zv-input[formControl],zv-input[formControlName],zv-input[ngModel],zv-email[formControl],zv-email[formControlName],zv-email[ngModel],zv-password[formControl],zv-password[formControlName],zv-password[ngModel],zv-number[formControl],zv-number[formControlName],zv-number[ngModel],zv-textarea[formControl],zv-textarea[formControlName],zv-textarea[ngModel],zv-select[formControl],zv-select[formControlName],zv-select[ngModel],zv-multiselect[formControl],zv-multiselect[formControlName],zv-multiselect[ngModel],zv-checkbox[formControl],zv-checkbox[formControlName],zv-checkbox[ngModel],zv-radio[formControl],zv-radio[formControlName],zv-radio[ngModel],zv-switch[formControl],zv-switch[formControlName],zv-switch[ngModel],zv-datepicker[formControl],zv-datepicker[formControlName],zv-datepicker[ngModel],zv-timepicker[formControl],zv-timepicker[formControlName],zv-timepicker[ngModel],zv-pin[formControl],zv-pin[formControlName],zv-pin[ngModel],zv-upload[formControl],zv-upload[formControlName],zv-upload[ngModel]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Reactive/Template validator bridge.
+ *
+ * Wraps the *same* signal `ZvValidators` as Angular `ValidatorFn`s so Reactive
+ * and Template forms reuse identical logic — zero duplication.
+ *
+ * @example
+ * new FormControl('', [toNgValidator(ZvValidators.required), toNgValidator(ZvValidators.email)])
+ */
+
+declare function toNgValidator(v: ZvValidator): ValidatorFn;
+declare function toNgAsyncValidator(v: ZvAsyncValidator): AsyncValidatorFn;
+/** Convenience: map many ZvValidators to one Angular ValidatorFn list. */
+declare const ngValidators: (...vs: ZvValidator[]) => ValidatorFn[];
+
+/** Default human-readable messages for built-in validator error keys. */
+declare const ZV_DEFAULT_MESSAGES: Record<string, (info: unknown) => string>;
+/** Resolve the first error in `errors` to a display string. */
+declare function formatError(errors: ZvErrors, overrides?: Record<string, string>): string | null;
+
+export { SignalControlAccessor, ZV_DEFAULT_CONFIG, ZV_DEFAULT_MESSAGES, ZV_INPUT_CONFIG, ZV_PATTERNS, ZvCheckbox, ZvControlValueAccessor, ZvDatepicker, ZvEmail, ZvFieldShell, ZvInput, ZvMultiselect, ZvNumber, ZvPassword, ZvPin, ZvRadio, ZvSelect, ZvSwitch, ZvTextarea, ZvTimepicker, ZvUpload, ZvValidators, createForm, formatError, ngValidators, provideSignalControl, provideZvInput, toNgAsyncValidator, toNgValidator };
+export type { ZvAppearance, ZvAsyncValidator, ZvColor, ZvControl, ZvControlStatus, ZvDir, ZvErrors, ZvFieldConfig, ZvFormOptions, ZvFormSchema, ZvInputConfig, ZvOption, ZvSignalForm, ZvSize, ZvStatus, ZvTheme, ZvValidator };