@ktortu/aaa 0.1.0-beta.0

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

@@ -0,0 +1,1574 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, 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 * 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';
+export { Temporal as TemporalNamespace } from 'temporal-polyfill';
+
+/** État d'un champ pertinent pour décider de l'affichage des erreurs. */
+interface KtFieldErrorState {
+    invalid: boolean;
+    touched: boolean;
+    dirty: boolean;
+}
+/** Décide QUAND afficher les erreurs d'un champ (équivalent signal de l'ErrorStateMatcher Material). */
+type KtFieldErrorMatcher = (state: KtFieldErrorState) => boolean;
+/** 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).
+    Lib neutre i18n : les textes sont fournis par le consommateur, ici en une fois.
+    Fourni en `Partial` : un consommateur n'override que ce qu'il veut. */
+interface KtFieldConfig {
+    /** Libellé accessible du bouton d'effacement. */
+    clearLabel: string;
+    /** Libellé accessible du bouton d'aide (i18n). */
+    helpLabel: string;
+    /** Quand afficher les erreurs. Défaut : `invalid && touched`. */
+    errorMatcher: KtFieldErrorMatcher;
+    /** Masquer le hint quand l'erreur s'affiche (façon Material). Défaut : `false`. */
+    hideHintWhenInvalid: boolean;
+    /** Afficher toutes les erreurs au lieu de la première seule. Défaut : `false`. */
+    showAllErrors: boolean;
+}
+declare const KT_FIELD_CONFIG: InjectionToken<Partial<KtFieldConfig>>;
+/** Parent field interface representing shared states for its controls. */
+interface KtFieldParent {
+    readonly baseId: Signal<string>;
+    readonly describedBy: Signal<string | null>;
+    readonly invalid: Signal<boolean>;
+    readonly required: Signal<boolean>;
+}
+declare const KT_FIELD: InjectionToken<KtFieldParent>;
+
+/** Forme minimale d'une erreur affichable — découple `Field` de Signal Forms. */
+interface KtFieldError {
+    kind: string;
+    message?: string;
+}
+/** Chrome de champ agnostique du système de forms : label + contrôle projeté + hint + erreur,
+    et centralisation du câblage a11y. Nourri par des inputs simples.
+
+    @example
+    ```html
+    <kt-field label="E-mail" hint="Nous ne partagerons jamais votre adresse." [invalid]="emailInvalid()" [errors]="emailErrors()" required>
+      <input ktFieldControl type="email" [(ngModel)]="email" />
+    </kt-field>
+    ``` */
+declare class KtField implements KtFieldParent {
+    private readonly config;
+    /** Libellé du champ. @default undefined */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Texte d'aide affiché sous le contrôle. @default undefined */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    /** Contenu de l'aide contextuelle (texte ou `TemplateRef`) rendu dans le tooltip d'aide. @default undefined */
+    readonly helpText: _angular_core.InputSignal<string | TemplateRef<unknown> | undefined>;
+    /** Libellé accessible du déclencheur d'aide. @default KT_FIELD_CONFIG.helpLabel ?? 'Help' */
+    readonly helpLabel: _angular_core.InputSignal<string>;
+    /** id(s) externe(s) à ajouter à l'`aria-describedby` du contrôle (découplage). @default undefined */
+    readonly customDescribedBy: _angular_core.InputSignal<string | undefined>;
+    /** Émis au clic sur le déclencheur d'aide (le `preventDefault`/`stopPropagation` est déjà appliqué). */
+    readonly helpClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    /** 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>;
+    /** 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 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>;
+    private readonly control;
+    private readonly templateTooltip;
+    private readonly projectedTooltip;
+    private readonly activeTooltip;
+    private readonly idGen;
+    private readonly uid;
+    readonly baseId: _angular_core.Signal<string>;
+    protected readonly labelId: _angular_core.Signal<string>;
+    protected readonly hintId: _angular_core.Signal<string>;
+    protected readonly errorId: _angular_core.Signal<string>;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly showHint: _angular_core.Signal<boolean>;
+    protected readonly displayedErrors: _angular_core.Signal<readonly KtFieldError[]>;
+    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>;
+}
+
+/** 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). */
+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>;
+    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;
+}
+
+/** 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. */
+declare abstract class KtBaseInputField<T> {
+    protected readonly config: Partial<_ktortu_aaa_forms.KtFieldConfig> | null;
+    /** 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>;
+    /** Rend le champ en lecture seule (valeur visible, non modifiable). @default false */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Le champ est-il en erreur (état fourni par la validation). @default false */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Marque le champ comme requis (ajoute `aria-required`). @default false */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /** Le champ a-t-il été modifié depuis sa valeur initiale. @default false */
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    /** 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. */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    /** Libellé du champ (associé via `<label for>`). */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Texte d'aide affiché sous le champ quand il est valide. */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    /** Aide contextuelle riche : texte ou `TemplateRef` projeté dans une infobulle d'aide. */
+    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). */
+    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. */
+    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. */
+    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`. */
+    readonly prefix: _angular_core.InputSignal<string | TemplateRef<unknown> | undefined>;
+    /** Contenu décoratif en fin de champ : texte ou `TemplateRef`. */
+    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`). */
+    readonly errorMatcher: _angular_core.InputSignal<KtFieldErrorMatcher | undefined>;
+    protected readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement | HTMLTextAreaElement> | undefined>;
+    private readonly matcher;
+    protected readonly showInvalid: _angular_core.Signal<boolean>;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    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;
+    protected clear(): void;
+    /** Parse la saisie brute en valeur typée. */
+    protected abstract parse(raw: string): T;
+    /** Représentation « vide » de la valeur. */
+    protected abstract emptyValue(): 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>;
+}
+
+/**
+ * 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/
+ * préfixe/suffixe/erreurs) de `KtBaseInputField`.
+ *
+ * @example
+ * ```html
+ * <kt-number-field label="Quantité" [(value)]="qty" [min]="0" [step]="1" />
+ * ```
+ */
+declare class KtNumberField extends KtBaseInputField<number | null> implements FormValueControl<number | null> {
+    /** Valeur saisie (two-way). `null` = champ vide. @default null */
+    readonly value: _angular_core.ModelSignal<number | null>;
+    /** Borne minimale (attribut `min` natif). @default undefined */
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    /** Borne maximale (attribut `max` natif). @default undefined */
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    /** Pas d'incrément (attribut `step` natif). @default undefined */
+    readonly step: _angular_core.InputSignal<number | undefined>;
+    /** Suggestions d'autocomplétion proposées via un `<datalist>` natif (la saisie reste libre).
+        Valeurs simples (`number[]`) ou couples `{ value, label }` pour distinguer libellé affiché et
+        valeur insérée. @default undefined */
+    readonly suggestions: _angular_core.InputSignal<readonly KtSuggestion<number>[] | undefined>;
+    private readonly idGen;
+    private readonly uid;
+    protected readonly datalistId: string;
+    protected readonly hasSuggestions: _angular_core.Signal<boolean>;
+    protected readonly datalistOptions: _angular_core.Signal<readonly KtDatalistOption[]>;
+    protected readonly rawValue: _angular_forms_signals.TransformedValueSignal<string>;
+    protected parse(raw: string): number | null;
+    protected onKeyDown(event: KeyboardEvent): void;
+    private adjustValue;
+    protected emptyValue(): number | null;
+    protected isEmpty(value: number | null): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtNumberField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtNumberField, "kt-number-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ktFieldHelp]"], true, never>;
+}
+
+/**
+ * Zone de texte multi-ligne (valeur `string`) intégrée aux Signal Forms via `FormValueControl`.
+ * Autosize en CSS (`field-sizing: content`) ; hérite de la présentation commune de `KtBaseInputField`.
+ *
+ * @example
+ * ```html
+ * <kt-text-area label="Commentaire" [(value)]="comment" [rows]="4" />
+ * ```
+ */
+declare class KtTextArea extends KtBaseInputField<string> implements FormValueControl<string> {
+    /** Valeur saisie (two-way). @default '' */
+    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>;
+    /** Plafond de caractères ; poussé par le form (validateur maxLength) ou par le consommateur. @default undefined */
+    readonly maxLength: _angular_core.InputSignal<number | undefined>;
+    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>;
+}
+
+/** Types texte dont la valeur reste une string (number/date = composants séparés). */
+type KtTextFieldType = 'text' | 'email' | 'password' | 'search' | 'tel' | 'url';
+/**
+ * Champ texte (valeur `string`) intégré aux Signal Forms via `FormValueControl`. Hérite de la
+ * présentation commune (label/hint/clear/préfixe/suffixe/erreurs) de `KtBaseInputField`.
+ *
+ * @example
+ * ```html
+ * <kt-text-field label="E-mail" type="email" [(value)]="email" required />
+ * ```
+ */
+declare class KtTextField extends KtBaseInputField<string> implements FormValueControl<string> {
+    /** Valeur saisie (two-way). @default '' */
+    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>;
+    /** 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 */
+    readonly suggestions: _angular_core.InputSignal<readonly KtSuggestion<string>[] | undefined>;
+    private readonly idGen;
+    private readonly uid;
+    protected readonly datalistId: string;
+    protected readonly hasSuggestions: _angular_core.Signal<boolean>;
+    protected readonly datalistOptions: _angular_core.Signal<readonly 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>;
+}
+
+/**
+ * Bouton bascule (Switch / Slide-Toggle) accessible conforme aux normes WAI-ARIA.
+ * Permet d'activer ou désactiver une option avec effet immédiat.
+ * Intégré aux Signal Forms de l'application via FormValueControl.
+ *
+ * @example
+ * ```html
+ * <kt-switch label="Notifications par e-mail" [(value)]="emailNotif" />
+ * ```
+ */
+declare class KtSwitch implements FormValueControl<boolean> {
+    private readonly config;
+    /** État de la bascule (two-way) : `true` = activé, `false` = désactivé. @default false */
+    readonly value: _angular_core.ModelSignal<boolean>;
+    /** État « touché » (two-way), généralement piloté par `[formField]`. @default false */
+    readonly touched: _angular_core.ModelSignal<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>;
+    /** 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>;
+    /** Erreurs de validation à afficher sous la bascule. @default [] */
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** Identifiant logique du contrôle (à titre indicatif). @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>;
+    /** Texte du libellé associé à la bascule. @default undefined */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Texte d'aide affiché sous la bascule (masqué quand une erreur s'affiche). @default undefined */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    /** Nom accessible (`aria-label`) quand `label` est absent. @default undefined */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** 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>;
+    private readonly idGen;
+    private readonly uid;
+    protected readonly baseId: _angular_core.Signal<string>;
+    protected readonly labelId: _angular_core.Signal<string>;
+    protected readonly hintId: _angular_core.Signal<string>;
+    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>[]>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    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>;
+}
+
+/**
+ * Groupe de cases à cocher (Checkbox Group) conforme à l'ARIA APG / RGAA.
+ * Orchestrateur : porte une valeur TABLEAU (`FormValueControl<V[]>`) et la sémantique de groupe
+ * (`role="group"`, légende, `aria-required`/`aria-invalid`, erreurs).
+ *
+ * Différence APG avec le radio-group : PAS de roving tabindex — chaque `kt-checkbox` reste
+ * tabbable et coche/décoche indépendamment. Les options sont fournies par le dev (boucle `@for`
+ * ou en dur) ; `compareWith` gère l'égalité quand les valeurs d'option sont des objets.
+ *
+ * @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-group>
+ * ```
+ */
+declare class KtCheckboxGroup<V> implements FormValueControl<V[]> {
+    private readonly config;
+    /** Sélection courante : tableau des valeurs d'options cochées (two-way). @default [] */
+    readonly value: _angular_core.ModelSignal<V[]>;
+    /** État « touché » (two-way), généralement piloté par `[formField]`. @default false */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** 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>;
+    /** 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>;
+    /** Erreurs de validation à afficher sous le groupe. @default [] */
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** Attribut `name` partagé (à titre indicatif). @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>;
+    /** Légende du groupe (`aria-labelledby`). @default undefined */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Texte d'aide affiché sous le groupe (masqué quand une erreur s'affiche). @default undefined */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    /** Nom accessible (`aria-label`) du groupe quand `label` est absent. @default undefined */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** 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>;
+    /** Égalité des valeurs en mode objet (défaut : identité `===`). */
+    readonly compareWith: _angular_core.InputSignal<((a: V, b: V) => boolean) | undefined>;
+    private readonly idGen;
+    private readonly uid;
+    protected readonly baseId: _angular_core.Signal<string>;
+    protected readonly labelId: _angular_core.Signal<string>;
+    protected readonly hintId: _angular_core.Signal<string>;
+    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>[]>;
+    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;
+    /** 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>;
+}
+
+/**
+ * Case à cocher (Checkbox) accessible conforme aux normes WAI-ARIA / RGAA.
+ * Bâtie sur un `<input type="checkbox">` NATIF (clavier, clic-label, état `indeterminate`,
+ * mode contraste élevé gratuits), redessinée via `appearance: none` + pseudo-éléments thémés.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * @example
+ * ```html
+ * <!-- Autonome -->
+ * <kt-checkbox label="Accepter les conditions" [(value)]="accepted" required />
+ *
+ * <!-- 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-group>
+ * ```
+ */
+declare class KtCheckbox<V = boolean> implements FormValueControl<V> {
+    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>;
+    /** 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 */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** 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>;
+    /** 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>;
+    /** Erreurs de validation à afficher sous la case. @default [] */
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    /** Attribut `name` du `<input>` natif. @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>;
+    /** Texte du libellé (remplacé visuellement par un contenu projeté). @default undefined */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Texte d'aide affiché sous la case (masqué quand une erreur s'affiche). @default undefined */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    /** Nom accessible (`aria-label`) pour une case sans libellé textuel. @default undefined */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** 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>;
+    private readonly inputEl;
+    private readonly idGen;
+    private readonly uid;
+    protected readonly baseId: _angular_core.Signal<string>;
+    protected readonly hintId: _angular_core.Signal<string>;
+    protected readonly errorId: _angular_core.Signal<string>;
+    /** Coché : appartenance au groupe le cas échéant, sinon l'état booléen propre.
+        (Nommé `isChecked` car `FormValueControl` réserve la propriété `checked`.) */
+    protected readonly isChecked: _angular_core.Signal<boolean>;
+    /** Désactivé : hérité du groupe le cas échéant. */
+    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>[]>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    constructor();
+    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>;
+}
+
+/**
+ * Groupe de boutons radio (Radio Group) conforme à l'ARIA APG / RGAA.
+ * Orchestrateur : porte la valeur (`FormValueControl<V | null>`), génère le `name` partagé et la
+ * sémantique de groupe (`role="radiogroup"`, légende, `aria-required`/`aria-invalid`, erreurs).
+ *
+ * Le clavier (roving tabindex + flèches qui déplacent ET cochent) est laissé au NATIF : les
+ * `<input type="radio">` des `kt-radio` enfants partagent le `name` du groupe — rien à réimplémenter.
+ * Les options sont fournies par le dev (boucle `@for` ou déclaration en dur) ; `compareWith` gère
+ * l'égalité quand `value` est un objet.
+ *
+ * @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-group>
+ * ```
+ */
+declare class KtRadioGroup<V> implements FormValueControl<V | null> {
+    private readonly config;
+    /** Valeur sélectionnée (two-way), ou `null` si aucune option n'est cochée. @default null */
+    readonly value: _angular_core.ModelSignal<V | null>;
+    /** État « touché » (two-way), généralement piloté par `[formField]`. @default false */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** 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>;
+    /** 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>;
+    /** 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 '' */
+    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>;
+    /** Légende du groupe (`aria-labelledby`). @default undefined */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Texte d'aide affiché sous le groupe (masqué quand une erreur s'affiche). @default undefined */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    /** Nom accessible (`aria-label`) du groupe quand `label` est absent. @default undefined */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** 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>;
+    /** É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 idGen;
+    private readonly uid;
+    protected readonly baseId: _angular_core.Signal<string>;
+    /** `name` partagé par les radios enfants → regroupement clavier NATIF (roving + flèches). */
+    readonly groupName: _angular_core.Signal<string>;
+    protected readonly labelId: _angular_core.Signal<string>;
+    protected readonly hintId: _angular_core.Signal<string>;
+    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>[]>;
+    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) */
+    isSelected(radioValue: V): boolean;
+    /** 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>;
+}
+
+/**
+ * Bouton radio individuel (enfant déclaratif de `kt-radio-group`).
+ * `<input type="radio">` NATIF partageant le `name` du groupe : clavier (roving + flèches) gratuit.
+ * Le libellé suit la même règle que la checkbox : `label` texte par défaut, contenu projeté en
+ * override visuel (carte sélectionnable), `ariaLabel` pour le nom accessible d'une option non-textuelle.
+ *
+ * @example
+ * ```html
+ * <kt-radio-group label="Civilité" [(value)]="civility">
+ *   <kt-radio [value]="'mme'" label="Madame" />
+ *   <kt-radio [value]="'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>;
+    /** 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 */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    /** Nom accessible (`aria-label`) pour une option sans libellé textuel. @default undefined */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Désactive ce radio (combiné à l'état désactivé du groupe). @default false */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** id imposé (sélecteurs de test stables) ; sinon auto-généré, anti-collision. @default undefined */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    private readonly idGen;
+    private readonly uid;
+    protected readonly baseId: _angular_core.Signal<string>;
+    protected readonly hintId: _angular_core.Signal<string>;
+    protected readonly checked: _angular_core.Signal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    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>;
+}
+
+/** Clé (propriété) OU fonction d'accès, pour dériver une valeur d'un item.
+    Partagé par les sélecteurs (BaseSelect) et les chips (ChipList). */
+type KtKeyish<T, R> = keyof T | ((item: T) => R);
+
+/** Base partagée des sélecteurs à liste fermée (Select single et MultiSelect), bâtis sur
+    `@angular/aria` (Combobox + Listbox) : options et dérivation (clé/fonction), état poussé
+    par `[formField]`, popup Popover responsive (dropdown ancré desktop ↔ bottom-sheet
+    téléphone, drag-to-dismiss), filtrage opt-in avec live region, clavier commun (Échap
+    global, Tab APG depuis le filtre). La VALEUR (`V | null` vs `V[]`) et `selectionChange`
+    restent dans les sous-classes : leurs types divergent, chacune implémente seule
+    `FormValueControl<…>`. Même pattern d'héritage que `BaseInputField`.
+
+    @template T Type d'une option (élément du tableau `options`).
+    @template V Type de la valeur émise par le contrôle (défaut `T` : l'objet entier ;
+      ou la clé extraite quand `optionValue` est fourni). */
+declare abstract class KtBaseSelect<T, V = T> {
+    protected readonly fieldConfig: Partial<_ktortu_aaa_forms.KtFieldConfig> | null;
+    protected readonly config: Partial<_ktortu_aaa_forms.KtSelectConfigOptions> | null;
+    protected readonly host: ElementRef<HTMLElement>;
+    private readonly ngZone;
+    protected readonly doc: Document;
+    private readonly platformId;
+    private readonly destroyRef;
+    private wasExpanded;
+    /** Liste des options affichées (source de vérité du contrôle). */
+    readonly options: _angular_core.InputSignal<readonly T[]>;
+    /** Libellé affiché d'une option : clé OU fonction. Défaut : `label`/`name`, sinon `String(option)`. */
+    readonly optionLabel: _angular_core.InputSignal<KtKeyish<T, string> | undefined>;
+    /** Dérive la valeur de sortie ET l'identité d'une option.
+        - Fourni (clé/fonction) ⇒ `value` = la/les clé(s) extraite(s).
+        - Omis ⇒ `value` = l'objet entier ; l'identité interne dérive de `id`/`value`. */
+    readonly optionValue: _angular_core.InputSignal<KtKeyish<T, V> | undefined>;
+    /** Désactivation d'une option : clé OU fonction renvoyant un booléen. Défaut : aucune option désactivée. */
+    readonly optionDisabled: _angular_core.InputSignal<KtKeyish<T, boolean> | undefined>;
+    /** Égalité des options en mode objet (présélection). Défaut : comparaison par identité (`id`/`value`). */
+    readonly compareWith: _angular_core.InputSignal<((a: T, b: T) => boolean) | undefined>;
+    /** Émis au clic sur le bouton d'aide contextuelle. */
+    readonly helpClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    /** 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>;
+    /** Champ en lecture seule (sélection figée, valeur affichée). Poussé par `[formField]`. @default false */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Le champ est-il invalide ? Pilote l'affichage des erreurs. Poussé par `[formField]`. @default false */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Champ obligatoire (marqueur visuel/ARIA). Poussé par `[formField]`. @default false */
+    readonly required: _angular_core.InputSignal<boolean>;
+    /** Le champ a-t-il été modifié depuis sa valeur initiale ? Poussé par `[formField]`. @default false */
+    readonly dirty: _angular_core.InputSignal<boolean>;
+    /** 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 '' */
+    readonly name: _angular_core.InputSignal<string>;
+    /** id imposé (sélecteurs de test stables) ; sinon auto-généré par Field. @default undefined */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    /** Libellé du champ (rendu par Field). @default undefined */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** 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` rendu 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). @default undefined */
+    readonly customDescribedBy: _angular_core.InputSignal<string | undefined>;
+    /** Texte indicatif affiché quand aucune option n'est sélectionnée. @default undefined */
+    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>;
+    /** 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>;
+    /** 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 ». */
+    readonly filterLabel: _angular_core.InputSignal<string | undefined>;
+    /** Prédicat de filtre custom `(option, texte tapé brut)`.
+        Défaut : libellé de l'option, insensible à la casse et aux accents. */
+    readonly filterFn: _angular_core.InputSignal<((option: T, query: string) => boolean) | undefined>;
+    /** Nombre maximal d'options affichées dans le DOM en mode filtrable pour optimiser les performances. @default 100 */
+    readonly maxVisibleOptions: _angular_core.InputSignal<number>;
+    /** Texte informatif de troncature des résultats (visuel). */
+    readonly truncatedResultsText: _angular_core.InputSignal<((max: number, total: number) => string) | undefined>;
+    /** Annonce de la troncature des résultats (live region). */
+    readonly truncatedResultsAnnouncement: _angular_core.InputSignal<((max: number, total: number) => string) | undefined>;
+    protected readonly expanded: _angular_core.WritableSignal<boolean>;
+    protected readonly viewport: KtViewport;
+    /** Écran compact (téléphone / fenêtre étroite) : bascule le popup en bottom-sheet modale.
+        Source unique configurable par appli (`KtViewport` / `provideKtBreakpoints`) ; pilote aussi
+        la classe CSS `kt-select__popup--sheet` du template. */
+    protected readonly compact: Signal<boolean>;
+    protected readonly triggerEl: Signal<ElementRef<HTMLElement> | undefined>;
+    protected readonly popupEl: Signal<ElementRef<HTMLElement> | undefined>;
+    private readonly idGen;
+    private readonly uid;
+    private readonly anchorName;
+    /** id du panneau (élément widget) en mode filtrable — cible de l'aria-controls du trigger. */
+    protected readonly panelId: string;
+    protected readonly filterInputEl: Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected readonly listboxEl: Signal<ElementRef<HTMLElement> | undefined>;
+    protected readonly listboxDir: Signal<Listbox<any> | undefined>;
+    protected readonly comboboxDir: Signal<Combobox | undefined>;
+    /** Suit l'état réel du Popover : la fermeture peut être synchrone (Tab) ET pilotée par
+        l'effect — sans ce flag, le second `hidePopover()` jetterait une InvalidStateError. */
+    private popoverShown;
+    private readonly matcher;
+    protected readonly showInvalid: Signal<boolean>;
+    protected readonly resolvedPlaceholder: Signal<string>;
+    protected readonly resolvedEmptyText: Signal<string>;
+    protected readonly resolvedCloseLabel: Signal<string>;
+    protected readonly resolvedFilterPlaceholder: Signal<string>;
+    protected readonly resolvedFilterLabel: Signal<string>;
+    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;
+    }[]>;
+    private readonly labelAccessor;
+    private readonly valueAccessor;
+    private readonly disabledAccessor;
+    /** Comparateur effectif en mode objet : `compareWith`, sinon égalité par identité. */
+    protected readonly comparator: Signal<(a: T, b: T) => boolean>;
+    protected labelOf(item: T): string;
+    protected keyOf(item: T): unknown;
+    protected disabledOf(item: T): boolean;
+    protected readonly filterText: _angular_core.WritableSignal<string>;
+    /** Annonce différée du nombre de résultats (live region `role="status"`). */
+    protected readonly announcedCount: _angular_core.WritableSignal<string>;
+    private announceTimer;
+    /** Options visibles : les options, restreintes par le filtre quand il est actif. */
+    protected readonly filteredOptions: Signal<readonly T[]>;
+    /** Les options affichées dans le DOM. La limitation (maxVisibleOptions) n'est appliquée qu'en mode filtrable. */
+    protected readonly displayedOptions: Signal<readonly T[]>;
+    /** Valeur poussée au ngListbox sous-jacent : tableau de clés (0/1 en single, N en multi). */
+    protected abstract readonly listboxValue: Signal<unknown[]>;
+    /** Réception des (dé)sélections du listbox — la sémantique de commit diverge (single/multi). */
+    protected abstract onListboxValueChange(keys: readonly unknown[]): void;
+    /** Texte de la live region du filtre. Virtuel : le multi y ajoute « , M selected ». */
+    protected composeFilterAnnouncement(): string;
+    constructor();
+    protected onFilterInput(event: Event): void;
+    /** Relaye la navigation vers le listbox : le focus DOM est dans le champ de filtre et les
+        keydown du popup ne remontent pas au combobox (le popup est un sibling DOM du trigger).
+        Shift+flèches : extension de plage (multi ; sans effet en single). Home/End/Espace/
+        caractères restent dans le champ (convention APG des combobox éditables). */
+    protected onFilterKeydown(event: KeyboardEvent): void;
+    /** Échap depuis n'importe où dans le composant popup ouvert : après un clic souris sur une
+        option, le focus DOM est sur le listbox (pas le trigger) — ni le listbox ni le combobox ne
+        gèrent Échap là. Le popup est rendu dans le sous-arbre DOM de l'hôte : l'événement y bulle.
+        (Trigger et champ de filtre gèrent leur Échap en amont avec stopPropagation : pas de doublon.) */
+    protected onHostKeydown(event: KeyboardEvent): void;
+    /** Annonce le contenu du filtre ~500 ms après la dernière frappe (évite le spam SR). */
+    protected scheduleResultsAnnouncement(): void;
+    /** Annonce immédiate dans la live region du panneau (annule une annonce différée en attente). */
+    protected announceNow(text: string): void;
+    /** Séquelle de la purge interne du Listbox (il vide sa valeur dès qu'un item n'est plus
+        rendu) : quand le filtre redécouvre des options sélectionnées, le binding `[value]` ne
+        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;
+    /** 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;
+    /** Fermeture synchrone du Popover (l'effect, différé, ne re-cachera pas : flag popoverShown). */
+    protected closePopupNow(): void;
+    private readonly sheetDrag;
+    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>;
+}
+
+/** Contexte typé reçu par le template d'une option (`ktSelectOption`). */
+interface KtSelectOptionContext<T> {
+    /** L'option en cours de rendu → `let-option`. */
+    $implicit: T;
+    /** L'option est-elle sélectionnée ? → `let-selected="selected"`. */
+    selected: boolean;
+    /** L'option est-elle active (survol/clavier) ? → `let-active="active"`. */
+    active: boolean;
+}
+/** Contexte typé reçu par le template du trigger (`ktSelectTrigger`). */
+interface KtSelectTriggerContext<T> {
+    /** L'option sélectionnée (ou `null`) → `let-option`. */
+    $implicit: T | null;
+}
+/** Template de rendu d'une option, posé sur un `<ng-template>` projeté dans `kt-select`.
+    L'input sert UNIQUEMENT à inférer `T` (re-bind de la liste d'options) ; `ngTemplateContextGuard`
+    type alors les variables `let-` (`option: T`, `selected`/`active: boolean`). Requiert `strictTemplates`.
+
+    ```html
+    <kt-select [options]="users" optionLabel="name">
+      <ng-template [ktSelectOption]="users" let-user let-selected="selected">
+        <user-badge [user]="user" /> @if (selected) { ✓ }
+      </ng-template>
+    </kt-select>
+    ``` */
+declare class KtSelectOptionDef<T> {
+    readonly ktSelectOption: _angular_core.InputSignal<readonly T[]>;
+    readonly template: TemplateRef<KtSelectOptionContext<T>>;
+    static ngTemplateContextGuard<T>(_dir: KtSelectOptionDef<T>, ctx: unknown): ctx is KtSelectOptionContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtSelectOptionDef<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtSelectOptionDef<any>, "ng-template[ktSelectOption]", never, { "ktSelectOption": { "alias": "ktSelectOption"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Template de rendu du trigger (libellé de la valeur courante). Même mécanisme typé que `ktSelectOption`.
+    Contexte : `let-option` = l'option sélectionnée (`T | null`).
+
+    ```html
+    <kt-select [options]="users" [(value)]="selected">
+      <ng-template [ktSelectTrigger]="users" let-user>
+        @if (user) { <user-badge [user]="user" /> } @else { Choisir… }
+      </ng-template>
+    </kt-select>
+    ``` */
+declare class KtSelectTriggerDef<T> {
+    readonly ktSelectTrigger: _angular_core.InputSignal<readonly T[]>;
+    readonly template: TemplateRef<KtSelectTriggerContext<T>>;
+    static ngTemplateContextGuard<T>(_dir: KtSelectTriggerDef<T>, ctx: unknown): ctx is KtSelectTriggerContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtSelectTriggerDef<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtSelectTriggerDef<any>, "ng-template[ktSelectTrigger]", never, { "ktSelectTrigger": { "alias": "ktSelectTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Payload de l'évènement `selectionChange` d'un `kt-select`. */
+interface KtSelectSelectionChange<T, V = T> {
+    /** Valeur émise : clé extraite ou objet entier (`null` si la sélection est effacée). */
+    value: V | null;
+    /** Option correspondante (`null` si la sélection est effacée). */
+    option: T | null;
+}
+/** Select single (« select-only combobox » WAI-ARIA) bâti sur `@angular/aria`.
+    Choix dans une liste fermée, sans saisie. Présentation responsive (un seul Popover, CSS @media) :
+    desktop = dropdown ancré (focus sur le trigger / activedescendant) ; téléphone tactile = bottom-sheet
+    en bas d'écran (focusMode 'roving', options réellement focusables, scrim ::backdrop, cibles ≥44px).
+    Composé avec `Field` ; s'intègre aux Signal Forms via `[formField]`.
+    Tout le commun (popup, filtre, clavier, drag-to-dismiss) vit dans `BaseSelect`.
+
+    @template T Type d'une option (élément du tableau `options`).
+    @template V Type de la valeur émise (défaut `T` ; clé extraite si `optionValue` est fourni).
+
+    @example
+    ```html
+    <kt-select [options]="users" optionLabel="name" optionValue="id" [(value)]="selectedId" />
+    ``` */
+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 */
+    readonly value: _angular_core.ModelSignal<V | null>;
+    /** Émis à chaque sélection. Payload : `{ value, option }` — `value` est la valeur émise (clé ou objet),
+        `option` l'objet option correspondant (`null` si la sélection est effacée). */
+    readonly selectionChange: _angular_core.OutputEmitterRef<KtSelectSelectionChange<T, V>>;
+    protected readonly optionDef: _angular_core.Signal<KtSelectOptionDef<any> | undefined>;
+    protected readonly triggerDef: _angular_core.Signal<KtSelectTriggerDef<any> | undefined>;
+    /** Fermer le popup après une sélection (sémantique single ; le multi reste ouvert). */
+    private readonly closeOnSelect;
+    /** Option correspondant à la valeur courante (clé extraite, ou objet si `optionValue` est omis). */
+    protected readonly selectedOption: _angular_core.Signal<T | null>;
+    /** Valeur du listbox : tableau de clés (0 ou 1 élément en single). */
+    protected readonly listboxValue: _angular_core.Signal<unknown[]>;
+    protected onListboxValueChange(keys: readonly unknown[]): void;
+    /** La sélection courante est-elle masquée par le filtre ou la troncation ? (≠ retirée des données). */
+    private isSelectionFilteredOut;
+    private commitSelection;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtSelect<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtSelect<any, any>, "kt-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "selectionChange": "selectionChange"; }, ["optionDef", "triggerDef"], ["[ktFieldHelp]"], true, never>;
+}
+
+/** Défauts applicables à tous les `kt-select` (surchargeables par champ via les inputs).
+    Lib neutre i18n : les textes sont fournis par le consommateur (ici en une fois).
+    Fourni en `Partial` : un consommateur n'override que ce qu'il veut.
+    Calqué sur `KT_FIELD_CONFIG`. */
+interface KtSelectConfigOptions {
+    /** Texte affiché quand aucune option n'est sélectionnée. */
+    placeholder: string;
+    /** Texte affiché quand la liste filtrée/d'options est vide. */
+    emptyText: string;
+    /** Libellé accessible du bouton de fermeture de la bottom-sheet mobile. */
+    closeLabel: string;
+    /** Fermer le popup après une sélection. Défaut (single) : `true`. */
+    closeOnSelect: boolean;
+    /** Placeholder du champ de filtre des select filtrables (`[filterable]`). */
+    filterPlaceholder: string;
+    /** Libellé accessible (aria-label) du champ de filtre. */
+    filterLabel: string;
+    /** Annonce du nombre de résultats du filtre (live region). Fonction : laisse le
+        consommateur gérer les pluriels i18n. Défaut : `'1 result'` / `'N results'`. */
+    filterResultsText: (count: number) => string;
+    /** Libellé accessible du bouton de retrait d'un chip. Défaut : `'Remove X'`. */
+    removeItemLabel: (itemLabel: string) => string;
+    /** Libellé accessible du conteneur de chips (reçoit le label du champ, pour
+        distinguer plusieurs multi-selects d'une page). Défaut : `'Selected items for X'`. */
+    selectedItemsLabel: (fieldLabel: string | undefined) => string;
+    /** Résumé affiché sur le trigger au-delà du seuil d'énumération. Défaut : `'N items selected'`. */
+    selectionSummaryText: (count: number) => string;
+    /** Annonce live après le retrait d'un élément (chip ou tout effacer). Défaut : `'X removed'`. */
+    itemRemovedText: (itemLabel: string) => string;
+    /** Compteur de sélection (live region du filtre, actions de masse). Défaut : `'N selected'`. */
+    selectionCountText: (count: number) => string;
+    /** Libellé du bouton « tout sélectionner » du popup (`[selectionActions]`). Défaut : `'Select all'`. */
+    selectAllLabel: string;
+    /** Libellé du bouton « tout effacer » du popup (`[selectionActions]`). Défaut : `'Clear all'`. */
+    clearAllLabel: string;
+    /** Libellé du bouton dépliant les chips repliés (`[maxVisibleChips]`). Défaut : `'+N more'`. */
+    moreChipsLabel: (hiddenCount: number) => string;
+    /** Libellé du même bouton une fois déplié. Défaut : `'Show less'`. */
+    lessChipsLabel: string;
+    /** Texte informatif de troncature des résultats (visuel). Défaut : `'Showing first X results of Y...'`. */
+    truncatedResultsText: (max: number, total: number) => string;
+    /** Annonce de la troncature des résultats (live region). Défaut : `'X results displayed out of Y...'`. */
+    truncatedResultsAnnouncement: (max: number, total: number) => string;
+}
+declare const KT_SELECT_CONFIG: InjectionToken<Partial<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
+    tous les `kt-select` descendants en héritent.
+
+    ```html
+    <div [ktSelectConfig]="{ placeholder: 'Choisir…', emptyText: 'Aucun résultat' }">
+      <kt-select … />
+    </div>
+    ```
+
+    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> {
+    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;
+    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>;
+}
+
+/** Contexte typé reçu par le template d'une option (`ktMultiSelectOption`). */
+interface KtMultiSelectOptionContext<T> {
+    /** L'option en cours de rendu → `let-option`. */
+    $implicit: T;
+    /** L'option est-elle sélectionnée ? → `let-selected="selected"`. */
+    selected: boolean;
+    /** L'option est-elle active (survol/clavier) ? → `let-active="active"`. */
+    active: boolean;
+}
+/** Contexte typé reçu par le template du trigger (`ktMultiSelectTrigger`). */
+interface KtMultiSelectTriggerContext<T> {
+    /** Les options sélectionnées (tableau d'objets) → `let-options`. */
+    $implicit: readonly T[];
+}
+/** Contexte typé reçu par le template de chip (`ktMultiSelectChip`). */
+interface KtMultiSelectChipContext<T> {
+    /** L'option sélectionnée correspondante → `let-option`. */
+    $implicit: T;
+    /** Fonction pour retirer cet élément de la sélection → `let-remove="remove"`. */
+    remove: () => void;
+}
+/** Template de rendu d'une option dans la liste du multi-select. L'input sert à inférer `T` ;
+    `ngTemplateContextGuard` type les variables `let-`.
+    Contexte : `let-option` = l'option (`T`), `let-selected` / `let-active` = booléens.
+
+    ```html
+    <kt-multi-select [options]="tags">
+      <ng-template [ktMultiSelectOption]="tags" let-tag let-selected="selected">
+        <tag-badge [tag]="tag" /> @if (selected) { ✓ }
+      </ng-template>
+    </kt-multi-select>
+    ``` */
+declare class KtMultiSelectOptionDef<T> {
+    readonly ktMultiSelectOption: _angular_core.InputSignal<readonly T[]>;
+    readonly template: TemplateRef<KtMultiSelectOptionContext<T>>;
+    static ngTemplateContextGuard<T>(_dir: KtMultiSelectOptionDef<T>, ctx: unknown): ctx is KtMultiSelectOptionContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtMultiSelectOptionDef<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtMultiSelectOptionDef<any>, "ng-template[ktMultiSelectOption]", never, { "ktMultiSelectOption": { "alias": "ktMultiSelectOption"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Template de rendu du trigger (contenu du bouton déclencheur) pour le multi-select.
+    Contexte : `let-options` = le tableau des options sélectionnées (`readonly T[]`).
+
+    ```html
+    <kt-multi-select [options]="tags">
+      <ng-template [ktMultiSelectTrigger]="tags" let-options>
+        @if (options.length) { {{ options.length }} sélectionné(s) } @else { Choisir… }
+      </ng-template>
+    </kt-multi-select>
+    ``` */
+declare class KtMultiSelectTriggerDef<T> {
+    readonly ktMultiSelectTrigger: _angular_core.InputSignal<readonly T[]>;
+    readonly template: TemplateRef<KtMultiSelectTriggerContext<T>>;
+    static ngTemplateContextGuard<T>(_dir: KtMultiSelectTriggerDef<T>, ctx: unknown): ctx is KtMultiSelectTriggerContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtMultiSelectTriggerDef<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtMultiSelectTriggerDef<any>, "ng-template[ktMultiSelectTrigger]", never, { "ktMultiSelectTrigger": { "alias": "ktMultiSelectTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Template de rendu d'un jeton (chip) affiché sous le multi-select.
+    Contexte : `let-option` = l'option sélectionnée (`T`), `let-remove` = fonction qui la retire.
+
+    ```html
+    <kt-multi-select [options]="tags">
+      <ng-template [ktMultiSelectChip]="tags" let-tag let-remove="remove">
+        <kt-chip [removable]="true" (remove)="remove()">{{ tag.name }}</kt-chip>
+      </ng-template>
+    </kt-multi-select>
+    ``` */
+declare class KtMultiSelectChipDef<T> {
+    readonly ktMultiSelectChip: _angular_core.InputSignal<readonly T[]>;
+    readonly template: TemplateRef<KtMultiSelectChipContext<T>>;
+    static ngTemplateContextGuard<T>(_dir: KtMultiSelectChipDef<T>, ctx: unknown): ctx is KtMultiSelectChipContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtMultiSelectChipDef<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtMultiSelectChipDef<any>, "ng-template[ktMultiSelectChip]", never, { "ktMultiSelectChip": { "alias": "ktMultiSelectChip"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Payload de l'évènement `selectionChange` d'un `kt-multi-select`. */
+interface KtMultiSelectSelectionChange<T, V = T> {
+    /** Valeurs émises : clés extraites ou objets entiers, dans l'ordre de sélection. */
+    value: V[];
+    /** Options correspondantes, dans l'ordre de sélection. */
+    options: T[];
+}
+/**
+ * Composant de sélection multiple (Multi-Select) conforme aux exigences d'accessibilité (WCAG 2.2 AAA / RGAA).
+ * Repose sur `@angular/aria/combobox` et `@angular/aria/listbox` avec [multi]="true".
+ * Présentation adaptative : dropdown (desktop) ou bottom-sheet modale (téléphone tactile).
+ * Option 1 : Résumé textuel sur le trigger et chips révocables affichés en dessous.
+ *
+ * Clavier multi-sélection (APG) : Espace/Entrée toggle, Shift+flèches étend la sélection,
+ * Ctrl+A tout (dé)sélectionne, Shift+Espace sélectionne la plage, typeahead — majoritairement
+ * natifs via `@angular/aria` ; les combos non relayés par la lib le sont via `onTriggerKeydown`.
+ * Tout le commun (popup, filtre, clavier, drag-to-dismiss) vit dans `BaseSelect`.
+ *
+ * @template T Type d'une option (élément du tableau `options`).
+ * @template V Type des valeurs émises (défaut `T` ; clés extraites si `optionValue` est fourni).
+ *
+ * @example
+ * ```html
+ * <kt-multi-select [options]="tags" optionLabel="name" optionValue="id" [(value)]="selectedIds" />
+ * ```
+ */
+declare class KtMultiSelect<T, V = T> extends KtBaseSelect<T, V> implements FormValueControl<V[]> {
+    /** Valeurs sélectionnées (clés extraites, ou objets entiers si `optionValue` est omis). @default [] */
+    readonly value: _angular_core.ModelSignal<V[]>;
+    /** Émis à chaque (dé)sélection. Payload : `{ value, options }` — `value` le tableau des valeurs émises
+        (clés ou objets), `options` les objets options correspondants, dans l'ordre de sélection. */
+    readonly selectionChange: _angular_core.OutputEmitterRef<KtMultiSelectSelectionChange<T, V>>;
+    /** Bouton « tout effacer » sur le champ (même contrat que `clearable` de BaseInputField). @default false */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Libellé i18n du bouton « tout effacer ». @default 'Clear' (ou KT_FIELD_CONFIG.clearLabel) */
+    readonly clearLabel: _angular_core.InputSignal<string>;
+    /** Barre « Tout sélectionner / Tout effacer » en tête du popup (bascule le popup en panneau dialog). */
+    readonly selectionActions: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Nombre maximal de chips affichés avant repli derrière un bouton « +N more ». Défaut : illimité. */
+    readonly maxVisibleChips: _angular_core.InputSignal<number | undefined>;
+    protected readonly optionDef: _angular_core.Signal<KtMultiSelectOptionDef<any> | undefined>;
+    protected readonly triggerDef: _angular_core.Signal<KtMultiSelectTriggerDef<any> | undefined>;
+    protected readonly chipDef: _angular_core.Signal<KtMultiSelectChipDef<any> | undefined>;
+    private readonly chipList;
+    protected readonly resolvedRemoveItemLabel: _angular_core.Signal<(itemLabel: string) => string>;
+    protected readonly resolvedSelectedItemsLabel: _angular_core.Signal<string>;
+    private readonly resolvedSelectionSummaryText;
+    protected readonly resolvedItemRemovedText: _angular_core.Signal<(itemLabel: string) => string>;
+    private readonly resolvedSelectionCountText;
+    protected readonly resolvedSelectAllLabel: _angular_core.Signal<string>;
+    protected readonly resolvedClearAllLabel: _angular_core.Signal<string>;
+    protected readonly resolvedMoreChipsLabel: _angular_core.Signal<(hiddenCount: number) => string>;
+    protected readonly resolvedLessChipsLabel: _angular_core.Signal<string>;
+    /** Accesseurs bridgés vers le ChipList (fonctions fléchées : une référence de méthode
+        non liée perdrait `this`). */
+    protected readonly chipLabelOf: (item: T) => string;
+    protected readonly chipKeyOf: (item: T) => unknown;
+    /** Options correspondant aux entrées de `value`, dans l'ordre de sélection.
+        Mode objet : chaque entrée est ramenée à l'option canonique équivalente (compareWith). */
+    protected readonly selectedOptions: _angular_core.Signal<T[]>;
+    protected readonly triggerText: _angular_core.Signal<string>;
+    /** Valeur brute transmise au ngListbox sous-jacent (tableau de clés). */
+    protected readonly listboxValue: _angular_core.Signal<unknown[]>;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    /** Le popup utilise la structure « panneau dialog » (champ de filtre et/ou barre d'actions). */
+    protected readonly dialogMode: _angular_core.Signal<boolean>;
+    /** Compteur de sélection affiché dans le panneau (info déjà portée par la live region → aria-hidden). */
+    protected readonly selectionCountLabel: _angular_core.Signal<string>;
+    /** Clé listbox d'une entrée de `value` (mode objet : clé de l'option canonique équivalente). */
+    private entryKey;
+    /** Entrée de `value` à committer pour une clé listbox (mode objet : l'option entière). */
+    private entryForKey;
+    protected onListboxValueChange(keys: readonly unknown[]): void;
+    private commitValue;
+    /** Comble les combos que le relay du combobox ne transmet pas en activedescendant :
+        Shift+Espace (sélection de plage) et Ctrl/Cmd+Shift+Home/End (plage jusqu'aux bornes). */
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    /** En panneau dialog, le relay du combobox vise le widget (la div), pas le listbox descendant :
+        on fait suivre au listbox les événements relayés (target = la div elle-même uniquement —
+        les keydown des éléments internes, qui bubblent, ne sont pas re-forwardés). */
+    protected onPanelKeydown(event: KeyboardEvent): void;
+    /** « N results » + « , M selected » quand des sélections existent (dont celles hors filtre). */
+    protected composeFilterAnnouncement(): string;
+    /** Retire une option de la valeur (annonce et focus : délégués au ChipList). */
+    protected removeOption(option: T): void;
+    private removeFromValue;
+    /** Vide toute la sélection depuis le champ (bouton `clearable`). */
+    protected clearSelection(): void;
+    /** Sélectionne toutes les options visibles non désactivées (sémantique du Ctrl+A natif :
+        avec un filtre actif, seules les options filtrées sont concernées). */
+    protected selectAllFiltered(): void;
+    /** Désélectionne toutes les options visibles (les sélections masquées par le filtre restent). */
+    protected clearAllFiltered(): void;
+    /** Annonce immédiate (action ponctuelle, pas de débounce) du total sélectionné. */
+    private announceSelectionCount;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtMultiSelect<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtMultiSelect<any, any>, "kt-multi-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "selectionActions": { "alias": "selectionActions"; "required": false; "isSignal": true; }; "maxVisibleChips": { "alias": "maxVisibleChips"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "selectionChange": "selectionChange"; }, ["optionDef", "triggerDef", "chipDef"], ["[ktFieldHelp]"], true, never>;
+}
+
+/** Portée de transition des chips. Fourni par `ChipList` (via `useExisting`) ; injecté en
+    optionnel par `Chip` pour ne porter un `view-transition-name` QUE pendant la transition
+    de SA liste — sinon tous les chips de la page deviendraient des groupes indépendants et
+    « glisseraient » individuellement à chaque reflow déclenché par une autre liste.
+    Fichier séparé : évite l'import circulaire Chip ↔ ChipList. */
+declare abstract class ChipTransitionScope {
+    abstract readonly transitioning: Signal<boolean>;
+}
+
+/**
+ * Pilule individuelle (tag). Utilisable seule (tag statique) ou dans `kt-chip-list`.
+ * Le label vient de la projection de contenu ; `removable` ajoute un bouton « retirer »
+ * (24px visibles, cible 44px via ::after — technique des boutons icon-only).
+ *
+ * @example
+ * ```html
+ * <kt-chip>Angular</kt-chip>
+ * <kt-chip removable removeLabel="Retirer Angular" (remove)="onRemove()">Angular</kt-chip>
+ * ```
+ */
+declare class KtChip {
+    protected readonly scope: ChipTransitionScope | null;
+    private readonly idGen;
+    /** Nom de View Transition propre au chip (détail interne, posé en host binding). */
+    protected readonly viewTransitionName: string;
+    /** Affiche le bouton « retirer » (sinon tag statique sans bouton). @default false */
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Chip désactivé (bouton « retirer » inactif). @default false */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Libellé accessible du bouton « retirer » (inclure le nom de l'item : « Remove X »). @default 'Remove' */
+    readonly removeLabel: _angular_core.InputSignal<string>;
+    /** É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`). */
+    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>;
+}
+
+/** Contexte typé reçu par le template d'un chip custom (`ktChipItem`). */
+interface KtChipItemContext<T> {
+    /** L'item en cours de rendu → `let-item`. */
+    $implicit: T;
+    /** Fonction pour retirer cet item de la liste → `let-remove="remove"`. */
+    remove: () => void;
+}
+/** Template de rendu custom d'un chip dans `kt-chip-list`.
+    Structurellement compatible avec `MultiSelectChipContext` (forwardable).
+    Contexte : `let-item` = l'item rendu (`T`), `let-remove` = fonction qui le retire.
+
+    ```html
+    <kt-chip-list [items]="tags">
+      <ng-template [ktChipItem]="tags" let-tag let-remove="remove">
+        <kt-chip [removable]="true" (remove)="remove()">{{ tag.name }}</kt-chip>
+      </ng-template>
+    </kt-chip-list>
+    ``` */
+declare class KtChipItemDef<T> {
+    readonly ktChipItem: _angular_core.InputSignal<readonly T[]>;
+    readonly template: TemplateRef<KtChipItemContext<T>>;
+    static ngTemplateContextGuard<T>(_dir: KtChipItemDef<T>, ctx: unknown): ctx is KtChipItemContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtChipItemDef<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtChipItemDef<any>, "ng-template[ktChipItem]", never, { "ktChipItem": { "alias": "ktChipItem"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Liste de chips révocables (`role="list"`) : repli au-delà de `maxVisible` (« +N more »),
+ * annonces lecteur d'écran (live region TOUJOURS rendue, y compris liste vide) et gestion
+ * du focus au retrait (chip suivant, sinon `emptyFocusTarget`).
+ * La liste ne possède PAS la donnée : le retrait émet `removed` et le parent met à jour
+ * `items` (pattern contrôlé). Rendu custom par chip via `ng-template[ktChipItem]` (projeté)
+ * ou `[chipTemplate]` (TemplateRef forwardé, ex. depuis MultiSelect) — le focus management
+ * ne voit pas les boutons des templates custom (view queries non traversantes) : le repli
+ * `emptyFocusTarget` couvre ce cas.
+ *
+ * @example
+ * ```html
+ * <kt-chip-list [items]="tags()" [maxVisible]="3" (removed)="onRemoved($event)" />
+ * ```
+ */
+declare class KtChipList<T> implements ChipTransitionScope {
+    private readonly config;
+    private readonly injector;
+    private readonly host;
+    private readonly doc;
+    private readonly platformId;
+    private readonly cdr;
+    /** 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>;
+    /** Items affichés sous forme de chips (la liste ne possède pas la donnée : pattern contrôlé). */
+    readonly items: _angular_core.InputSignal<readonly T[]>;
+    /** Libellé d'un item : clé OU fonction. @default `label`/`name`, sinon `String(item)` */
+    readonly itemLabel: _angular_core.InputSignal<KtKeyish<T, string> | undefined>;
+    /** Identité d'un item (track du @for) : clé OU fonction. @default `id`/`value`, sinon l'item */
+    readonly itemKey: _angular_core.InputSignal<KtKeyish<T, unknown> | undefined>;
+    /** Chips révocables (bouton « retirer » par chip). @default true */
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Liste désactivée (boutons « retirer » présents mais inactifs). @default false */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Lecture seule : les boutons « retirer » sont absents (≠ disabled : présents mais inactifs). @default false */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Nombre maximal de chips affichés avant repli derrière « +N more ». @default undefined (illimité) */
+    readonly maxVisible: _angular_core.InputSignal<number | undefined>;
+    /** Libellé accessible de la liste (`aria-label`). Défaut : `KT_CHIPS_CONFIG.listLabel` ou « Selected items ». */
+    readonly listLabel: _angular_core.InputSignal<string | undefined>;
+    /** Construit le libellé du bouton « retirer » à partir du libellé de l'item. @default `« Remove {label} »` */
+    readonly removeItemLabel: _angular_core.InputSignal<((itemLabel: string) => string) | undefined>;
+    /** Construit le message d'annonce après retrait (live region). @default `« {label} removed »` */
+    readonly itemRemovedText: _angular_core.InputSignal<((itemLabel: string) => string) | undefined>;
+    /** Construit le libellé du bouton de repli à partir du nombre masqué. @default `« +{n} more »` */
+    readonly moreLabel: _angular_core.InputSignal<((hiddenCount: number) => string) | undefined>;
+    /** Libellé du bouton qui replie la liste dépliée. Défaut : `KT_CHIPS_CONFIG.lessLabel` ou « Show less ». */
+    readonly lessLabel: _angular_core.InputSignal<string | undefined>;
+    /** Template custom forwardé (alternative au `ng-template[ktChipItem]` projeté). @default null */
+    readonly chipTemplate: _angular_core.InputSignal<TemplateRef<KtChipItemContext<T>> | null>;
+    /** Élément à focuser quand le dernier chip est retiré (ex. le trigger du champ parent). @default undefined */
+    readonly emptyFocusTarget: _angular_core.InputSignal<HTMLElement | undefined>;
+    /** Émis quand un chip est retiré (le parent doit retirer l'item de `items`).
+        Payload : `{ item, index }` — l'item retiré et son index dans `items` au moment du retrait. */
+    readonly removed: _angular_core.OutputEmitterRef<{
+        item: T;
+        index: number;
+    }>;
+    protected readonly itemDef: _angular_core.Signal<KtChipItemDef<any> | undefined>;
+    private readonly chips;
+    protected readonly resolvedListLabel: _angular_core.Signal<string>;
+    private readonly resolvedRemoveItemLabel;
+    private readonly resolvedItemRemovedText;
+    protected readonly resolvedMoreLabel: _angular_core.Signal<(hiddenCount: number) => string>;
+    protected readonly resolvedLessLabel: _angular_core.Signal<string>;
+    private readonly labelAccessor;
+    private readonly keyAccessor;
+    protected labelOf(item: T): string;
+    protected keyOf(item: T): unknown;
+    protected removeLabelFor(item: T): string;
+    /** Template effectif : contenu projeté (ktChipItem) prioritaire sur l'input forwardé. */
+    protected readonly effectiveTemplate: _angular_core.Signal<TemplateRef<KtChipItemContext<any>> | null>;
+    protected readonly showRemove: _angular_core.Signal<boolean>;
+    protected readonly expanded: _angular_core.WritableSignal<boolean>;
+    protected readonly overflow: _angular_core.Signal<boolean>;
+    protected readonly hiddenCount: _angular_core.Signal<number>;
+    protected readonly visibleItems: _angular_core.Signal<readonly T[]>;
+    protected readonly status: _angular_core.WritableSignal<string>;
+    private statusTimer;
+    constructor();
+    private readonly idGen;
+    protected readonly moreBtnTransitionName: string;
+    /** Annonce un message dans la live region de la liste (effacé après ~2 s).
+        Public : permet au parent d'annoncer des actions liées (ex. « tout effacer »). */
+    announce(text: string): void;
+    private activeTransition;
+    /** Exécute `action` dans une View Transition (morph des chips qui se déplacent, entrée/sortie
+        stylées via `::view-transition-*(.chip-transition)` — cf. tokens.css). Transition SCOPÉE à
+        l'élément quand le navigateur le permet (`element.startViewTransition`, Chrome 147+) ; sinon
+        transition document — dans les deux cas, seuls les chips de CETTE liste sont nommés (cf.
+        `transitioning`). Fallback : action directe si l'API est absente ou si l'utilisateur
+        préfère moins de mouvement. */
+    private withViewTransition;
+    /** Retrait demandé : annonce, émet vers le parent (qui met à jour `items`), puis focus
+        le chip suivant — sinon `emptyFocusTarget` (le bouton focusé disparaît du DOM). */
+    protected removeAt(item: T, index: number): void;
+    protected removeCallback(item: T, index: number): () => void;
+    /** Déplie/replie ; au dépliage, focus sur le premier chip nouvellement révélé. */
+    protected toggleExpanded(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtChipList<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtChipList<any>, "kt-chip-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "itemLabel": { "alias": "itemLabel"; "required": false; "isSignal": true; }; "itemKey": { "alias": "itemKey"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "maxVisible": { "alias": "maxVisible"; "required": false; "isSignal": true; }; "listLabel": { "alias": "listLabel"; "required": false; "isSignal": true; }; "removeItemLabel": { "alias": "removeItemLabel"; "required": false; "isSignal": true; }; "itemRemovedText": { "alias": "itemRemovedText"; "required": false; "isSignal": true; }; "moreLabel": { "alias": "moreLabel"; "required": false; "isSignal": true; }; "lessLabel": { "alias": "lessLabel"; "required": false; "isSignal": true; }; "chipTemplate": { "alias": "chipTemplate"; "required": false; "isSignal": true; }; "emptyFocusTarget": { "alias": "emptyFocusTarget"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, ["itemDef"], never, true, never>;
+}
+
+/** Défauts applicables à tous les `kt-chip-list` (surchargeables par liste via les inputs).
+    Lib neutre i18n : les textes sont fournis par le consommateur (ici en une fois).
+    Fourni en `Partial` : un consommateur n'override que ce qu'il veut.
+    Calqué sur `KT_FIELD_CONFIG`/`KT_SELECT_CONFIG`.
+    NB : le MultiSelect passe ses propres textes (résolus depuis KT_SELECT_CONFIG) en inputs —
+    ils priment donc sur ce token pour les chips rendus sous un multi-select. */
+interface KtChipsConfig {
+    /** Libellé accessible du bouton de retrait d'un chip. Défaut : `'Remove X'`. */
+    removeItemLabel: (itemLabel: string) => string;
+    /** Annonce live après le retrait d'un chip. Défaut : `'X removed'`. */
+    itemRemovedText: (itemLabel: string) => string;
+    /** Libellé du bouton dépliant les chips repliés (`[maxVisible]`). Défaut : `'+N more'`. */
+    moreLabel: (hiddenCount: number) => string;
+    /** Libellé du même bouton une fois déplié. Défaut : `'Show less'`. */
+    lessLabel: string;
+    /** Libellé accessible du conteneur (`role="list"`). Défaut : `'Selected items'`. */
+    listLabel: string;
+}
+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
+    à son type Temporal (`fromString` / `serialize`).
+
+    Contrat abstrait : une sous-classe implémente uniquement le couple
+    `fromString` (chaîne ISO de l'input natif → valeur typée `T`) et `serialize`
+    (valeur `T` → chaîne ISO pour l'attribut `[value]` de l'input). La valeur exposée
+    reste toujours `T | null`, où `null` représente le champ vide ; le parsing est
+    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`. */
+declare abstract class KtBaseTemporalField<T extends {
+    toString(): string;
+}> extends KtBaseInputField<T | null> {
+    private readonly doc;
+    constructor();
+    /** Construit la valeur typée depuis la chaîne ISO de l'input natif (ex. `Temporal.PlainDate.from`). */
+    protected abstract fromString(raw: string): T;
+    /** 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 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>;
+    /** 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 */
+    readonly suggestions: _angular_core.InputSignal<readonly KtSuggestion<T>[] | undefined>;
+    private readonly idGen;
+    private readonly uid;
+    protected readonly datalistId: string;
+    protected readonly hasSuggestions: _angular_core.Signal<boolean>;
+    protected readonly datalistOptions: _angular_core.Signal<readonly 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>;
+}
+
+/** 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.
+ *
+ * @example
+ * ```ts
+ * import { type CalendarDate } from '@ktortu/aaa';
+ * ```
+ */
+type CalendarDate = Temporal.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;
+/** 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;
+/** 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;
+/** 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;
+
+/** Champ « date sans heure » : valeur = `Temporal.PlainDate`, input natif `type="date"`.
+ *
+ * @example
+ * ```html
+ * <kt-date-field label="Date de naissance" [(value)]="birthDate" />
+ * ```
+ */
+declare class KtDateField extends KtBaseTemporalField<Temporal.PlainDate> implements FormValueControl<Temporal.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;
+    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>;
+}
+
+/** Champ « heure sans date » : valeur = `Temporal.PlainTime`, input natif `type="time"`.
+ *
+ * @example
+ * ```html
+ * <kt-time-field label="Heure de rendez-vous" [(value)]="appointmentTime" />
+ * ```
+ */
+declare class KtTimeField extends KtBaseTemporalField<Temporal.PlainTime> implements FormValueControl<Temporal.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;
+    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>;
+}
+
+/** Champ « date-heure sans fuseau » : valeur = `Temporal.PlainDateTime`, input
+    natif `type="datetime-local"`. Volontairement SANS timezone (heure « au mur »).
+ *
+ * @example
+ * ```html
+ * <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> {
+    /** 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;
+    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>;
+}
+
+/** Champ « mois/année » (ex. expiration de carte) : valeur = `Temporal.PlainYearMonth`,
+    input natif `type="month"`.
+ *
+ * @example
+ * ```html
+ * <kt-year-month-field label="Expiration" [(value)]="cardExpiry" />
+ * ```
+ */
+declare class KtYearMonthField extends KtBaseTemporalField<Temporal.PlainYearMonth> implements FormValueControl<Temporal.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;
+    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>;
+}
+
+/** Champ « instant absolu » : valeur = `Temporal.Instant` (UTC), saisi et affiché en **heure
+    locale** via un input `type="datetime-local"`. Conçu pour le flux serveur-UTC → affichage/édition
+    locale → renvoi UTC. Le fuseau local vient du service `KtClock` (injecté → testable).
+
+    Conversion UTC↔heure locale : à l'affichage, l'`Instant` UTC est projeté dans le fuseau
+    local (`KtClock.timeZoneId()`) pour produire l'heure « au mur » montrée à l'utilisateur ; à la
+    saisie, cette heure locale est réinterprétée dans le même fuseau puis reconvertie en `Instant`
+    UTC. Fournir un `KtClock` figé en test garantit une conversion déterministe.
+ *
+ * @example
+ * ```html
+ * <kt-instant-field label="Horodatage" [(value)]="recordedAt" />
+ * ```
+ */
+declare class KtInstantField extends KtBaseTemporalField<Temporal.Instant> implements FormValueControl<Temporal.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;
+    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;
+/** 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
+    (format au runtime via `LOCALE_ID`, pas `$localize`).
+
+    Un `Instant` n'a pas de fuseau propre → il est affiché dans la **zone locale** (via `KtClock`).
+    Un `ZonedDateTime` est affiché dans **sa propre** zone. Les `Plain*` n'ont pas de fuseau.
+ *
+ * @example
+ * ```html
+ * <!-- format par défaut de la locale active -->
+ * {{ d | temporalDate }}
+ * <!-- options Intl.DateTimeFormat -->
+ * {{ d | temporalDate:{ month: 'long' } }}
+ * {{ d | temporalDate:{ dateStyle: 'full' } }}
+ * ```
+ */
+declare class KtTemporalDatePipe implements PipeTransform {
+    private readonly locale;
+    private readonly clock;
+    transform(value: FormattableTemporal | null | undefined, options?: Intl.DateTimeFormatOptions): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtTemporalDatePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<KtTemporalDatePipe, "temporalDate", true>;
+}
+
+/** Source unique de l'heure courante et du **fuseau local** de l'utilisateur.
+    Injectable (et donc figeable en test) : `vi.useFakeTimers()` ne fige PAS `Temporal.Now`.
+    Règle d'équipe : ne jamais appeler `Temporal.Now.*` en direct ailleurs — passer par `KtClock`. */
+declare class KtClock {
+    /** Fuseau IANA local de l'utilisateur (auto-détecté), ex. `"Europe/Paris"`.
+        Sert de zone de référence pour `today()` et pour les conversions UTC↔local.
+        @returns L'identifiant de fuseau IANA. */
+    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;
+    /** Date civile du jour telle qu'observée dans le fuseau local (`timeZoneId()`).
+        @returns Le jour courant en `Temporal.PlainDate`. */
+    today(): Temporal.PlainDate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtClock, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KtClock>;
+}
+/** Horloge figée pour les tests : fige l'instant ET le fuseau (sinon un test passe en France mais
+    échoue sur un runner CI en UTC). À fournir via `{ provide: KtClock, useValue: new KtFixedClock(...) }`. */
+declare class KtFixedClock extends KtClock {
+    private readonly fixedInstant;
+    private readonly zone;
+    /** Construit une horloge figée déterministe pour les tests.
+        @param fixedInstant Instant absolu (UTC) renvoyé tel quel par `now()` et utilisé comme base de `today()`.
+        @param zone Fuseau IANA fixe (ex. `"Europe/Paris"`) renvoyé par `timeZoneId()`.
+     *
+     * @example
+     * ```ts
+     * TestBed.configureTestingModule({
+     *   providers: [
+     *     { provide: KtClock, useValue: new KtFixedClock(Temporal.Instant.from('2026-06-18T10:00:00Z'), 'Europe/Paris') },
+     *   ],
+     * });
+     * ```
+     */
+    constructor(fixedInstant: Temporal.Instant, zone: string);
+    timeZoneId(): string;
+    now(): Temporal.Instant;
+    today(): Temporal.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 };