@ktortu/aaa 0.1.0-beta.0 → 0.9.1

package/types/ktortu-aaa-forms.d.ts

@@ -1,22 +1,43 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Signal, TemplateRef, ModelSignal, ElementRef, PipeTransform } from '@angular/core';
+import { InjectionToken, Signal, Provider, TemplateRef, ModelSignal, ElementRef, PipeTransform } from '@angular/core';
 import * as _angular_forms_signals from '@angular/forms/signals';
-import { WithOptionalFieldTree, ValidationError, FormValueControl } from '@angular/forms/signals';
+import { ValidationError, WithOptionalFieldTree, FormValueControl } from '@angular/forms/signals';
 import * as _ktortu_aaa_forms from '@ktortu/aaa/forms';
 import { Listbox } from '@angular/aria/listbox';
 import { Combobox } from '@angular/aria/combobox';
 import { KtViewport } from '@ktortu/aaa/cdk';
-import { Temporal } from 'temporal-polyfill';
+import * as temporal_polyfill from 'temporal-polyfill';
+import { Temporal as Temporal$1 } from 'temporal-polyfill';
 export { Temporal as TemporalNamespace } from 'temporal-polyfill';
 
 /** État d'un champ pertinent pour décider de l'affichage des erreurs. */
 interface KtFieldErrorState {
+    /** Le champ est-il en erreur de validation. */
     invalid: boolean;
+    /** Le champ a-t-il été visité (blur). */
     touched: boolean;
+    /** Le champ a-t-il été modifié depuis sa valeur initiale. */
     dirty: boolean;
 }
 /** Décide QUAND afficher les erreurs d'un champ (équivalent signal de l'ErrorStateMatcher Material). */
 type KtFieldErrorMatcher = (state: KtFieldErrorState) => boolean;
+/** Erreur à résoudre en message : la `ValidationError` de Signal Forms. Selon le `kind`, ses
+    sous-types portent des params typés (`min`, `max`, `minLength`, `maxLength`, `minDate`,
+    `maxDate`, `pattern`…) lisibles via {@link ktErrorParam}. */
+type KtResolvableError = ValidationError;
+/** Fabrique de message par défaut pour un `kind` : reçoit l'erreur complète (params accessibles). */
+type KtErrorMessageFactory = (error: KtResolvableError) => string;
+/** Messages d'erreur par défaut indexés par `kind`. Valeur statique (kinds sans param : `required`,
+    `email`) ou fabrique (kinds paramétrés : `min`, `minLength`…). Une chaîne vide (`''`) supprime
+    l'affichage du message — le champ reste invalide, mais sans texte (cf. récap d'erreurs externe). */
+type KtFieldErrorMessages = Record<string, string | KtErrorMessageFactory>;
+/** Apparence du chrome de champ. `fill` = label au-dessus (défaut historique) ; `outline` = bordure
+    + label flottant qui se loge dans la bordure (transition douce depuis Angular Material « outline »). */
+type KtFieldAppearance = 'fill' | 'outline';
+/** Politique du label flottant (apparence `outline` uniquement). `auto` = flotte au focus / quand le
+    champ est rempli ; `always` = toujours flotté, même vide (le placeholder s'affiche alors). Équivaut
+    au `floatLabel` d'Angular Material. */
+type KtFloatLabel = 'auto' | 'always';
 /** Défaut : afficher l'erreur une fois le champ quitté (blur). */
 declare const defaultKtFieldErrorMatcher: KtFieldErrorMatcher;
 /** Défauts applicables à tous les champs (surchargeables par champ via les inputs).
@@ -33,20 +54,68 @@ interface KtFieldConfig {
     hideHintWhenInvalid: boolean;
     /** Afficher toutes les erreurs au lieu de la première seule. Défaut : `false`. */
     showAllErrors: boolean;
+    /** Message d'erreur d'un `kt-number-field` quand la saisie n'est pas un nombre valide.
+        Défaut (anglais neutre) : `'Please enter a valid number.'`. */
+    numberParseError: string;
+    /** Messages d'erreur par défaut indexés par `kind` (`required`, `email`, `min`, `minLength`…),
+        fusionnés par-dessus les défauts anglais embarqués (cf. `KT_DEFAULT_FIELD_ERROR_MESSAGES`).
+        Un message explicite passé au validateur Signal Forms (`{ message }`) reste prioritaire ; une
+        valeur `''` supprime le texte d'un `kind`. Défaut : `{}` (on garde les défauts anglais). */
+    errorMessages: Partial<KtFieldErrorMessages>;
+    /** Apparence par défaut de tous les champs (`fill` | `outline`). Défaut : `'fill'`. */
+    appearance: KtFieldAppearance;
+    /** Politique du label flottant en `outline` (`auto` | `always`). Défaut : `'auto'`. */
+    floatLabel: KtFloatLabel;
 }
 declare const KT_FIELD_CONFIG: InjectionToken<Partial<KtFieldConfig>>;
+/**
+ * Fournit des défauts de champ (apparence, libellés, matcher d'erreurs, messages d'erreur par
+ * défaut…) pour un sous-arbre ou l'application entière. Idéal pour une transition globale — ex. tout
+ * passer en `outline` façon Material en un seul provider.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts — apparence globale
+ * providers: [provideKtField({ appearance: 'outline' })]
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Surcharger des messages d'erreur par défaut (fusionnés par-dessus les défauts anglais).
+ * // Une fabrique reçoit l'erreur complète : ses params typés sont lisibles via `ktErrorParam`.
+ * providers: [
+ *   provideKtField({
+ *     errorMessages: {
+ *       required: 'Champ obligatoire.',
+ *       minLength: (e) => `Au moins ${ktErrorParam<number>(e, 'minLength')} caractères.`,
+ *       pattern: '', // '' supprime le texte de ce kind : champ rouge, sans message
+ *     },
+ *   }),
+ * ]
+ * ```
+ *
+ * @remarks Pour passer toute la lib en français d'un coup (libellés + messages d'erreur), préférez
+ * `provideKtDefaultFR()` (paquet `@ktortu/aaa/i18n`), qui fournit déjà un dictionnaire complet.
+ */
+declare function provideKtField(config: Partial<KtFieldConfig>): Provider;
 /** Parent field interface representing shared states for its controls. */
 interface KtFieldParent {
+    /** id de base du champ, posé sur le contrôle (`[id]`). */
     readonly baseId: Signal<string>;
+    /** Valeur de `aria-describedby` à câbler sur le contrôle (ou `null`). */
     readonly describedBy: Signal<string | null>;
+    /** Le champ est-il en erreur (pose `aria-invalid`). */
     readonly invalid: Signal<boolean>;
+    /** Le champ est-il requis (pose `aria-required`). */
     readonly required: Signal<boolean>;
 }
 declare const KT_FIELD: InjectionToken<KtFieldParent>;
 
 /** Forme minimale d'une erreur affichable — découple `Field` de Signal Forms. */
 interface KtFieldError {
+    /** Identifiant du type d'erreur (ex. `'required'`, `'email'`). */
     kind: string;
+    /** Message lisible affiché à l'utilisateur (optionnel). */
     message?: string;
 }
 /** Chrome de champ agnostique du système de forms : label + contrôle projeté + hint + erreur,
@@ -75,15 +144,25 @@ declare class KtField implements KtFieldParent {
     /** Erreurs de validation à afficher sous le contrôle. @default [] */
     readonly errors: _angular_core.InputSignal<readonly KtFieldError[]>;
     /** Marque le champ comme invalide (pose `aria-invalid` et conditionne l'affichage des erreurs). @default false */
-    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Affiche l'astérisque requis et pose `aria-required` sur le contrôle. @default false */
-    readonly required: _angular_core.InputSignal<boolean>;
-    /** id imposé (sélecteurs de test stables) ; sinon auto-généré, anti-collision. */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** id imposé (sélecteurs de test stables) ; sinon auto-généré, anti-collision. @default undefined */
     readonly fieldId: _angular_core.InputSignal<string | undefined>;
-    /** Masquer le hint quand l'erreur s'affiche (façon Material). */
-    readonly hideHintWhenInvalid: _angular_core.InputSignal<boolean>;
-    /** Afficher toutes les erreurs au lieu de la première seule. */
-    readonly showAllErrors: _angular_core.InputSignal<boolean>;
+    /** Masquer le hint quand l'erreur s'affiche (façon Material). @default KT_FIELD_CONFIG.hideHintWhenInvalid ?? false */
+    readonly hideHintWhenInvalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Afficher toutes les erreurs au lieu de la première seule. @default KT_FIELD_CONFIG.showAllErrors ?? false */
+    readonly showAllErrors: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Apparence du chrome : `fill` (label au-dessus) ou `outline` (bordure + label flottant, façon
+        Material). Non fournie ⇒ valeur du `KT_FIELD_CONFIG`, sinon `'fill'`. @default undefined */
+    readonly appearance: _angular_core.InputSignal<KtFieldAppearance | undefined>;
+    /** Apparence effective : input ?? KT_FIELD_CONFIG.appearance ?? 'fill'. */
+    protected readonly resolvedAppearance: _angular_core.Signal<KtFieldAppearance>;
+    /** Politique du label flottant (outline) : `auto` (flotte au focus/rempli) ou `always` (toujours
+        flotté, même vide). Non fournie ⇒ valeur du `KT_FIELD_CONFIG`, sinon `'auto'`. @default undefined */
+    readonly floatLabel: _angular_core.InputSignal<KtFloatLabel | undefined>;
+    /** Politique effective : input ?? KT_FIELD_CONFIG.floatLabel ?? 'auto'. */
+    protected readonly resolvedFloatLabel: _angular_core.Signal<KtFloatLabel>;
     private readonly control;
     private readonly templateTooltip;
     private readonly projectedTooltip;
