@ktortu/aaa 0.1.0-beta.0 → 0.9.1

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

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, AfterViewInit } from '@angular/core';
+import { InjectionToken, AfterViewInit, Provider } from '@angular/core';
 
 /** Axe "emphase" (apparence). */
 type KtButtonMode = 'filled' | 'tonal' | 'outlined' | 'text';
@@ -7,13 +7,27 @@ type KtButtonMode = 'filled' | 'tonal' | 'outlined' | 'text';
 type KtButtonColor = 'primary' | 'neutral' | 'danger';
 /** Taille (la cible md ~44-48px vise le confort tactile / AAA). */
 type KtButtonSize = 'sm' | 'md' | 'lg';
+/** Défauts applicables à tous les `[ktButton]` (surchargeables par bouton via les inputs). */
 interface KtButtonConfig {
+    /** Garde le bouton focusable même désactivé (via `aria-disabled`). */
     disabledInteractive: boolean;
+    /** Emphase visuelle par défaut (apparence). */
     mode: KtButtonMode;
+    /** Intention sémantique par défaut (couleur). */
     color: KtButtonColor;
+    /** Taille par défaut. */
     size: KtButtonSize;
 }
 declare const KT_BUTTON_CONFIG: InjectionToken<Partial<KtButtonConfig>>;
+/**
+ * Fournit des défauts de bouton (mode/couleur/taille…) pour un sous-arbre ou l'application entière.
+ *
+ * @example
+ * ```ts
+ * providers: [provideKtButton({ mode: 'tonal', size: 'lg' })]
+ * ```
+ */
+declare function provideKtButton(config: Partial<KtButtonConfig>): Provider;
 /**
  * Bouton ou lien stylé par la directive `ktButton`. À poser sur un `<button>`
  * (action) ou un `<a>` (navigation) — l'accessibilité s'adapte automatiquement
@@ -40,23 +54,23 @@ declare class KtButton implements AfterViewInit {
     /** Taille ; `md` vise une cible tactile ~44-48px. @default 'md' (ou KT_BUTTON_CONFIG.size) */
     readonly size: _angular_core.InputSignal<KtButtonSize>;
     /** Étire le bouton sur toute la largeur disponible. @default false */
-    readonly fullWidth: _angular_core.InputSignal<boolean>;
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Bouton carré sans texte ; impose un nom accessible via `ariaLabel`. @default false */
     readonly iconOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Nom accessible. Obligatoire si `iconOnly` ; à défaut, l'`aria-label` natif est préservé. */
+    /** Nom accessible. **Obligatoire si `iconOnly`** ; à défaut, l'`aria-label` natif est préservé. @default undefined */
     readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
     /** Attribut HTML natif (comportement formulaire), distinct de `mode`. @default 'button' */
     readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
     /** Affiche l'état de chargement et rend le bouton inerte (`aria-busy`). @default false */
-    readonly loading: _angular_core.InputSignal<boolean>;
-    /** Nom de l'icône (rendu via CSS `data-icon`). */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Nom de l'icône (rendu via CSS `data-icon`). @default undefined */
     readonly icon: _angular_core.InputSignal<string | undefined>;
     /** Position de l'icône relative au texte. @default 'start' */
     readonly iconPosition: _angular_core.InputSignal<"start" | "end">;
     /** Désactive le bouton. @default false */
-    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Garde le bouton focusable même désactivé (via `aria-disabled`). @default false (ou KT_BUTTON_CONFIG.disabledInteractive) */
-    readonly disabledInteractive: _angular_core.InputSignal<boolean>;
+    readonly disabledInteractive: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
     constructor();