@@ -100,99 +179,180 @@ declare class KtField implements KtFieldParent {
     readonly describedBy: _angular_core.Signal<string | null>;
     protected onHelpClick(event: MouseEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtField, "kt-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "helpText": { "alias": "helpText"; "required": false; "isSignal": true; }; "helpLabel": { "alias": "helpLabel"; "required": false; "isSignal": true; }; "customDescribedBy": { "alias": "customDescribedBy"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "fieldId": { "alias": "fieldId"; "required": false; "isSignal": true; }; "hideHintWhenInvalid": { "alias": "hideHintWhenInvalid"; "required": false; "isSignal": true; }; "showAllErrors": { "alias": "showAllErrors"; "required": false; "isSignal": true; }; }, { "helpClick": "helpClick"; }, ["control", "projectedTooltip"], ["[ktFieldHelp]", "*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtField, "kt-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "helpText": { "alias": "helpText"; "required": false; "isSignal": true; }; "helpLabel": { "alias": "helpLabel"; "required": false; "isSignal": true; }; "customDescribedBy": { "alias": "customDescribedBy"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "fieldId": { "alias": "fieldId"; "required": false; "isSignal": true; }; "hideHintWhenInvalid": { "alias": "hideHintWhenInvalid"; "required": false; "isSignal": true; }; "showAllErrors": { "alias": "showAllErrors"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "floatLabel": { "alias": "floatLabel"; "required": false; "isSignal": true; }; }, { "helpClick": "helpClick"; }, ["control", "projectedTooltip"], ["[ktFieldHelp]", "*"], true, never>;
 }
 
 /** Marque le contrôle (natif ou custom) d'un champ pour que `Field` y câble l'a11y
-    (id, aria-describedby, aria-invalid, aria-required). */
+    (id, aria-describedby, aria-invalid, aria-required).
+
+    @example
+    ```html
+    <kt-field label="E-mail" [invalid]="invalid()" [errors]="errors()">
+      <input ktFieldControl type="email" [(ngModel)]="email" />
+    </kt-field>
+    ``` */
 declare class KtFieldControl {
     private readonly parent;
     protected readonly id: _angular_core.Signal<string | null>;
     protected readonly describedBy: _angular_core.Signal<string | null>;
     protected readonly invalid: _angular_core.Signal<boolean>;
     protected readonly required: _angular_core.Signal<boolean>;
+    /** Élément DOM hôte du contrôle (exposé pour le focus / la mesure par le parent). */
     readonly element: HTMLElement;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtFieldControl, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtFieldControl, "[ktFieldControl]", never, {}, {}, never, never, true, never>;
 }
 
-/** Suggestion d'un champ de saisie (rendu `<datalist>`) : soit la valeur seule, soit un couple
-    `{ value, label }` où `label` est le texte affiché et `value` ce qui est inséré dans le champ.
-    @template V Type de la valeur du champ (string, number, ou type Temporal selon le champ). */
-type KtSuggestion<V> = V | {
-    value: V;
-    label?: string;
-};
-/** Option `<datalist>` normalisée : `value` est la chaîne posée sur l'attribut DOM, `label` le
-    libellé affiché (ou `null`). */
-interface KtDatalistOption {
-    value: string;
-    label: string | null;
+/**
+ * Lit un param typé d'une `ValidationError` (ex. `min`, `minLength`, `maxLength`, `minDate`…).
+ * Les sous-types d'erreur de Signal Forms exposent ces params, mais le type de base `ValidationError`
+ * ne les déclare pas : ce helper centralise l'accès pour les fabriques de message, sans `any`.
+ *
+ * @example
+ * ```ts
+ * minLength: (e) => `Au moins ${ktErrorParam<number>(e, 'minLength')} caractères.`
+ * ```
+ */
+declare function ktErrorParam<T>(error: KtResolvableError, key: string): T;
+/**
+ * Messages d'erreur **anglais** par défaut de la lib, indexés par `kind`. Couvrent tous les
+ * validateurs natifs de Signal Forms (`required`, `email`, `min`, `max`, `minLength`, `maxLength`,
+ * `minDate`, `maxDate`, `pattern`). Surchargeables famille par famille via `KT_FIELD_CONFIG.errorMessages`
+ * (ou globalement par langue, cf. `provideKtDefaultFR`). Le `numberParseError` reste géré à la source
+ * par `kt-number-field` (kind `parse`).
+ */
+declare const KT_DEFAULT_FIELD_ERROR_MESSAGES: KtFieldErrorMessages;
+/**
+ * Résout le **message par défaut** d'une erreur de validation à partir de son `kind` (et de ses
+ * params typés), en fusionnant les défauts anglais embarqués avec les surcharges du `KT_FIELD_CONFIG`.
+ *
+ * Utilisé par chaque contrôle `kt-*` au moment du rendu, là où la `ValidationError` complète (params)
+ * est encore disponible — `kt-field` reste agnostique de Signal Forms. Précédence du texte affiché :
+ * `message` du validateur > `KT_FIELD_CONFIG.errorMessages[kind]` > défaut anglais > rien.
+ *
+ * Injectable racine : un seul résolveur partagé par tous les champs.
+ */
+declare class KtFieldErrorResolver {
+    private readonly config;
+    /** Map effective : défauts anglais + surcharges du `KT_FIELD_CONFIG`, par `kind`. */
+    private readonly messages;
+    /**
+     * Message par défaut d'une erreur (selon son `kind` + params), ou `undefined` si aucun défaut
+     * n'est connu pour ce `kind` (l'UI n'affiche alors rien).
+     */
+    resolve(error: KtResolvableError): string | undefined;
+    /**
+     * Prépare une liste d'erreurs pour l'affichage : applique la précédence (message du validateur
+     * sinon défaut résolu) et **écarte les erreurs au message vide** — suppression explicite via
+     * `{ message: '' }`. Le champ reste invalide (rouge / `aria-invalid`), simplement sans texte.
+     */
+    resolveAll(errors: readonly KtResolvableError[]): KtFieldError[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtFieldErrorResolver, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KtFieldErrorResolver>;
 }
 
 /** Base partagée des champs simples (TextField, NumberField) : état FormValueControl,
     présentation (label/hint/prefix/suffix/clear) et politique d'affichage des erreurs.
-    La valeur, son parsing et la notion de « vide » sont fournis par la sous-classe. */
+    La valeur, son parsing et la notion de « vide » sont fournis par la sous-classe.
+
+    @example
+    ```ts
+    // Sous-classement : on fournit value (model concret) + parse/emptyValue/isEmpty.
+    @Component({ selector: 'kt-text-field', templateUrl: './text-field.html' })
+    export class KtTextField extends KtBaseInputField<string> implements FormValueControl<string> {
+      readonly value = model<string>('');
+      protected parse(raw: string): string { return raw; }
+      protected emptyValue(): string { return ''; }
+      protected isEmpty(value: string): boolean { return value.length === 0; }
+    }
+    ``` */
 declare abstract class KtBaseInputField<T> {
     protected readonly config: Partial<_ktortu_aaa_forms.KtFieldConfig> | null;
+    private readonly errorResolver;
     /** Valeur du contrôle — déclarée concrètement par la sous-classe. */
     abstract value: ModelSignal<T>;
     /** Marque le champ comme « visité » (déclenche l'affichage des erreurs). Deux-way. @default false */
     readonly touched: ModelSignal<boolean>;
     /** Désactive la saisie et le focus. @default false */
-    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Rend le champ en lecture seule (valeur visible, non modifiable). @default false */
-    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Le champ est-il en erreur (état fourni par la validation). @default false */
-    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Marque le champ comme requis (ajoute `aria-required`). @default false */
-    readonly required: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Le champ a-t-il été modifié depuis sa valeur initiale. @default false */
-    readonly dirty: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Validation asynchrone en cours (poussé par `[field]`) : pose `aria-busy` + `data-pending`. @default false */
+    readonly pending: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Liste des erreurs de validation à afficher. @default [] */
     readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
     /** Attribut `name` natif du contrôle. @default '' */
     readonly name: _angular_core.InputSignal<string>;
-    /** id imposé pour des sélecteurs de test stables ; sinon auto-généré par Field. */
+    /** id imposé pour des sélecteurs de test stables ; sinon auto-généré par Field. @default undefined */
     readonly id: _angular_core.InputSignal<string | undefined>;
-    /** Libellé du champ (associé via `<label for>`). */
+    /** Libellé du champ (associé via `<label for>`). @default undefined */
     readonly label: _angular_core.InputSignal<string | undefined>;
-    /** Texte d'aide affiché sous le champ quand il est valide. */
+    /** Texte d'aide affiché sous le champ quand il est valide. @default undefined */
     readonly hint: _angular_core.InputSignal<string | undefined>;
-    /** Aide contextuelle riche : texte ou `TemplateRef` projeté dans une infobulle d'aide. */
+    /** Aide contextuelle riche : texte ou `TemplateRef` projeté dans une infobulle d'aide. @default undefined */
     readonly helpText: _angular_core.InputSignal<string | TemplateRef<unknown> | undefined>;
     /** Libellé accessible du bouton d'aide. @default 'Help' (ou KT_FIELD_CONFIG.helpLabel) */
     readonly helpLabel: _angular_core.InputSignal<string>;
-    /** Force la valeur de `aria-describedby` (sinon dérivée de hint/erreur). */
+    /** Force la valeur de `aria-describedby` (sinon dérivée de hint/erreur). @default undefined */
     readonly customDescribedBy: _angular_core.InputSignal<string | undefined>;
     /** Émis au clic sur le bouton d'aide contextuelle. */
     readonly helpClick: _angular_core.OutputEmitterRef<MouseEvent>;
-    /** Texte indicatif affiché dans le champ vide. */
+    /** Texte indicatif affiché dans le champ vide. @default undefined */
     readonly placeholder: _angular_core.InputSignal<string | undefined>;
     /** Indice d'autoremplissage du navigateur (attribut `autocomplete` natif) ; ex. `'current-password'`,
         `'new-password'`, `'email'`, `'username'`, `'off'`.
         @default undefined */
     readonly autocomplete: _angular_core.InputSignal<AutoFill | undefined>;
-    /** Nom d'icône Material Symbols affichée en tête de champ. */
+    /** Nom d'icône Material Symbols affichée en tête de champ. @default undefined */
     readonly icon: _angular_core.InputSignal<string | undefined>;
     /** Affiche un bouton « effacer » quand le champ contient une valeur. @default false */
     readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Contenu décoratif en tête de champ : texte ou `TemplateRef`. */
+    /** Contenu décoratif en tête de champ : texte ou `TemplateRef`. @default undefined */
     readonly prefix: _angular_core.InputSignal<string | TemplateRef<unknown> | undefined>;
-    /** Contenu décoratif en fin de champ : texte ou `TemplateRef`. */
+    /** Contenu décoratif en fin de champ : texte ou `TemplateRef`. @default undefined */
     readonly suffix: _angular_core.InputSignal<string | TemplateRef<unknown> | undefined>;
     /** Libellé i18n du bouton « effacer ». @default 'Clear' (ou KT_FIELD_CONFIG.clearLabel) */
     readonly clearLabel: _angular_core.InputSignal<string>;
-    /** Quand afficher l'erreur ; surcharge KT_FIELD_CONFIG et le défaut (`invalid && touched`). */
+    /** Quand afficher l'erreur ; surcharge KT_FIELD_CONFIG et le défaut (`invalid && touched`). @default undefined */
     readonly errorMatcher: _angular_core.InputSignal<KtFieldErrorMatcher | undefined>;
+    /** Apparence du chrome (`fill` | `outline`) ; non fournie ⇒ `KT_FIELD_CONFIG.appearance` ?? `'fill'`.
+        @default undefined */
+    readonly appearance: _angular_core.InputSignal<KtFieldAppearance | undefined>;
+    /** Politique du label flottant en outline (`auto` | `always`) ; non fournie ⇒ `KT_FIELD_CONFIG.floatLabel`
+        ?? `'auto'`. En `always`, le label reste en haut même vide et le placeholder s'affiche. @default undefined */
+    readonly floatLabel: _angular_core.InputSignal<KtFloatLabel | undefined>;
     protected readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement | HTMLTextAreaElement> | undefined>;
     private readonly matcher;
     protected readonly showInvalid: _angular_core.Signal<boolean>;
+    /** Erreurs prêtes pour `kt-field` : messages par défaut résolus, suppressions (`message: ''`) écartées. */
+    protected readonly displayErrors: _angular_core.Signal<_ktortu_aaa_forms.KtFieldError[]>;
     protected readonly showClear: _angular_core.Signal<boolean>;
+    /** Apparence effective (input ?? config ?? 'fill'). Sert aux templates : forward à `kt-field` et,
+        en outline, pose une sentinelle de placeholder pour la détection « rempli » du label flottant. */
+    protected readonly outline: _angular_core.Signal<boolean>;
+    /** Label toujours flotté en outline (input ?? config ?? 'auto'). */
+    protected readonly alwaysFloat: _angular_core.Signal<boolean>;
+    /** Valeur de l'attribut `placeholder` natif selon l'apparence :
+        - fill : le placeholder tel quel ;
+        - outline + always : le vrai placeholder (le label est en haut, pas de chevauchement) ;
+        - outline + auto : sentinelle `' '` (le label tient lieu de placeholder ; active `:placeholder-shown`). */
+    protected readonly placeholderAttr: _angular_core.Signal<string | null>;
     protected asTemplate(value: string | TemplateRef<unknown> | undefined): TemplateRef<unknown> | null;
     protected asText(value: string | TemplateRef<unknown> | undefined): string | null;
     protected onInput(event: Event): void;
     protected onKeyDown(event: KeyboardEvent): void;
+    /** Focus le contrôle natif (utilisé par Signal Forms `focusBoundControl`). */
+    focus(options?: FocusOptions): void;
+    /** Ré-aligne le texte affiché sur la valeur courante (utilisé par Signal Forms `reset`). */
+    reset(): void;
+    /** Représentation texte de la valeur pour l'input natif. Surchargeable par sous-classe. */
+    protected displayValue(): string;
     protected clear(): void;
     /** Parse la saisie brute en valeur typée. */
     protected abstract parse(raw: string): T;
@@ -201,9 +361,27 @@ declare abstract class KtBaseInputField<T> {
     /** La valeur est-elle vide (affichage du bouton d'effacement) ? */
     protected abstract isEmpty(value: T): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtBaseInputField<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtBaseInputField<any>, never, never, { "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "helpText": { "alias": "helpText"; "required": false; "isSignal": true; }; "helpLabel": { "alias": "helpLabel"; "required": false; "isSignal": true; }; "customDescribedBy": { "alias": "customDescribedBy"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; }, { "touched": "touchedChange"; "helpClick": "helpClick"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtBaseInputField<any>, never, never, { "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "helpText": { "alias": "helpText"; "required": false; "isSignal": true; }; "helpLabel": { "alias": "helpLabel"; "required": false; "isSignal": true; }; "customDescribedBy": { "alias": "customDescribedBy"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "floatLabel": { "alias": "floatLabel"; "required": false; "isSignal": true; }; }, { "touched": "touchedChange"; "helpClick": "helpClick"; }, never, never, true, never>;
 }
 
+/** Suggestion d'un champ de saisie (rendu `<datalist>`) : soit la valeur seule, soit un couple
+    `{ value, label }` où `label` est le texte affiché et `value` ce qui est inséré dans le champ.
+    @template V Type de la valeur du champ (string, number, ou type Temporal selon le champ). */
+type KtSuggestion<V> = V | {
+    value: V;
+    label?: string;
+};
+/** Option `<datalist>` normalisée : `value` est la chaîne posée sur l'attribut DOM, `label` le
+    libellé affiché (ou `null`). */
+interface KtDatalistOption {
+    value: string;
+    label: string | null;
+}
+/** Normalise une liste de suggestions en options `<datalist>`. `toValue` sérialise la valeur en
+    chaîne attendue par l'input natif (identité pour le texte, `String()` pour les nombres,
+    `serialize()` pour les champs Temporal). */
+declare function normalizeKtSuggestions<V>(suggestions: readonly KtSuggestion<V>[] | undefined, toValue: (value: V) => string): readonly KtDatalistOption[];
+
 /**
  * Champ numérique : valeur `number | null` (champ vide ⇒ `null`, jamais `NaN`), intégré aux
  * Signal Forms via `FormValueControl`. Hérite de la présentation commune (label/hint/clear/
@@ -231,11 +409,12 @@ declare class KtNumberField extends KtBaseInputField<number | null> implements F
     private readonly uid;
     protected readonly datalistId: string;
     protected readonly hasSuggestions: _angular_core.Signal<boolean>;
-    protected readonly datalistOptions: _angular_core.Signal<readonly KtDatalistOption[]>;
+    protected readonly datalistOptions: _angular_core.Signal<readonly _ktortu_aaa_forms.KtDatalistOption[]>;
     protected readonly rawValue: _angular_forms_signals.TransformedValueSignal<string>;
     protected parse(raw: string): number | null;
     protected onKeyDown(event: KeyboardEvent): void;
     private adjustValue;
+    reset(): void;
     protected emptyValue(): number | null;
     protected isEmpty(value: number | null): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtNumberField, never>;
@@ -256,13 +435,20 @@ declare class KtTextArea extends KtBaseInputField<string> implements FormValueCo
     readonly value: _angular_core.ModelSignal<string>;
     /** Hauteur initiale (lignes). L'autosize est géré en CSS via `field-sizing: content`. @default 3 */
     readonly rows: _angular_core.InputSignal<number>;
+    /** Plancher de caractères (attribut `minlength` natif ; poussé par le validateur minLength). @default undefined */
+    readonly minLength: _angular_core.InputSignal<number | undefined>;
     /** Plafond de caractères ; poussé par le form (validateur maxLength) ou par le consommateur. @default undefined */
     readonly maxLength: _angular_core.InputSignal<number | undefined>;
+    /** Motifs de validation (contrat Signal Forms). L'attribut natif `pattern` ne prend qu'une regex →
+        seule la première est posée. @default [] */
+    readonly pattern: _angular_core.InputSignal<readonly RegExp[]>;
+    /** Source de la première regex pour l'attribut `pattern` natif (`null` si aucune). */
+    protected readonly patternAttr: _angular_core.Signal<string>;
     protected parse(raw: string): string;
     protected emptyValue(): string;
     protected isEmpty(value: string): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtTextArea, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtTextArea, "kt-text-area", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ktFieldHelp]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtTextArea, "kt-text-area", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ktFieldHelp]"], true, never>;
 }
 
 /** Types texte dont la valeur reste une string (number/date = composants séparés). */
@@ -281,6 +467,15 @@ declare class KtTextField extends KtBaseInputField<string> implements FormValueC
     readonly value: _angular_core.ModelSignal<string>;
     /** Variante HTML du champ (pilote `type` natif et le clavier mobile). @default 'text' */
     readonly type: _angular_core.InputSignal<KtTextFieldType>;
+    /** Plancher de caractères (attribut `minlength` natif ; poussé par le validateur minLength). @default undefined */
+    readonly minLength: _angular_core.InputSignal<number | undefined>;
+    /** Plafond de caractères (attribut `maxlength` natif ; poussé par le validateur maxLength). @default undefined */
+    readonly maxLength: _angular_core.InputSignal<number | undefined>;
+    /** Motifs de validation (contrat Signal Forms). L'attribut natif `pattern` ne prend qu'une regex →
+        seule la première est posée. @default [] */
+    readonly pattern: _angular_core.InputSignal<readonly RegExp[]>;
+    /** Source de la première regex pour l'attribut `pattern` natif (`null` si aucune). */
+    protected readonly patternAttr: _angular_core.Signal<string>;
     /** Suggestions d'autocomplétion proposées via un `<datalist>` natif (la saisie reste libre).
         Valeurs simples (`string[]`) ou couples `{ value, label }` pour distinguer libellé affiché et
         valeur insérée. @default undefined */
@@ -289,12 +484,12 @@ declare class KtTextField extends KtBaseInputField<string> implements FormValueC
     private readonly uid;
     protected readonly datalistId: string;
     protected readonly hasSuggestions: _angular_core.Signal<boolean>;
-    protected readonly datalistOptions: _angular_core.Signal<readonly KtDatalistOption[]>;
+    protected readonly datalistOptions: _angular_core.Signal<readonly _ktortu_aaa_forms.KtDatalistOption[]>;
     protected parse(raw: string): string;
     protected emptyValue(): string;
     protected isEmpty(value: string): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtTextField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtTextField, "kt-text-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ktFieldHelp]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtTextField, "kt-text-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ktFieldHelp]"], true, never>;
 }
 
 /**
@@ -316,11 +511,13 @@ declare class KtSwitch implements FormValueControl<boolean> {
     /** Désactive la bascule (non actionnable). @default false */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Marque la bascule comme invalide (combiné à `touched`/`dirty` via l'`errorMatcher`). @default false */
-    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Affiche l'astérisque requis sur le libellé. @default false */
     readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** État « modifié » (entre dans la logique d'affichage des erreurs). @default false */
-    readonly dirty: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Validation asynchrone en cours (poussé par `[field]`) : pose `aria-busy` + `data-pending`. @default false */
+    readonly pending: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Erreurs de validation à afficher sous la bascule. @default [] */
     readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
     /** Identifiant logique du contrôle (à titre indicatif). @default '' */
@@ -336,7 +533,9 @@ declare class KtSwitch implements FormValueControl<boolean> {
     /** Stratégie décidant quand afficher les erreurs (sinon celle du `KT_FIELD_CONFIG`). @default undefined */
     readonly errorMatcher: _angular_core.InputSignal<KtFieldErrorMatcher | undefined>;
     /** Afficher toutes les erreurs au lieu de la première seule. @default KT_FIELD_CONFIG.showAllErrors ?? false */
-    readonly showAllErrors: _angular_core.InputSignal<boolean>;
+    readonly showAllErrors: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly switchBtn;
+    private readonly errorResolver;
     private readonly idGen;
     private readonly uid;
     protected readonly baseId: _angular_core.Signal<string>;
@@ -345,13 +544,18 @@ declare class KtSwitch implements FormValueControl<boolean> {
     protected readonly errorId: _angular_core.Signal<string>;
     private readonly matcher;
     protected readonly showInvalid: _angular_core.Signal<boolean>;
-    protected readonly displayedErrors: _angular_core.Signal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** Erreurs résolues (messages par défaut appliqués, suppressions `message: ''` écartées). */
+    protected readonly resolvedErrors: _angular_core.Signal<_ktortu_aaa_forms.KtFieldError[]>;
+    protected readonly displayedErrors: _angular_core.Signal<_ktortu_aaa_forms.KtFieldError[]>;
     protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
     protected readonly describedBy: _angular_core.Signal<string | null>;
+    constructor();
+    /** Focus le bouton bascule natif (utilisé par Signal Forms `focusBoundControl`). */
+    focus(options?: FocusOptions): void;
     protected toggle(): void;
     protected onSpacebar(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtSwitch, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtSwitch, "kt-switch", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "showAllErrors": { "alias": "showAllErrors"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtSwitch, "kt-switch", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "showAllErrors": { "alias": "showAllErrors"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
 }
 
 /**
@@ -366,9 +570,9 @@ declare class KtSwitch implements FormValueControl<boolean> {
  * @example
  * ```html
  * <kt-checkbox-group label="Centres d'intérêt" [(value)]="interests" required>
- *   <kt-checkbox [value]="'sport'" label="Sport" />
- *   <kt-checkbox [value]="'musique'" label="Musique" />
- *   <kt-checkbox [value]="'cinema'" label="Cinéma" />
+ *   <kt-checkbox [optionValue]="'sport'" label="Sport" />
+ *   <kt-checkbox [optionValue]="'musique'" label="Musique" />
+ *   <kt-checkbox [optionValue]="'cinema'" label="Cinéma" />
  * </kt-checkbox-group>
  * ```
  */
@@ -381,14 +585,18 @@ declare class KtCheckboxGroup<V> implements FormValueControl<V[]> {
     /** Désactive le groupe entier (hérité par chaque case enfant). @default false */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Marque le groupe comme invalide (combiné à `touched`/`dirty` via l'`errorMatcher`). @default false */
-    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Affiche l'astérisque requis et `aria-required` sur le groupe. @default false */
     readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** État « modifié » (entre dans la logique d'affichage des erreurs). @default false */
-    readonly dirty: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Validation asynchrone en cours (poussé par `[field]`) : pose `aria-busy` + `data-pending`. @default false */
+    readonly pending: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Erreurs de validation à afficher sous le groupe. @default [] */
     readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
-    /** Attribut `name` partagé (à titre indicatif). @default '' */
+    /** Nom logique du groupe, à titre INDICATIF : contrairement à `kt-radio-group` (où `name` est
+        propagé aux `<input>` natifs pour le regroupement radio), il n'est PAS répercuté sur les cases
+        enfants (les checkboxes n'ont pas besoin d'un `name` partagé). @default '' */
     readonly name: _angular_core.InputSignal<string>;
     /** id imposé (sélecteurs de test stables) ; sinon auto-généré, anti-collision. @default undefined */
     readonly id: _angular_core.InputSignal<string | undefined>;
@@ -401,9 +609,11 @@ declare class KtCheckboxGroup<V> implements FormValueControl<V[]> {
     /** Stratégie décidant quand afficher les erreurs (sinon celle du `KT_FIELD_CONFIG`). @default undefined */
     readonly errorMatcher: _angular_core.InputSignal<KtFieldErrorMatcher | undefined>;
     /** Afficher toutes les erreurs au lieu de la première seule. @default KT_FIELD_CONFIG.showAllErrors ?? false */
-    readonly showAllErrors: _angular_core.InputSignal<boolean>;
+    readonly showAllErrors: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Égalité des valeurs en mode objet (défaut : identité `===`). */
     readonly compareWith: _angular_core.InputSignal<((a: V, b: V) => boolean) | undefined>;
+    private readonly el;
+    private readonly errorResolver;
     private readonly idGen;
     private readonly uid;
     protected readonly baseId: _angular_core.Signal<string>;
@@ -412,16 +622,20 @@ declare class KtCheckboxGroup<V> implements FormValueControl<V[]> {
     protected readonly errorId: _angular_core.Signal<string>;
     private readonly matcher;
     protected readonly showInvalid: _angular_core.Signal<boolean>;
-    protected readonly displayedErrors: _angular_core.Signal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** Erreurs résolues (messages par défaut appliqués, suppressions `message: ''` écartées). */
+    protected readonly resolvedErrors: _angular_core.Signal<_ktortu_aaa_forms.KtFieldError[]>;
+    protected readonly displayedErrors: _angular_core.Signal<_ktortu_aaa_forms.KtFieldError[]>;
     protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
     protected readonly describedBy: _angular_core.Signal<string | null>;
     private readonly comparator;
     /** La valeur d'option d'un enfant est-elle dans la sélection ? (lu dans le `computed` enfant) */
     isSelected(optionValue: V): boolean;
+    /** Focus la première case activable (utilisé par Signal Forms `focusBoundControl`). */
+    focus(options?: FocusOptions): void;
     /** Ajoute/retire une valeur d'option de la sélection (émis par un enfant au `change` natif). */
     toggle(optionValue: V, checked: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtCheckboxGroup<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtCheckboxGroup<any>, "kt-checkbox-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "showAllErrors": { "alias": "showAllErrors"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtCheckboxGroup<any>, "kt-checkbox-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "showAllErrors": { "alias": "showAllErrors"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
 }
 
 /**
@@ -432,8 +646,9 @@ declare class KtCheckboxGroup<V> implements FormValueControl<V[]> {
  * DEUX MODES, selon la présence d'un `kt-checkbox-group` parent :
  *  - Autonome : `value` est l'état coché (`boolean`, two-way), intégré aux Signal Forms via
  *    `FormValueControl<boolean>` (même contrat que `kt-switch`).
- *  - Dans un groupe : `value` est la VALEUR d'option représentée ; l'état coché dérive de
- *    l'appartenance au tableau du groupe, et le (dé)cochage met à jour ce tableau.
+ *  - Dans un groupe : `optionValue` porte la VALEUR d'option représentée ; l'état coché dérive de
+ *    l'appartenance au tableau du groupe, et le (dé)cochage met à jour ce tableau. `value` est
+ *    alors ignoré (c'est le groupe qui détient la sélection).
  *
  * Libellé : `label` (texte) par défaut ; un contenu projeté le remplace visuellement pour les
  * rendus riches (carte/option), `ariaLabel` portant alors le nom accessible si besoin.
@@ -445,17 +660,21 @@ declare class KtCheckboxGroup<V> implements FormValueControl<V[]> {
  *
  * <!-- Dans un groupe -->
  * <kt-checkbox-group label="Centres d'intérêt" [(value)]="interests">
- *   <kt-checkbox [value]="'sport'" label="Sport" />
- *   <kt-checkbox [value]="'musique'" label="Musique" />
+ *   <kt-checkbox [optionValue]="'sport'" label="Sport" />
+ *   <kt-checkbox [optionValue]="'musique'" label="Musique" />
  * </kt-checkbox-group>
  * ```
  */
-declare class KtCheckbox<V = boolean> implements FormValueControl<V> {
+declare class KtCheckbox<V = unknown> implements FormValueControl<boolean> {
     private readonly config;
     /** Groupe parent optionnel : présent ⇒ la case appartient à un `kt-checkbox-group`. */
     protected readonly group: KtCheckboxGroup<V> | null;
-    /** Autonome : état coché (`boolean`, two-way). En groupe : la valeur d'option représentée. */
-    readonly value: _angular_core.ModelSignal<V>;
+    /** État coché (`boolean`, two-way) en mode autonome. Ignoré en mode groupe : c'est alors
+        `optionValue` + le tableau du groupe qui font foi. @default false */
+    readonly value: _angular_core.ModelSignal<boolean>;
+    /** Mode groupe uniquement : valeur d'option contribuée au tableau du `kt-checkbox-group` parent
+        quand la case est cochée. Sans effet en mode autonome. @default undefined */
+    readonly optionValue: _angular_core.InputSignal<V | undefined>;
     /** Tri-état visuel (parent d'une arborescence) : propriété DOM `indeterminate`, pas un attribut. */
     readonly indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** État « touché » (two-way), généralement piloté par `[formField]`. @default false */
@@ -463,11 +682,13 @@ declare class KtCheckbox<V = boolean> implements FormValueControl<V> {
     /** Désactive la case (héritable du groupe parent). @default false */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Marque la case comme invalide (combiné à `touched`/`dirty` via l'`errorMatcher`). @default false */
-    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Affiche l'astérisque requis et `aria-required`. @default false */
     readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** État « modifié » (entre dans la logique d'affichage des erreurs). @default false */
-    readonly dirty: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Validation asynchrone en cours (poussé par `[field]`) : pose `aria-busy` + `data-pending`. @default false */
+    readonly pending: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Erreurs de validation à afficher sous la case. @default [] */
     readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
     /** Attribut `name` du `<input>` natif. @default '' */
@@ -483,8 +704,10 @@ declare class KtCheckbox<V = boolean> implements FormValueControl<V> {
     /** Stratégie décidant quand afficher les erreurs (sinon celle du `KT_FIELD_CONFIG`). @default undefined */
     readonly errorMatcher: _angular_core.InputSignal<KtFieldErrorMatcher | undefined>;
     /** Afficher toutes les erreurs au lieu de la première seule. @default KT_FIELD_CONFIG.showAllErrors ?? false */
-    readonly showAllErrors: _angular_core.InputSignal<boolean>;
+    readonly showAllErrors: _angular_core.InputSignalWithTransform<boolean, unknown>;
     private readonly inputEl;
+    private readonly el;
+    private readonly errorResolver;
     private readonly idGen;
     private readonly uid;
     protected readonly baseId: _angular_core.Signal<string>;
@@ -497,14 +720,18 @@ declare class KtCheckbox<V = boolean> implements FormValueControl<V> {
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     private readonly matcher;
     protected readonly showInvalid: _angular_core.Signal<boolean>;
-    protected readonly displayedErrors: _angular_core.Signal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** Erreurs résolues (messages par défaut appliqués, suppressions `message: ''` écartées). */
+    protected readonly resolvedErrors: _angular_core.Signal<_ktortu_aaa_forms.KtFieldError[]>;
+    protected readonly displayedErrors: _angular_core.Signal<_ktortu_aaa_forms.KtFieldError[]>;
     protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
     protected readonly describedBy: _angular_core.Signal<string | null>;
     constructor();
+    /** Focus la case native (utilisé par Signal Forms `focusBoundControl`). */
+    focus(options?: FocusOptions): void;
     protected onChange(event: Event): void;
     protected onBlur(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtCheckbox<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtCheckbox<any>, "kt-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "showAllErrors": { "alias": "showAllErrors"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtCheckbox<any>, "kt-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "showAllErrors": { "alias": "showAllErrors"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
 }
 
 /**
@@ -520,9 +747,9 @@ declare class KtCheckbox<V = boolean> implements FormValueControl<V> {
  * @example
  * ```html
  * <kt-radio-group label="Civilité" [(value)]="civility" required>
- *   <kt-radio [value]="'mme'" label="Madame" />
- *   <kt-radio [value]="'m'" label="Monsieur" />
- *   <kt-radio [value]="'autre'" label="Autre" />
+ *   <kt-radio [optionValue]="'mme'" label="Madame" />
+ *   <kt-radio [optionValue]="'m'" label="Monsieur" />
+ *   <kt-radio [optionValue]="'autre'" label="Autre" />
  * </kt-radio-group>
  * ```
  */
@@ -535,11 +762,13 @@ declare class KtRadioGroup<V> implements FormValueControl<V | null> {
     /** Désactive le groupe entier (hérité par chaque radio enfant). @default false */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Marque le groupe comme invalide (combiné à `touched`/`dirty` via l'`errorMatcher`). @default false */
-    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Affiche l'astérisque requis et `aria-required` sur le groupe. @default false */
     readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** État « modifié » (entre dans la logique d'affichage des erreurs). @default false */
-    readonly dirty: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Validation asynchrone en cours (poussé par `[field]`) : pose `aria-busy` + `data-pending`. @default false */
+    readonly pending: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Erreurs de validation à afficher sous le groupe. @default [] */
     readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
     /** Base du `name` partagé par les radios enfants (sinon auto-généré). @default '' */
@@ -555,9 +784,11 @@ declare class KtRadioGroup<V> implements FormValueControl<V | null> {
     /** Stratégie décidant quand afficher les erreurs (sinon celle du `KT_FIELD_CONFIG`). @default undefined */
     readonly errorMatcher: _angular_core.InputSignal<KtFieldErrorMatcher | undefined>;
     /** Afficher toutes les erreurs au lieu de la première seule. @default KT_FIELD_CONFIG.showAllErrors ?? false */
-    readonly showAllErrors: _angular_core.InputSignal<boolean>;
+    readonly showAllErrors: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Égalité des valeurs en mode objet (défaut : identité `===`). Seul rescapé du contrat select. */
     readonly compareWith: _angular_core.InputSignal<((a: V, b: V) => boolean) | undefined>;
+    private readonly el;
+    private readonly errorResolver;
     private readonly idGen;
     private readonly uid;
     protected readonly baseId: _angular_core.Signal<string>;
@@ -568,16 +799,21 @@ declare class KtRadioGroup<V> implements FormValueControl<V | null> {
     protected readonly errorId: _angular_core.Signal<string>;
     private readonly matcher;
     protected readonly showInvalid: _angular_core.Signal<boolean>;
-    protected readonly displayedErrors: _angular_core.Signal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** Erreurs résolues (messages par défaut appliqués, suppressions `message: ''` écartées). */
+    protected readonly resolvedErrors: _angular_core.Signal<_ktortu_aaa_forms.KtFieldError[]>;
+    protected readonly displayedErrors: _angular_core.Signal<_ktortu_aaa_forms.KtFieldError[]>;
     protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
     protected readonly describedBy: _angular_core.Signal<string | null>;
     private readonly comparator;
-    /** Le `value` d'un enfant correspond-il à la sélection courante ? (lu dans le `computed` enfant) */
+    /** L'`optionValue` d'un enfant correspond-il à la sélection courante ? (lu dans le `computed` enfant) */
     isSelected(radioValue: V): boolean;
+    /** Focus l'option pertinente (utilisé par Signal Forms `focusBoundControl`) : le radio coché
+        s'il existe, sinon le premier radio activable — conforme au roving tabindex natif. */
+    focus(options?: FocusOptions): void;
     /** Commit d'une sélection émis par un enfant au `change` natif. */
     select(radioValue: V): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtRadioGroup<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtRadioGroup<any>, "kt-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "showAllErrors": { "alias": "showAllErrors"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtRadioGroup<any>, "kt-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "showAllErrors": { "alias": "showAllErrors"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
 }
 
 /**
@@ -589,15 +825,16 @@ declare class KtRadioGroup<V> implements FormValueControl<V | null> {
  * @example
  * ```html
  * <kt-radio-group label="Civilité" [(value)]="civility">
- *   <kt-radio [value]="'mme'" label="Madame" />
- *   <kt-radio [value]="'m'" label="Monsieur" />
+ *   <kt-radio [optionValue]="'mme'" label="Madame" />
+ *   <kt-radio [optionValue]="'m'" label="Monsieur" />
  * </kt-radio-group>
  * ```
  */
 declare class KtRadio<V> {
     protected readonly group: KtRadioGroup<V>;
-    /** Valeur d'option représentée par ce radio (sélectionnée ⇒ devient la valeur du groupe). @default (requis) */
-    readonly value: _angular_core.InputSignal<V>;
+    /** Valeur d'option représentée par ce radio (sélectionnée ⇒ devient la valeur du groupe). Nommée
+        `optionValue` pour s'aligner sur `kt-checkbox` (où `value` = état coché). @default (requis) */
+    readonly optionValue: _angular_core.InputSignal<V>;
     /** Texte du libellé (remplacé visuellement par un contenu projeté). @default undefined */
     readonly label: _angular_core.InputSignal<string | undefined>;
     /** Texte d'aide affiché sous le radio. @default undefined */
@@ -614,9 +851,11 @@ declare class KtRadio<V> {
     protected readonly hintId: _angular_core.Signal<string>;
     protected readonly checked: _angular_core.Signal<boolean>;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
+    private readonly el;
+    constructor();
     protected onChange(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtRadio<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtRadio<any>, "kt-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtRadio<any>, "kt-radio", never, { "optionValue": { "alias": "optionValue"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 /** Clé (propriété) OU fonction d'accès, pour dériver une valeur d'un item.
@@ -636,6 +875,7 @@ type KtKeyish<T, R> = keyof T | ((item: T) => R);
       ou la clé extraite quand `optionValue` est fourni). */
 declare abstract class KtBaseSelect<T, V = T> {
     protected readonly fieldConfig: Partial<_ktortu_aaa_forms.KtFieldConfig> | null;
+    private readonly errorResolver;
     protected readonly config: Partial<_ktortu_aaa_forms.KtSelectConfigOptions> | null;
     protected readonly host: ElementRef<HTMLElement>;
     private readonly ngZone;
@@ -660,15 +900,17 @@ declare abstract class KtBaseSelect<T, V = T> {
     /** Le champ a-t-il été visité ? Poussé par `[formField]` ; passe à `true` à la première sélection. @default false */
     readonly touched: _angular_core.ModelSignal<boolean>;
     /** Champ désactivé (trigger inerte). Poussé par `[formField]`. @default false */
-    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Champ en lecture seule (sélection figée, valeur affichée). Poussé par `[formField]`. @default false */
-    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Le champ est-il invalide ? Pilote l'affichage des erreurs. Poussé par `[formField]`. @default false */
-    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Champ obligatoire (marqueur visuel/ARIA). Poussé par `[formField]`. @default false */
-    readonly required: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Le champ a-t-il été modifié depuis sa valeur initiale ? Poussé par `[formField]`. @default false */
-    readonly dirty: _angular_core.InputSignal<boolean>;
+    readonly dirty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Validation asynchrone en cours (poussé par `[field]`) : pose `aria-busy` + `data-pending`. @default false */
+    readonly pending: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Erreurs de validation à afficher. Poussé par `[formField]`. @default [] */
     readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
     /** Attribut `name` logique du contrôle (à titre indicatif). @default '' */
@@ -689,9 +931,15 @@ declare abstract class KtBaseSelect<T, V = T> {
     readonly placeholder: _angular_core.InputSignal<string | undefined>;
     /** Quand afficher l'erreur ; surcharge KT_FIELD_CONFIG et le défaut (`invalid && touched`). @default undefined */
     readonly errorMatcher: _angular_core.InputSignal<KtFieldErrorMatcher | undefined>;
+    /** Apparence du chrome (`fill` | `outline`) ; non fournie ⇒ `KT_FIELD_CONFIG.appearance` ?? `'fill'`.
+        @default undefined */
+    readonly appearance: _angular_core.InputSignal<KtFieldAppearance | undefined>;
+    /** Politique du label flottant en outline (`auto` | `always`) ; non fournie ⇒ `KT_FIELD_CONFIG.floatLabel`
+        ?? `'auto'`. @default undefined */
+    readonly floatLabel: _angular_core.InputSignal<KtFloatLabel | undefined>;
     /** Affiche un champ de recherche en tête du popup (desktop) / de la sheet (téléphone).
-        Pour les listes longues ; le texte tapé ne sert qu'à filtrer (réinitialisé à la fermeture). */
-    readonly filterable: _angular_core.InputSignal<boolean>;
+        Pour les listes longues ; le texte tapé ne sert qu'à filtrer (réinitialisé à la fermeture). @default false */
+    readonly filterable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Placeholder du champ de recherche du popup. Défaut : `KT_SELECT_CONFIG.filterPlaceholder` ou vide. */
     readonly filterPlaceholder: _angular_core.InputSignal<string | undefined>;
     /** Libellé accessible du champ de recherche. Défaut : `KT_SELECT_CONFIG.filterLabel` ou « Filter options ». */
@@ -735,10 +983,7 @@ declare abstract class KtBaseSelect<T, V = T> {
     protected readonly resolvedFilterResultsText: Signal<(count: number) => string>;
     protected readonly resolvedTruncatedResultsText: Signal<(max: number, total: number) => string>;
     protected readonly resolvedTruncatedResultsAnnouncement: Signal<(max: number, total: number) => string>;
-    protected readonly fieldErrors: Signal<{
-        kind: string;
-        message: string | undefined;
-    }[]>;
+    protected readonly fieldErrors: Signal<_ktortu_aaa_forms.KtFieldError[]>;
     private readonly labelAccessor;
     private readonly valueAccessor;
     private readonly disabledAccessor;
@@ -782,6 +1027,11 @@ declare abstract class KtBaseSelect<T, V = T> {
         re-pousse rien (`listboxValue` n'a pas changé) — on resynchronise le modèle du Listbox
         avec les clés sélectionnées actuellement visibles. */
     protected resyncListboxSelection(): void;
+    /** Focus le trigger natif (utilisé par Signal Forms `focusBoundControl`). */
+    focus(options?: FocusOptions): void;
+    /** Referme le panneau et vide le filtre (utilisé par Signal Forms `reset`). La sélection du
+        listbox dérive de `value()` (computed) et se resynchronise seule. */
+    reset(): void;
     /** Desktop filtrable : le focus DOM vit dans le popup (champ/options) — on le rend au trigger
         à la fermeture, sinon il tombe sur `<body>`. (Écran compact : déjà géré par l'effect `compact`.) */
     protected refocusTriggerAfterFilterClose(): void;
@@ -791,7 +1041,7 @@ declare abstract class KtBaseSelect<T, V = T> {
     protected onDragStart(event: PointerEvent): void;
     private animateAndCloseSelect;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtBaseSelect<any, any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtBaseSelect<any, any>, never, never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "optionDisabled": { "alias": "optionDisabled"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "helpText": { "alias": "helpText"; "required": false; "isSignal": true; }; "helpLabel": { "alias": "helpLabel"; "required": false; "isSignal": true; }; "customDescribedBy": { "alias": "customDescribedBy"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "filterLabel": { "alias": "filterLabel"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "maxVisibleOptions": { "alias": "maxVisibleOptions"; "required": false; "isSignal": true; }; "truncatedResultsText": { "alias": "truncatedResultsText"; "required": false; "isSignal": true; }; "truncatedResultsAnnouncement": { "alias": "truncatedResultsAnnouncement"; "required": false; "isSignal": true; }; }, { "helpClick": "helpClick"; "touched": "touchedChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtBaseSelect<any, any>, never, never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "optionDisabled": { "alias": "optionDisabled"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "helpText": { "alias": "helpText"; "required": false; "isSignal": true; }; "helpLabel": { "alias": "helpLabel"; "required": false; "isSignal": true; }; "customDescribedBy": { "alias": "customDescribedBy"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "errorMatcher": { "alias": "errorMatcher"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "floatLabel": { "alias": "floatLabel"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "filterLabel": { "alias": "filterLabel"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "maxVisibleOptions": { "alias": "maxVisibleOptions"; "required": false; "isSignal": true; }; "truncatedResultsText": { "alias": "truncatedResultsText"; "required": false; "isSignal": true; }; "truncatedResultsAnnouncement": { "alias": "truncatedResultsAnnouncement"; "required": false; "isSignal": true; }; }, { "helpClick": "helpClick"; "touched": "touchedChange"; }, never, never, true, never>;
 }
 
 /** Contexte typé reçu par le template d'une option (`ktSelectOption`). */
@@ -863,7 +1113,12 @@ interface KtSelectSelectionChange<T, V = T> {
 
     @example
     ```html
-    <kt-select [options]="users" optionLabel="name" optionValue="id" [(value)]="selectedId" />
+    <kt-select
+      [options]="users"
+      optionLabel="name"
+      optionValue="id"
+      [(value)]="selectedId"
+      (selectionChange)="onSelectionChange($event)" />
     ``` */
 declare class KtSelect<T, V = T> extends KtBaseSelect<T, V> implements FormValueControl<V | null> {
     /** Valeur sélectionnée (clé extraite, ou objet entier si `optionValue` est omis ; `null` si rien). @default null */
@@ -932,6 +1187,13 @@ interface KtSelectConfigOptions {
     truncatedResultsAnnouncement: (max: number, total: number) => string;
 }
 declare const KT_SELECT_CONFIG: InjectionToken<Partial<KtSelectConfigOptions>>;
+/**
+ * Source UNIQUE des défauts (anglais neutre) de la config select / multi-select. Constitue le 3e
+ * maillon de la résolution `input() ?? KT_SELECT_CONFIG ?? DEFAULT_KT_SELECT_CONFIG`, jusqu'ici
+ * éparpillé entre `base-select.ts`, `multi-select.ts` et des fonctions locales. Centralisé ici pour
+ * éviter toute dérive et garantir la complétude des traductions (cf. test de complétude i18n).
+ */
+declare const DEFAULT_KT_SELECT_CONFIG: Required<KtSelectConfigOptions>;
 
 /** Configure les `kt-select` d'un sous-arbre via DI (équivalent du Context provider de react-select).
     Alternative à un provider global de `KT_SELECT_CONFIG` : on pose la directive sur un conteneur et
@@ -945,30 +1207,13 @@ declare const KT_SELECT_CONFIG: InjectionToken<Partial<KtSelectConfigOptions>>;
 
     La directive EST fournie comme `KT_SELECT_CONFIG` (`useExisting`) : les getters exposent l'objet
     bindé sous la forme `Partial<KtSelectConfigOptions>` attendue par le composant. */
-declare class KtSelectConfig implements Partial<KtSelectConfigOptions> {
+declare class KtSelectConfig {
     readonly ktSelectConfig: _angular_core.InputSignal<Partial<KtSelectConfigOptions>>;
     /** Config héritée du contexte parent (provider global ou directive englobante) : la
         directive ne masque que les clés qu'elle définit, le reste continue d'en hériter. */
     private readonly parent;
-    private resolve;
-    get placeholder(): string | undefined;
-    get emptyText(): string | undefined;
-    get closeLabel(): string | undefined;
-    get closeOnSelect(): boolean | undefined;
-    get filterPlaceholder(): string | undefined;
-    get filterLabel(): string | undefined;
-    get filterResultsText(): ((count: number) => string) | undefined;
-    get removeItemLabel(): ((itemLabel: string) => string) | undefined;
-    get selectedItemsLabel(): ((fieldLabel: string | undefined) => string) | undefined;
-    get selectionSummaryText(): ((count: number) => string) | undefined;
-    get itemRemovedText(): ((itemLabel: string) => string) | undefined;
-    get selectionCountText(): ((count: number) => string) | undefined;
-    get selectAllLabel(): string | undefined;
-    get clearAllLabel(): string | undefined;
-    get moreChipsLabel(): ((hiddenCount: number) => string) | undefined;
-    get lessChipsLabel(): string | undefined;
-    get truncatedResultsText(): ((max: number, total: number) => string) | undefined;
-    get truncatedResultsAnnouncement(): ((max: number, total: number) => string) | undefined;
+    /** Résout une clé : valeur bindée sur la directive, sinon valeur héritée du contexte parent. */
+    resolve<K extends keyof KtSelectConfigOptions>(key: K): Partial<KtSelectConfigOptions>[K];
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtSelectConfig, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtSelectConfig, "[ktSelectConfig]", never, { "ktSelectConfig": { "alias": "ktSelectConfig"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -1070,7 +1315,12 @@ interface KtMultiSelectSelectionChange<T, V = T> {
  *
  * @example
  * ```html
- * <kt-multi-select [options]="tags" optionLabel="name" optionValue="id" [(value)]="selectedIds" />
+ * <kt-multi-select
+ *   [options]="tags"
+ *   optionLabel="name"
+ *   optionValue="id"
+ *   [(value)]="selectedIds"
+ *   (selectionChange)="onSelectionChange($event)" />
  * ```
  */
 declare class KtMultiSelect<T, V = T> extends KtBaseSelect<T, V> implements FormValueControl<V[]> {
@@ -1180,7 +1430,11 @@ declare class KtChip {
     /** Émis au clic sur le bouton « retirer » (le parent décide de retirer le chip). */
     readonly remove: _angular_core.OutputEmitterRef<void>;
     private readonly removeBtn;
-    /** Focus programmatique du bouton « retirer » (focus management d'`kt-chip-list`). */
+    /**
+     * Focus programmatique du bouton « retirer ». Helper de coordination interne (focus management
+     * d'`kt-chip-list`), non destiné aux consommateurs.
+     * @internal
+     */
     focusRemove(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtChip, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtChip, "kt-chip", never, { "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; }, { "remove": "remove"; }, never, ["*"], true, never>;
@@ -1205,6 +1459,7 @@ interface KtChipItemContext<T> {
     </kt-chip-list>
     ``` */
 declare class KtChipItemDef<T> {
+    /** Liste des items rendus par ce template (sert aussi à inférer le type `T` du contexte). */
     readonly ktChipItem: _angular_core.InputSignal<readonly T[]>;
     readonly template: TemplateRef<KtChipItemContext<T>>;
     static ngTemplateContextGuard<T>(_dir: KtChipItemDef<T>, ctx: unknown): ctx is KtChipItemContext<T>;
@@ -1234,6 +1489,7 @@ declare class KtChipList<T> implements ChipTransitionScope {
     private readonly doc;
     private readonly platformId;
     private readonly cdr;
+    private readonly ngZone;
     /** Vrai pendant la View Transition de CETTE liste : les chips (standards via Chip,
         custom via tokens.css) ne portent leur `view-transition-name` que dans cette fenêtre. */
     readonly transitioning: _angular_core.WritableSignal<boolean>;
@@ -1338,8 +1594,8 @@ interface KtChipsConfig {
 declare const KT_CHIPS_CONFIG: InjectionToken<Partial<KtChipsConfig>>;
 
 /** Base partagée des champs Temporal (Date/Time/DateTime/YearMonth).
-    Toute la logique commune (parsing tolérant, valeur vide `null`, `displayValue` pour l'input
-    natif) vit ici ; chaque sous-classe ne fournit que la construction et la sérialisation propres
+    Toute la logique commune (parsing tolérant, valeur vide `null`, synchronisation de l'input natif)
+    vit ici ; chaque sous-classe ne fournit que la construction et la sérialisation propres
     à son type Temporal (`fromString` / `serialize`).
 
     Contrat abstrait : une sous-classe implémente uniquement le couple
@@ -1349,7 +1605,20 @@ declare const KT_CHIPS_CONFIG: InjectionToken<Partial<KtChipsConfig>>;
     tolérant (saisie partielle/invalide → `null`, jamais d'exception ni de valeur fausse).
 
     @template T Type Temporal porté par le champ (ex. `Temporal.PlainDate`,
-    `Temporal.PlainTime`, …). Doit exposer `toString()`. La valeur du champ est `T | null`. */
+    `Temporal.PlainTime`, …). Doit exposer `toString()`. La valeur du champ est `T | null`.
+
+    @example
+    ```ts
+    // Sous-classer : ne fournir que fromString (input natif → T) et serialize (T → input natif).
+    export class KtDateField extends KtBaseTemporalField<Temporal.PlainDate> {
+      protected override fromString(raw: string): Temporal.PlainDate {
+        return Temporal.PlainDate.from(raw);
+      }
+      protected override serialize(value: Temporal.PlainDate): string {
+        return value.toString();
+      }
+    }
+    ``` */
 declare abstract class KtBaseTemporalField<T extends {
     toString(): string;
 }> extends KtBaseInputField<T | null> {
@@ -1360,10 +1629,24 @@ declare abstract class KtBaseTemporalField<T extends {
     /** Sérialise la valeur au format attendu par l'input natif (précision adaptée au type). */
     protected abstract serialize(value: T): string;
     protected parse(raw: string): T | null;
+    protected displayValue(): string;
+    /** Efface AUSSI l'input natif. L'effet de synchro ignore une mise à `null` quand l'input est
+        focalisé (pour ne pas écraser une saisie partielle en cours), or `clear()` focalise justement
+        le champ — sans ce forçage, le bouton « effacer » (et Échap) resterait sans effet sur les
+        champs temporels. */
+    protected clear(): void;
     protected emptyValue(): T | null;
     protected isEmpty(value: T | null): boolean;
-    /** Représentation ISO pour l'attribut `[value]` de l'input natif (null → champ vide). */
-    protected readonly displayValue: _angular_core.Signal<string>;
+    /** Borne minimale autorisée (membre `min` du contrat `FormValueControl`, aussi posé en attribut
+        `min` natif via `serialize`). Non bornée par défaut. @default undefined */
+    readonly min: _angular_core.InputSignal<T | undefined>;
+    /** Borne maximale autorisée (membre `max` du contrat `FormValueControl`, aussi posé en attribut
+        `max` natif via `serialize`). Non bornée par défaut. @default undefined */
+    readonly max: _angular_core.InputSignal<T | undefined>;
+    /** Représentation ISO de `min` pour l'attribut natif (`null` quand non borné). */
+    protected readonly serializedMin: _angular_core.Signal<string | null>;
+    /** Représentation ISO de `max` pour l'attribut natif (`null` quand non borné). */
+    protected readonly serializedMax: _angular_core.Signal<string | null>;
     /** Suggestions proposées via un `<datalist>` natif (le picker date/heure reste disponible).
         Valeurs Temporal simples ou couples `{ value, label }` ; chaque valeur est sérialisée au
         format de l'input via `serialize`. @default undefined */
@@ -1372,11 +1655,64 @@ declare abstract class KtBaseTemporalField<T extends {
     private readonly uid;
     protected readonly datalistId: string;
     protected readonly hasSuggestions: _angular_core.Signal<boolean>;
-    protected readonly datalistOptions: _angular_core.Signal<readonly KtDatalistOption[]>;
+    protected readonly datalistOptions: _angular_core.Signal<readonly _ktortu_aaa_forms.KtDatalistOption[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtBaseTemporalField<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtBaseTemporalField<any>, never, never, { "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtBaseTemporalField<any>, never, never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Précision de saisie/sérialisation des champs Temporal porteurs d'une heure. */
+type KtTimePrecision = 'minute' | 'second';
+/** Base des champs Temporal porteurs d'une heure (`Time`, `DateTime`, `Instant`). Ajoute le réglage
+    `precision` qui pilote, d'un seul point, la sérialisation (`smallestUnit` du `toString`) et
+    l'attribut `step` natif de l'input — un input `time`/`datetime-local` n'affiche le sélecteur de
+    secondes que si `step` < 60. Les champs sans heure (`Date`, `YearMonth`) n'héritent pas de cette
+    base. Chaque sous-classe lit `precision()` dans son `serialize`.
+
+    @example
+    ```ts
+    // Sous-classer : lire precision() dans serialize pour piloter smallestUnit.
+    export class KtTimeField extends KtBaseTimeTemporalField<Temporal.PlainTime> {
+      protected override fromString(raw: string): Temporal.PlainTime {
+        return Temporal.PlainTime.from(raw);
+      }
+      protected override serialize(value: Temporal.PlainTime): string {
+        return value.toString({ smallestUnit: this.precision() });
+      }
+    }
+    ``` */
+declare abstract class KtBaseTimeTemporalField<T extends {
+    toString(): string;
+}> extends KtBaseTemporalField<T> {
+    /** Précision de l'heure : `'minute'` (secondes masquées) ou `'second'`.
+        @default 'minute' */
+    readonly precision: _angular_core.InputSignal<KtTimePrecision>;
+    /** Attribut `step` natif : `'1'` (seconde) en précision seconde, sinon `null` (pas natif = minute). */
+    protected readonly step: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtBaseTimeTemporalField<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtBaseTimeTemporalField<any>, never, never, { "precision": { "alias": "precision"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * Point d'import unique de Temporal pour toute la lib.
+ *
+ * - La **valeur** runtime `Temporal` vient de `globalThis.Temporal` : native sur Chrome/Edge 144+,
+ *   Firefox 139+, Node 26+ ; sinon posée par le polyfill chargé dans `main.ts`
+ *   (`temporal-polyfill/global`) ou `test-setup.ts`.
+ * - Les **types** (`TemporalNamespace.PlainDate`, …) viennent d'un `import type` (effacé au build
+ *   → 0 KB, le polyfill n'est jamais bundlé dans la lib).
+ *
+ * Convention : importer `{ Temporal, type TemporalNamespace }` — `Temporal` pour les appels
+ * (`Temporal.PlainDate.from(...)`), `TemporalNamespace` pour les annotations
+ * (`TemporalNamespace.PlainDate`). Le jour où le natif est garanti partout (Safari inclus), il
+ * suffira de retirer le polyfill de `main.ts` : ce fichier ne change pas.
+ */
+type TemporalImpl = (typeof temporal_polyfill)['Temporal'];
+/** Point d'accès `Temporal` de la lib. Proxy à résolution paresseuse : le namespace réel n'est lu
+    qu'au premier accès de propriété (`Temporal.PlainDate`…), jamais à l'import — ce qui supprime la
+    dépendance à l'ordre d'init des modules et fait booter Safari/WebKit tant que le polyfill est
+    importé dans `main.ts`. */
+declare const Temporal: TemporalImpl;
+
 /** Date civile (jour/mois/année), sans heure ni fuseau — alias de `Temporal.PlainDate`.
     À utiliser pour une date « pure » : naissance, échéance, jour d'un événement.
  *
@@ -1385,22 +1721,22 @@ declare abstract class KtBaseTemporalField<T extends {
  * import { type CalendarDate } from '@ktortu/aaa';
  * ```
  */
-type CalendarDate = Temporal.PlainDate;
+type CalendarDate = Temporal$1.PlainDate;
 /** Heure « au mur » (heure/minute/seconde), sans date ni fuseau — alias de `Temporal.PlainTime`.
     À utiliser pour une heure isolée : heure d'ouverture, créneau de rendez-vous récurrent. */
-type WallTime = Temporal.PlainTime;
+type WallTime = Temporal$1.PlainTime;
 /** Date + heure locale, sans fuseau — alias de `Temporal.PlainDateTime`.
     À utiliser quand date et heure comptent mais que le fuseau est implicite/non pertinent
     (heure « au mur » : ne représente pas un instant absolu). */
-type LocalDateTime = Temporal.PlainDateTime;
+type LocalDateTime = Temporal$1.PlainDateTime;
 /** Instant absolu sur la ligne du temps, en UTC — alias de `Temporal.Instant`.
     À utiliser pour horodater un événement réel (création, mesure) indépendamment du fuseau
     d'affichage ; la conversion en heure locale se fait à la présentation (via `KtClock`). */
-type Timestamp = Temporal.Instant;
+type Timestamp = Temporal$1.Instant;
 /** Instant + fuseau nommé (IANA) — alias de `Temporal.ZonedDateTime`.
     À utiliser quand le fuseau fait partie de la donnée (ex. « 14h00 à Paris ») et doit être
     conservé, contrairement à `Timestamp` qui ne porte pas de fuseau. */
-type ZonedTimestamp = Temporal.ZonedDateTime;
+type ZonedTimestamp = Temporal$1.ZonedDateTime;
 
 /** Champ « date sans heure » : valeur = `Temporal.PlainDate`, input natif `type="date"`.
  *
@@ -1409,13 +1745,13 @@ type ZonedTimestamp = Temporal.ZonedDateTime;
  * <kt-date-field label="Date de naissance" [(value)]="birthDate" />
  * ```
  */
-declare class KtDateField extends KtBaseTemporalField<Temporal.PlainDate> implements FormValueControl<Temporal.PlainDate | null> {
+declare class KtDateField extends KtBaseTemporalField<Temporal$1.PlainDate> implements FormValueControl<Temporal$1.PlainDate | null> {
     /** Valeur du champ : un `Temporal.PlainDate` (date civile sans heure ni fuseau).
         `null` = champ vide.
         @default null */
-    value: _angular_core.ModelSignal<Temporal.PlainDate | null>;
-    protected fromString(raw: string): Temporal.PlainDate;
-    protected serialize(value: Temporal.PlainDate): string;
+    value: _angular_core.ModelSignal<Temporal$1.PlainDate | null>;
+    protected fromString(raw: string): Temporal$1.PlainDate;
+    protected serialize(value: Temporal$1.PlainDate): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtDateField, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtDateField, "kt-date-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ktFieldHelp]"], true, never>;
 }
@@ -1427,13 +1763,13 @@ declare class KtDateField extends KtBaseTemporalField<Temporal.PlainDate> implem
  * <kt-time-field label="Heure de rendez-vous" [(value)]="appointmentTime" />
  * ```
  */
-declare class KtTimeField extends KtBaseTemporalField<Temporal.PlainTime> implements FormValueControl<Temporal.PlainTime | null> {
+declare class KtTimeField extends KtBaseTimeTemporalField<Temporal$1.PlainTime> implements FormValueControl<Temporal$1.PlainTime | null> {
     /** Valeur du champ : un `Temporal.PlainTime` (heure « au mur », sans date ni fuseau).
         `null` = champ vide.
         @default null */
-    value: _angular_core.ModelSignal<Temporal.PlainTime | null>;
-    protected fromString(raw: string): Temporal.PlainTime;
-    protected serialize(value: Temporal.PlainTime): string;
+    value: _angular_core.ModelSignal<Temporal$1.PlainTime | null>;
+    protected fromString(raw: string): Temporal$1.PlainTime;
+    protected serialize(value: Temporal$1.PlainTime): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtTimeField, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtTimeField, "kt-time-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ktFieldHelp]"], true, never>;
 }
@@ -1446,13 +1782,13 @@ declare class KtTimeField extends KtBaseTemporalField<Temporal.PlainTime> implem
  * <kt-date-time-field label="Début de l'événement" [(value)]="startsAt" />
  * ```
  */
-declare class KtDateTimeField extends KtBaseTemporalField<Temporal.PlainDateTime> implements FormValueControl<Temporal.PlainDateTime | null> {
+declare class KtDateTimeField extends KtBaseTimeTemporalField<Temporal$1.PlainDateTime> implements FormValueControl<Temporal$1.PlainDateTime | null> {
     /** Valeur du champ : un `Temporal.PlainDateTime` (date + heure « au mur », sans fuseau).
         `null` = champ vide.
         @default null */
-    value: _angular_core.ModelSignal<Temporal.PlainDateTime | null>;
-    protected fromString(raw: string): Temporal.PlainDateTime;
-    protected serialize(value: Temporal.PlainDateTime): string;
+    value: _angular_core.ModelSignal<Temporal$1.PlainDateTime | null>;
+    protected fromString(raw: string): Temporal$1.PlainDateTime;
+    protected serialize(value: Temporal$1.PlainDateTime): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtDateTimeField, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtDateTimeField, "kt-date-time-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ktFieldHelp]"], true, never>;
 }
@@ -1465,13 +1801,13 @@ declare class KtDateTimeField extends KtBaseTemporalField<Temporal.PlainDateTime
  * <kt-year-month-field label="Expiration" [(value)]="cardExpiry" />
  * ```
  */
-declare class KtYearMonthField extends KtBaseTemporalField<Temporal.PlainYearMonth> implements FormValueControl<Temporal.PlainYearMonth | null> {
+declare class KtYearMonthField extends KtBaseTemporalField<Temporal$1.PlainYearMonth> implements FormValueControl<Temporal$1.PlainYearMonth | null> {
     /** Valeur du champ : un `Temporal.PlainYearMonth` (mois + année, sans jour ni fuseau).
         `null` = champ vide.
         @default null */
-    value: _angular_core.ModelSignal<Temporal.PlainYearMonth | null>;
-    protected fromString(raw: string): Temporal.PlainYearMonth;
-    protected serialize(value: Temporal.PlainYearMonth): string;
+    value: _angular_core.ModelSignal<Temporal$1.PlainYearMonth | null>;
+    protected fromString(raw: string): Temporal$1.PlainYearMonth;
+    protected serialize(value: Temporal$1.PlainYearMonth): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtYearMonthField, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtYearMonthField, "kt-year-month-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ktFieldHelp]"], true, never>;
 }
@@ -1490,20 +1826,20 @@ declare class KtYearMonthField extends KtBaseTemporalField<Temporal.PlainYearMon
  * <kt-instant-field label="Horodatage" [(value)]="recordedAt" />
  * ```
  */
-declare class KtInstantField extends KtBaseTemporalField<Temporal.Instant> implements FormValueControl<Temporal.Instant | null> {
+declare class KtInstantField extends KtBaseTimeTemporalField<Temporal$1.Instant> implements FormValueControl<Temporal$1.Instant | null> {
     private readonly clock;
     /** Valeur du champ : un `Temporal.Instant` (instant absolu en UTC), saisi/affiché en heure
         locale via `KtClock`. `null` = champ vide.
         @default null */
-    value: _angular_core.ModelSignal<Temporal.Instant | null>;
-    protected fromString(raw: string): Temporal.Instant;
-    protected serialize(value: Temporal.Instant): string;
+    value: _angular_core.ModelSignal<Temporal$1.Instant | null>;
+    protected fromString(raw: string): Temporal$1.Instant;
+    protected serialize(value: Temporal$1.Instant): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtInstantField, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtInstantField, "kt-instant-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ktFieldHelp]"], true, never>;
 }
 
 /** Valeurs Temporal formatables pour l'affichage (toutes exposent `toLocaleString`). */
-type FormattableTemporal = Temporal.PlainDate | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.PlainYearMonth | Temporal.Instant | Temporal.ZonedDateTime;
+type FormattableTemporal = Temporal$1.PlainDate | Temporal$1.PlainTime | Temporal$1.PlainDateTime | Temporal$1.PlainYearMonth | Temporal$1.Instant | Temporal$1.ZonedDateTime;
 /** Formate une valeur Temporal pour l'affichage selon la locale active.
     `DatePipe` n'accepte pas Temporal (seulement `Date|string|number`) → pipe dédié, basé sur
     `toLocaleString` (interface `Intl.DateTimeFormat`). Cohérent avec la neutralité i18n de la lib
@@ -1524,6 +1860,13 @@ type FormattableTemporal = Temporal.PlainDate | Temporal.PlainTime | Temporal.Pl
 declare class KtTemporalDatePipe implements PipeTransform {
     private readonly locale;
     private readonly clock;
+    /** Formate la valeur Temporal en chaîne localisée via `toLocaleString`.
+     * @param value Valeur Temporal à formater (`Plain*`, `Instant` ou `ZonedDateTime`) ; `null`/`undefined` → chaîne vide.
+     * @param options Options `Intl.DateTimeFormatOptions` transmises telles quelles. Styles globaux :
+     *   `dateStyle`/`timeStyle` (`'full' | 'long' | 'medium' | 'short'`). Champs fins :
+     *   `weekday`/`era`/`month` (`'long' | 'short' | 'narrow'`), `year`/`day`/`hour`/`minute`/`second`
+     *   (`'numeric' | '2-digit'`), `hour12`, `timeZoneName`, `timeZone`, etc. Omis → format par défaut de la locale.
+     * @returns La chaîne formatée selon la locale active (`LOCALE_ID`), ou `''` si la valeur est absente. */
     transform(value: FormattableTemporal | null | undefined, options?: Intl.DateTimeFormatOptions): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtTemporalDatePipe, never>;
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<KtTemporalDatePipe, "temporalDate", true>;
@@ -1539,10 +1882,10 @@ declare class KtClock {
     timeZoneId(): string;
     /** Instant absolu courant, sur la ligne du temps (UTC), indépendant du fuseau.
         @returns L'instant présent en `Temporal.Instant`. */
-    now(): Temporal.Instant;
+    now(): Temporal$1.Instant;
     /** Date civile du jour telle qu'observée dans le fuseau local (`timeZoneId()`).
         @returns Le jour courant en `Temporal.PlainDate`. */
-    today(): Temporal.PlainDate;
+    today(): Temporal$1.PlainDate;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtClock, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<KtClock>;
 }
@@ -1564,11 +1907,11 @@ declare class KtFixedClock extends KtClock {
      * });
      * ```
      */
-    constructor(fixedInstant: Temporal.Instant, zone: string);
+    constructor(fixedInstant: Temporal$1.Instant, zone: string);
     timeZoneId(): string;
-    now(): Temporal.Instant;
-    today(): Temporal.PlainDate;
+    now(): Temporal$1.Instant;
+    today(): Temporal$1.PlainDate;
 }
 
-export { KT_CHIPS_CONFIG, KT_FIELD, KT_FIELD_CONFIG, KT_SELECT_CONFIG, KtBaseTemporalField, KtCheckbox, KtCheckboxGroup, KtChip, KtChipItemDef, KtChipList, KtClock, KtDateField, KtDateTimeField, KtField, KtFieldControl, KtFixedClock, KtInstantField, KtMultiSelect, KtMultiSelectChipDef, KtMultiSelectOptionDef, KtMultiSelectTriggerDef, KtNumberField, KtRadio, KtRadioGroup, KtSelect, KtSelectConfig, KtSelectOptionDef, KtSelectTriggerDef, KtSwitch, KtTemporalDatePipe, KtTextArea, KtTextField, KtTimeField, KtYearMonthField, defaultKtFieldErrorMatcher };
-export type { CalendarDate, KtChipItemContext, KtChipsConfig, KtFieldConfig, KtFieldError, KtFieldErrorMatcher, KtFieldErrorState, KtFieldParent, KtKeyish, KtMultiSelectChipContext, KtMultiSelectOptionContext, KtMultiSelectSelectionChange, KtMultiSelectTriggerContext, KtSelectConfigOptions, KtSelectOptionContext, KtSelectSelectionChange, KtSelectTriggerContext, KtSuggestion, KtTextFieldType, LocalDateTime, Timestamp, WallTime, ZonedTimestamp };
+export { DEFAULT_KT_SELECT_CONFIG, KT_CHIPS_CONFIG, KT_DEFAULT_FIELD_ERROR_MESSAGES, KT_FIELD, KT_FIELD_CONFIG, KT_SELECT_CONFIG, KtBaseInputField, KtBaseSelect, KtBaseTemporalField, KtBaseTimeTemporalField, KtCheckbox, KtCheckboxGroup, KtChip, KtChipItemDef, KtChipList, KtClock, KtDateField, KtDateTimeField, KtField, KtFieldControl, KtFieldErrorResolver, KtFixedClock, KtInstantField, KtMultiSelect, KtMultiSelectChipDef, KtMultiSelectOptionDef, KtMultiSelectTriggerDef, KtNumberField, KtRadio, KtRadioGroup, KtSelect, KtSelectConfig, KtSelectOptionDef, KtSelectTriggerDef, KtSwitch, KtTemporalDatePipe, KtTextArea, KtTextField, KtTimeField, KtYearMonthField, Temporal, defaultKtFieldErrorMatcher, ktErrorParam, normalizeKtSuggestions, provideKtField };
+export type { CalendarDate, KtChipItemContext, KtChipsConfig, KtDatalistOption, KtErrorMessageFactory, KtFieldAppearance, KtFieldConfig, KtFieldError, KtFieldErrorMatcher, KtFieldErrorMessages, KtFieldErrorState, KtFieldParent, KtFloatLabel, KtKeyish, KtMultiSelectChipContext, KtMultiSelectOptionContext, KtMultiSelectSelectionChange, KtMultiSelectTriggerContext, KtResolvableError, KtSelectConfigOptions, KtSelectOptionContext, KtSelectSelectionChange, KtSelectTriggerContext, KtSuggestion, KtTextFieldType, KtTimePrecision, LocalDateTime, Timestamp, WallTime, ZonedTimestamp };