@@ -66,5 +80,5 @@ declare class KtButton implements AfterViewInit {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtButton, "button[ktButton], a[ktButton]", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { KT_BUTTON_CONFIG, KtButton };
+export { KT_BUTTON_CONFIG, KtButton, provideKtButton };
 export type { KtButtonColor, KtButtonConfig, KtButtonMode, KtButtonSize };

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

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken } from '@angular/core';
+import { InjectionToken, Provider } from '@angular/core';
 
 /**
  * En-tête de la carte (rangée flex : média/avatar + titre + éventuelle action). Marqueur
@@ -67,6 +67,16 @@ declare class KtCardActions {
  *
  * Quand la carte ancêtre est `disabled`, le lien sort de l'ordre de tabulation (`tabindex="-1"`)
  * et est annoncé `aria-disabled` : une carte inerte ne piège pas le focus clavier (WCAG 2.4.3).
+ *
+ * @example
+ * ```html
+ * <article ktCard interactive>
+ *   <div ktCardContent>
+ *     <h3 id="t1">Titre</h3>
+ *     <a ktCardLink routerLink="/detail" aria-labelledby="t1">Voir le détail</a>
+ *   </div>
+ * </article>
+ * ```
  */
 declare class KtCardLink {
     private readonly host;
@@ -90,6 +100,15 @@ interface KtCardConfig {
     variant: KtCardVariant;
 }
 declare const KT_CARD_CONFIG: InjectionToken<Partial<KtCardConfig>>;
+/**
+ * Fournit des défauts de carte (apparence de surface) pour un sous-arbre ou l'application entière.
+ *
+ * @example
+ * ```ts
+ * providers: [provideKtCard({ variant: 'outlined' })]
+ * ```
+ */
+declare function provideKtCard(config: Partial<KtCardConfig>): Provider;
 /**
  * Carte : SURFACE de contenu. Directive (pas de composant) posée sur l'élément SÉMANTIQUE choisi
  * par le consommateur (`<article>`, `<section>`, `<li>`, `<a>`…) — la lib n'impose jamais de
@@ -117,6 +136,7 @@ declare const KT_CARD_CONFIG: InjectionToken<Partial<KtCardConfig>>;
 declare class KtCard {
     private readonly config;
     private readonly host;
+    private readonly platformId;
     /** Référence réactive sur le lien primaire de la carte */
     readonly cardLink: i0.Signal<KtCardLink | undefined>;
     /** Apparence de la surface : `elevated` | `outlined` | `filled`. @default 'elevated' (ou `KT_CARD_CONFIG.variant`) */
@@ -135,9 +155,9 @@ declare class KtCard {
 
 /**
  * Import ergonomique de toute la famille card en une fois :
- * `imports: [KT_CARD]` au lieu d'énumérer chaque directive.
+ * `imports: [KtCardImports]` au lieu d'énumérer chaque directive.
  */
-declare const KT_CARD: readonly [typeof KtCard, typeof KtCardHeader, typeof KtCardMedia, typeof KtCardContent, typeof KtCardActions, typeof KtCardLink];
+declare const KtCardImports: readonly [typeof KtCard, typeof KtCardHeader, typeof KtCardMedia, typeof KtCardContent, typeof KtCardActions, typeof KtCardLink];
 
-export { KT_CARD, KT_CARD_CONFIG, KtCard, KtCardActions, KtCardContent, KtCardHeader, KtCardLink, KtCardMedia };
+export { KT_CARD_CONFIG, KtCard, KtCardActions, KtCardContent, KtCardHeader, KtCardImports, KtCardLink, KtCardMedia, provideKtCard };
 export type { KtCardConfig, KtCardVariant };

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

@@ -4,7 +4,9 @@ import * as _ktortu_aaa_cdk from '@ktortu/aaa/cdk';
 
 /** Contrôleur de drag-to-dismiss d'une bottom-sheet. À câbler sur le `pointerdown` de la poignée. */
 interface KtSheetDrag {
+    /** Démarre le suivi du glissement ; à brancher sur le `pointerdown` de la poignée. */
     start(event: PointerEvent): void;
+    /** Détache les écouteurs et réinitialise l'état ; à appeler à la destruction. */
     destroy(): void;
 }
 interface KtSheetDragOptions {
@@ -25,6 +27,18 @@ interface KtSheetDragOptions {
  * Geste DOUBLÉ côté appelant par Échap + bouton Fermer + tap-extérieur (WCAG 2.5.1) : ce module ne
  * gère que le glissement. Le gating « écran compact uniquement » reste à l'appelant (signal `isCompact`
  * de `KtViewport`) — la primitive est volontairement agnostique.
+ *
+ * @param opts Élément à translater, callback de fermeture, classe de drag et seuil optionnel.
+ * @returns Un contrôleur {@link KtSheetDrag} (`start` à brancher sur `pointerdown`, `destroy` au teardown).
+ * @example
+ * ```ts
+ * const drag = createKtSheetDrag({
+ *   pane: () => paneEl(),
+ *   onDismiss: () => dialogRef.close(),
+ *   draggingClass: 'kt-sheet--dragging',
+ * });
+ * // <div class="handle" (pointerdown)="drag.start($event)"></div>
+ * ```
  */
 declare function createKtSheetDrag(opts: KtSheetDragOptions): KtSheetDrag;
 
@@ -55,20 +69,28 @@ declare const KT_DEFAULT_BREAKPOINTS: KtBreakpoints;
 declare const KT_BREAKPOINTS: InjectionToken<KtBreakpoints>;
 /**
  * À ajouter aux `providers` de `app.config.ts`. Fusionne avec les défauts → surcharge partielle OK.
+ * @param overrides Seuils à surcharger ; les clés absentes gardent leur défaut `KT_DEFAULT_BREAKPOINTS`.
+ * @returns Provider liant `KT_BREAKPOINTS` aux seuils fusionnés.
  * @example provideKtBreakpoints({ tablet: 768, desktop: 1200 })
  * @example provideKtBreakpoints({ tablet: '(min-width: 768px) and (orientation: landscape)' })
  */
 declare function provideKtBreakpoints(overrides: Partial<KtBreakpoints>): Provider;
 /** Trois chaînes de media queries résolues, prêtes pour `matchMedia` / `BreakpointObserver`. */
 interface KtBreakpointMedia {
+    /** Media query de la bande mobile. */
     mobile: string;
+    /** Media query de la bande tablette. */
     tablet: string;
+    /** Media query de la bande desktop. */
     desktop: string;
 }
 /**
  * Convertit les seuils (nombres et/ou chaînes) en 3 media queries. Un palier-chaîne est repris
  * verbatim ; un palier-nombre devient la bande `[plancher courant .. plancher suivant[`. Si le
  * plancher suivant est une chaîne (pas de borne numérique), la bande reste ouverte de ce côté.
+ * @param bp Seuils responsive à convertir (nombres et/ou chaînes).
+ * @returns Les trois media queries résolues (`mobile`, `tablet`, `desktop`).
+ * @example resolveKtBreakpointMedia(KT_DEFAULT_BREAKPOINTS)
  */
 declare function resolveKtBreakpointMedia(bp: KtBreakpoints): KtBreakpointMedia;
 
@@ -98,9 +120,25 @@ declare class KtViewport {
     static ɵprov: i0.ɵɵInjectableDeclaration<KtViewport>;
 }
 
+/**
+ * Génère des identifiants numériques incrémentaux uniques au sein de l'application, soit globalement,
+ * soit par préfixe (compteur dédié). Sert à construire des `anchor-name` / `id` stables et distincts.
+ *
+ * @example
+ * ```ts
+ * const idGen = inject(KtIdGenerator);
+ * const anchor = `--kt-menu-anchor-${idGen.generateId('menu')}`;
+ * ```
+ */
 declare class KtIdGenerator {
     private readonly counters;
     private nextGlobalId;
+    /**
+     * Renvoie le prochain identifiant. Sans `prefix`, utilise le compteur global ; avec `prefix`,
+     * utilise un compteur dédié à ce préfixe (séquences indépendantes).
+     * @param prefix Clé optionnelle de compteur ; chaque préfixe a sa propre séquence.
+     * @returns Le compteur courant (number) pour la portée demandée, avant incrément.
+     */
     generateId(prefix?: string): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<KtIdGenerator, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<KtIdGenerator>;

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

@@ -23,7 +23,10 @@ declare class KtDialogTitle {
     private readonly host;
     private readonly renderer;
     private readonly idGen;
-    /** Id de l'hôte câblé en `aria-labelledby` : préserve un id fourni par le consommateur, sinon en génère un. */
+    /**
+     * Id de l'hôte câblé en `aria-labelledby` : préserve un id fourni par le consommateur, sinon en génère un.
+     * @default `host.id` ?? `dialogRef.config.ariaLabelledBy` ?? `kt-dialog-title-<généré>`
+     */
     readonly id: string;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<KtDialogTitle, never>;
@@ -50,7 +53,10 @@ declare class KtDialogDescription implements OnInit, OnDestroy {
     private readonly host;
     private readonly renderer;
     private readonly idGen;
-    /** Id de l'hôte câblé en `aria-describedby` : préserve un id fourni par le consommateur, sinon en génère un. */
+    /**
+     * Id de l'hôte câblé en `aria-describedby` : préserve un id fourni par le consommateur, sinon en génère un.
+     * @default `host.id` ?? `dialogRef.config.ariaDescribedBy` ?? `kt-dialog-desc-<généré>`
+     */
     readonly id: string;
     constructor();
     ngOnInit(): void;
@@ -190,12 +196,28 @@ declare class KtDialogSheetHandle {
  * Pour focaliser un élément précis à l'ouverture (ex. éviter un bouton destructeur),
  * passez `autoFocus: '[ktDialogFocusInitial]'` dans la config d'ouverture et posez la
  * directive `ktDialogFocusInitial` sur la cible.
+ *
+ * @example
+ * ```ts
+ * // valeur de base, généralement consommée via provideKtDialogDefaults()
+ * provideKtDialogDefaults({ ...KT_DIALOG_AAA_DEFAULTS });
+ * ```
  */
 declare const KT_DIALOG_AAA_DEFAULTS: DialogConfig;
 /**
  * Enregistre les valeurs par défaut AAA du dialog au niveau application.
  * À ajouter aux `providers` de `app.config.ts`. `overrides` permet d'ajuster sans
  * tout réécrire (ex. `provideKtDialogDefaults({ maxWidth: '40rem' })`).
+ *
+ * @example
+ * ```ts
+ * // app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [provideKtDialogDefaults({ maxWidth: '40rem' })],
+ * };
+ * ```
+ * @param overrides Surcharges partielles fusionnées par-dessus `KT_DIALOG_AAA_DEFAULTS`.
+ * @returns Un `Provider` pour le token `DEFAULT_DIALOG_CONFIG`.
  */
 declare function provideKtDialogDefaults(overrides?: Partial<DialogConfig>): Provider;
 /**
@@ -215,58 +237,134 @@ type KtDialogPresentation = 'centered' | 'fullscreen' | 'sheet' | 'centered-full
  * `centered-*`, l'appelant fournit `compact` (= `KtViewport.isCompact()`, largeur seule) — centré
  * sur desktop, plein écran / sheet sur écran compact. Fonction pure (testable sans DOM).
  * Appelée par `injectKtDialogOpener` à chaque ouverture ; exportée pour un usage direct éventuel.
+ *
+ * @example
+ * ```ts
+ * resolveKtDialogPanelClass('sheet');               // ['kt-dialog', 'kt-dialog--sheet']
+ * resolveKtDialogPanelClass('centered-sheet', true); // bottom-sheet sur écran compact
+ * ```
+ * @param presentation Présentation choisie par le dev (responsive comprise). Défaut `'centered'`.
+ * @param compact `true` quand l'écran est compact (= `KtViewport.isCompact()`), pour résoudre les variantes `centered-*`. Défaut `false`.
+ * @returns La liste des classes CSS de la présentation concrète résolue.
  */
 declare function resolveKtDialogPanelClass(presentation?: KtDialogPresentation, compact?: boolean): string[];
 
 /**
- * Sucre typé pour récupérer les données injectées dans un composant de dialogue (`DIALOG_DATA`).
- * À appeler en contexte d'injection (ex. initialiseur de champ).
+ * ⚠️ API BAS-NIVEAU — n'utilisez PAS ceci par défaut. Pour implémenter un dialog, passez par
+ * {@link defineKtDialog} et son `injectData()` (qui lie le type des données à l'ouvreur).
  *
- * @example
- * ```ts
- * interface RenameData { currentName: string; }
- *
- * @Component({  …  })
- * export class RenameDialog {
- *   protected readonly data = injectKtDialogData<RenameData>();
- *   // this.data.currentName  →  string
- * }
- * ```
+ * Sucre typé pour récupérer les données injectées dans un composant de dialogue (`DIALOG_DATA`).
+ * Le type `T` est affirmé ICI indépendamment de l'ouvreur : rien ne garantit qu'il corresponde au
+ * type passé à `injectKtDialogOpener` → risque de divergence silencieuse. À réserver à un cas où
+ * `defineKtDialog` ne convient pas.
  */
 declare function injectKtDialogData<T>(): T;
 /** Config d'ouverture sans le champ `data` (fourni séparément, typé), enrichie de `presentation`. */
-type OpenerConfig<D, R, C> = Omit<DialogConfig<D, DialogRef<R, C>>, 'data'> & {
+type KtDialogOpenerConfig<D, R, C> = Omit<DialogConfig<D, DialogRef<R, C>>, 'data'> & {
     /** Présentation du dialog (cf. `KtDialogPresentation`) — choisie par le dev. Résolue à CHAQUE
         ouverture : les variantes responsive lisent le signal d'écran compact. Défaut : `'centered'`.
         Combinée à un éventuel `panelClass` additionnel. */
     presentation?: KtDialogPresentation;
 };
 /**
- * Crée un ouvreur de dialog **typé et centralisé**, en contexte d'injection.
- * Le contrat (composant + type de `data` + type de résultat + config par défaut) est défini
- * UNE fois ; l'ouvreur renvoyé est une closure appelable ensuite n'importe où dans la classe
- * (handlers compris), 100 % typée, sans nouvel `inject`.
+ * ⚠️ API BAS-NIVEAU — n'utilisez PAS ceci par défaut. Pour implémenter un dialog, passez par
+ * {@link defineKtDialog} puis son `injectOpener(...)` : il fixe données + résultat une seule fois et
+ * les partage avec `injectData()`/`injectRef()`. N'appelez `injectKtDialogOpener` directement que
+ * dans un cas avancé où le contrat groupé de `defineKtDialog` ne convient pas.
+ *
+ * Crée un ouvreur de dialog typé en contexte d'injection : le contrat (composant + type de `data` +
+ * type de résultat + config par défaut) est figé via les génériques `<Composant, Data, Résultat>`
+ * (qu'il faut répéter — d'où la préférence pour `defineKtDialog`). L'ouvreur renvoyé est une closure
+ * appelable n'importe où dans la classe, 100 % typée, sans nouvel `inject`.
  *
  * Conserve le `ViewContainerRef` du contexte appelant (le dialog hérite donc de l'arbre logique
  * d'injection), reste testable (TestBed fournit `Dialog`) et sans état global (SSR-safe).
  *
+ * @param component Composant à monter dans le dialog.
+ * @param baseConfig Config d'ouverture par défaut (sans `data`), enrichie de `presentation` ; fusionnée à chaque ouverture.
+ * @returns Une closure d'ouverture typée : `() => DialogRef` (sans data) ou `(data, config?) => DialogRef` (avec data).
+ * @see {@link defineKtDialog} — la façon recommandée d'obtenir cet ouvreur.
+ */
+declare function injectKtDialogOpener<C, R = unknown>(component: ComponentType<C>, baseConfig?: KtDialogOpenerConfig<void, R, C>): () => DialogRef<R, C>;
+declare function injectKtDialogOpener<C, D, R = unknown>(component: ComponentType<C>, baseConfig?: KtDialogOpenerConfig<D, R, C>): (data: D, config?: KtDialogOpenerConfig<D, R, C>) => DialogRef<R, C>;
+/**
+ * Contrat de dialog typé renvoyé par `defineKtDialog` : les trois accès (données, référence,
+ * ouvreur) dérivent des MÊMES génériques `D`/`R`, déclarés une seule fois — impossible donc que
+ * le type des données ou du résultat diverge entre le composant et l'ouvreur.
+ *
+ * @template D Type des données injectées (`void` si aucune).
+ * @template R Type du résultat renvoyé à la fermeture.
+ */
+interface KtDialogContract<D, R> {
+    /** Données injectées (à appeler en contexte d'injection DANS le composant de dialog). */
+    injectData(): D;
+    /** Référence typée du dialog : `close()` n'accepte QUE le résultat `R` (sûreté de fermeture). */
+    injectRef(): DialogRef<R>;
+    /** Ouvreur typé CO-LOCALISÉ pour ce composant (cf. `injectKtDialogOpener`). */
+    injectOpener<C>(component: ComponentType<C>, baseConfig?: KtDialogOpenerConfig<D, R, C>): (data: D, config?: KtDialogOpenerConfig<D, R, C>) => DialogRef<R, C>;
+}
+/**
+ * ✅ STRATÉGIE PAR DÉFAUT pour implémenter un dialog `@ktortu/aaa`. Toute nouvelle dialog DOIT être
+ * écrite ainsi. N'utilisez `injectKtDialogData` / `injectKtDialogOpener` directement QUE dans un cas
+ * avancé non couvert ici.
+ *
+ * Définit le contrat typé du dialog (données `D` + résultat `R`) en UN SEUL endroit, co-localisé avec
+ * le composant. Renvoie trois accès liés aux mêmes types — `injectData()` (données), `injectRef()`
+ * (référence dont `close()` n'accepte que `R`) et `injectOpener()` (ouvreur) — d'où l'impossibilité
+ * d'une divergence de type entre composant et ouvreur.
+ *
+ * Recette à copier pour CHAQUE dialog :
+ * 1. `interface XxxData { … }` (ou `void` si aucune donnée) ;
+ * 2. `const xxxDialog = defineKtDialog<XxxData, Résultat>();` ;
+ * 3. dans le composant : `injectData()` pour lire la donnée, `injectRef()` pour fermer avec résultat ;
+ * 4. `export const injectXxxDialog = () => xxxDialog.injectOpener(XxxDialog);` (co-localisé) ;
+ * 5. côté consommateur : `private readonly openXxx = injectXxxDialog();` (initialiseur de champ).
+ *
+ * Convention de fermeture : annuler / fermer SANS résultat via la directive `[ktDialogClose]`
+ * (→ `undefined`) ; renvoyer un résultat via `ref.close(résultat)` (typé `R`). Passer un résultat par
+ * `[ktDialogClose]="x"` reste possible mais N'EST PAS typé (la directive ignore `R`).
+ *
  * @example
- * // co-localisé avec le composant
- * export const injectRenameDialog = () =>
- *   injectKtDialogOpener<RenameDialog, RenameData, string>(RenameDialog, { autoFocus: '[ktDialogFocusInitial]' });
+ * ```ts
+ * // ─── rename-dialog.ts : composant + contrat + ouvreur, co-localisés ───
+ * export interface RenameData { currentName: string; }
  *
- * // dans un composant/service consommateur
- * private readonly openRename = injectRenameDialog();
- * rename() { this.openRename({ currentName: 'X' }).closed.subscribe(n => {  n: string | undefined  }); }
+ * const renameDialog = defineKtDialog<RenameData, string>(); // D et R déclarés UNE seule fois
+ *
+ * @Component({
+ *   imports: [KtButton, KtDialogImports],
+ *   template: `
+ *     <h2 ktDialogTitle>Renommer</h2>
+ *     <footer ktDialogActions>
+ *       <button ktButton ktDialogClose>Annuler</button>            // ferme sans résultat (undefined)
+ *       <button ktButton (click)="submit()">Renommer</button>      // ferme avec résultat typé
+ *     </footer>`,
+ * })
+ * export class RenameDialog {
+ *   protected readonly data = renameDialog.injectData();  // RenameData garanti
+ *   private readonly ref = renameDialog.injectRef();      // DialogRef<string>
+ *   protected submit() { this.ref.close('nouveau-nom'); } // close(result?: string) — typé
+ * }
+ *
+ * export const injectRenameDialog = () => renameDialog.injectOpener(RenameDialog);
+ *
+ * // ─── consommateur ───
+ * private readonly openRename = injectRenameDialog();     // initialiseur de champ = contexte d'injection
+ * rename() {
+ *   this.openRename({ currentName: 'X' }).closed.subscribe(name => {
+ *     // name: string | undefined
+ *   });
+ * }
+ * ```
  */
-declare function injectKtDialogOpener<C, R = unknown>(component: ComponentType<C>, baseConfig?: OpenerConfig<void, R, C>): () => DialogRef<R, C>;
-declare function injectKtDialogOpener<C, D, R = unknown>(component: ComponentType<C>, baseConfig?: OpenerConfig<D, R, C>): (data: D, config?: OpenerConfig<D, R, C>) => DialogRef<R, C>;
+declare function defineKtDialog<D = void, R = unknown>(): KtDialogContract<D, R>;
 
 declare class KtDialogContainer extends CdkDialogContainer implements OnInit {
     private readonly dialogRef;
     private readonly elementRef;
     private readonly host;
     private readonly platformId;
+    private readonly destroyRef;
     protected readonly isClosing: i0.WritableSignal<boolean>;
     constructor();
     ngOnInit(): void;
@@ -278,9 +376,9 @@ declare class KtDialogContainer extends CdkDialogContainer implements OnInit {
 
 /**
  * Import ergonomique de toute la famille dialog en une fois :
- * `imports: [KT_DIALOG]` au lieu d'énumérer chaque directive structurelle.
+ * `imports: [KtDialogImports]` au lieu d'énumérer chaque directive structurelle.
  */
-declare const KT_DIALOG: readonly [typeof KtDialogHeader, typeof KtDialogTitle, typeof KtDialogDescription, typeof KtDialogContent, typeof KtDialogActions, typeof KtDialogClose, typeof KtDialogFocusInitial, typeof KtDialogSheetHandle];
+declare const KtDialogImports: readonly [typeof KtDialogHeader, typeof KtDialogTitle, typeof KtDialogDescription, typeof KtDialogContent, typeof KtDialogActions, typeof KtDialogClose, typeof KtDialogFocusInitial, typeof KtDialogSheetHandle];
 
-export { KT_DIALOG, KT_DIALOG_AAA_DEFAULTS, KtDialogActions, KtDialogClose, KtDialogContainer, KtDialogContent, KtDialogDescription, KtDialogFocusInitial, KtDialogHeader, KtDialogSheetHandle, KtDialogTitle, injectKtDialogData, injectKtDialogOpener, provideKtDialogDefaults, resolveKtDialogPanelClass };
-export type { KtDialogPresentation };
+export { KT_DIALOG_AAA_DEFAULTS, KtDialogActions, KtDialogClose, KtDialogContainer, KtDialogContent, KtDialogDescription, KtDialogFocusInitial, KtDialogHeader, KtDialogImports, KtDialogSheetHandle, KtDialogTitle, defineKtDialog, injectKtDialogData, injectKtDialogOpener, provideKtDialogDefaults, resolveKtDialogPanelClass };
+export type { KtDialogContract, KtDialogOpenerConfig, KtDialogPresentation };