@nomosui/react 0.4.0

package/dist/types/catalogue/contract.d.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+/**
+ * Le contrat d'un manifeste de composant (ADR 0005).
+ *
+ * Le manifeste est écrit à la main, colocalisé avec son composant
+ * (`src/components/<nom>/manifest.ts`), et validé ici : une erreur de forme se voit à
+ * l'import du catalogue, pas dans la page de style ni dans le serveur MCP.
+ *
+ * `usages` est obligatoire et non vide : c'est la partie qu'un agent vient chercher —
+ * l'intention (« quel badge pour un statut de production »), pas seulement le type.
+ */
+export declare const componentPropSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    required: z.ZodBoolean;
+    default: z.ZodOptional<z.ZodString>;
+    check: z.ZodEnum<{
+        attribute: "attribute";
+        class: "class";
+        content: "content";
+        rendered: "rendered";
+        accepted: "accepted";
+    }>;
+    description: z.ZodString;
+}, z.core.$strict>;
+export declare const componentVariantSchema: z.ZodObject<{
+    name: z.ZodString;
+    values: z.ZodArray<z.ZodString>;
+    default: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+}, z.core.$strict>;
+export declare const componentUsageSchema: z.ZodObject<{
+    when: z.ZodString;
+    use: z.ZodString;
+    avoid: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const componentManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+    summary: z.ZodString;
+    level: z.ZodEnum<{
+        jeton: "jeton";
+        primitive: "primitive";
+        bloc: "bloc";
+    }>;
+    props: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        required: z.ZodBoolean;
+        default: z.ZodOptional<z.ZodString>;
+        check: z.ZodEnum<{
+            attribute: "attribute";
+            class: "class";
+            content: "content";
+            rendered: "rendered";
+            accepted: "accepted";
+        }>;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+    variants: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        values: z.ZodArray<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+    example: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    usages: z.ZodArray<z.ZodObject<{
+        when: z.ZodString;
+        use: z.ZodString;
+        avoid: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ComponentManifest = z.infer<typeof componentManifestSchema>;
+export type ComponentProp = z.infer<typeof componentPropSchema>;
+export type ComponentVariant = z.infer<typeof componentVariantSchema>;
+export type ComponentUsage = z.infer<typeof componentUsageSchema>;
+/** Le message d'erreur d'un manifeste invalide : quel composant, quel champ, quoi. */
+export declare function errorMessage(schemaName: string, error: z.ZodError): string;

package/dist/types/catalogue/registry.d.ts

@@ -0,0 +1,33 @@
+import type { ComponentType } from 'react';
+import { type ComponentManifest } from './contract';
+/**
+ * L'index du catalogue : **un inventaire, deux rendus** (ADR 0005). La page de style
+ * le lit pour un humain, le serveur MCP le servira à un agent, et le test de cohérence
+ * le confronte aux props réelles.
+ *
+ * Chaque entrée porte le manifeste, le composant lui-même (pour que la page de style
+ * le rende et que le test l'interroge) et la config de variantes du composant, indexée
+ * par le nom de la prop qui les porte.
+ */
+type VariantsConfig = {
+    variants?: Record<string, Record<string, unknown>>;
+    defaultVariants?: Record<string, unknown>;
+};
+export type CatalogueEntry = {
+    manifest: ComponentManifest;
+    component: ComponentType<Record<string, unknown>>;
+    variantsConfig: Record<string, VariantsConfig>;
+};
+export declare const catalogueEntries: CatalogueEntry[];
+/**
+ * Valide l'index : chaque manifeste respecte le contrat, et deux composants ne portent
+ * pas le même nom. Une entrée refusée dit laquelle et pourquoi.
+ */
+export declare function validateCatalogue(entries: CatalogueEntry[]): CatalogueEntry[];
+/** Le catalogue validé — c'est celui-là qu'on expose. */
+export declare const catalogue: CatalogueEntry[];
+/** Les noms des composants du catalogue, dans l'ordre de l'index. */
+export declare const componentNames: string[];
+/** Le composant et son manifeste, ou une erreur qui dit ce qui manque. */
+export declare function findComponent(name: string): CatalogueEntry;
+export {};

package/dist/types/components/alert/alert.d.ts

@@ -0,0 +1,30 @@
+import type { ReactNode } from 'react';
+import { type Tone } from '../../lib/tone';
+type AlertBase = {
+    /** Le ton : une intention, pas une couleur (cf. `toneClasses`). Défaut `info`. */
+    tone?: Tone;
+    /** Le titre du bandeau : court, jamais une phrase. */
+    title: string;
+    /** Le contenu détaillé, sous le titre. */
+    children?: ReactNode;
+    /** Ce qu'on peut faire : un bouton, un lien. */
+    action?: ReactNode;
+    /** Remplace l'icône par défaut du ton. */
+    icon?: ReactNode;
+    /** Les classes de l'appelant, fusionnées après celles du cœur. */
+    className?: string;
+};
+/**
+ * Le bouton de fermeture exige son libellé accessible : `onClose` et `closeLabel` vont
+ * ensemble, ou pas du tout (le cœur n'a pas d'i18n, il n'invente aucun texte).
+ */
+type AlertClose = {
+    onClose?: undefined;
+    closeLabel?: undefined;
+} | {
+    onClose: () => void;
+    closeLabel: string;
+};
+export type AlertProps = AlertBase & AlertClose;
+export declare function Alert({ tone, title, children, action, icon, onClose, closeLabel, className, }: AlertProps): import("react").JSX.Element;
+export {};

package/dist/types/components/alert/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste du bandeau (ADR 0005, ADR 0015). Le ton réutilise le vocabulaire `toneClasses`. */
+export declare const alertManifest: ComponentManifest;

package/dist/types/components/badge/badge.d.ts

@@ -0,0 +1,25 @@
+import type { HTMLAttributes } from 'react';
+import { type VariantProps } from 'class-variance-authority';
+/**
+ * La config des variantes est exportée à côté de `badgeVariants` : le catalogue la lit
+ * pour vérifier que le manifeste ne dérive pas des props réelles (ADR 0005). cva ne
+ * porte pas la config sur la fonction qu'il rend, donc on l'écrit ici, une fois.
+ */
+export declare const badgeVariantsConfig: {
+    variants: {
+        variant: {
+            default: string;
+            secondary: string;
+            destructive: string;
+            outline: string;
+        };
+    };
+    defaultVariants: {
+        variant: "default";
+    };
+};
+export declare const badgeVariants: (props?: ({
+    variant?: "default" | "secondary" | "destructive" | "outline" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type BadgeProps = HTMLAttributes<HTMLDivElement> & VariantProps<typeof badgeVariants>;
+export declare const Badge: ({ className, variant, ...props }: BadgeProps) => import("react").JSX.Element;

package/dist/types/components/badge/manifest.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/**
+ * Le manifeste du Badge (ADR 0005). Il est écrit à la main : le type se génère,
+ * l'usage s'écrit. Le test de cohérence du catalogue le confronte aux props réelles —
+ * une variante ajoutée au composant sans passer ici fait rougir le test.
+ */
+export declare const badgeManifest: ComponentManifest;

package/dist/types/components/button/button.d.ts

@@ -0,0 +1,38 @@
+import type { ComponentProps } from 'react';
+import { type VariantProps } from 'class-variance-authority';
+/**
+ * Le bouton du cœur. La config des variantes est exportée à côté de `buttonVariants`,
+ * comme celle du Badge : le catalogue la lit pour vérifier que le manifeste ne dérive
+ * pas des props réelles (ADR 0005).
+ */
+export declare const buttonVariantsConfig: {
+    variants: {
+        variant: {
+            default: string;
+            destructive: string;
+            outline: string;
+            secondary: string;
+            ghost: string;
+            link: string;
+        };
+        size: {
+            default: string;
+            sm: string;
+            lg: string;
+            icon: string;
+        };
+    };
+    defaultVariants: {
+        variant: "default";
+        size: "default";
+    };
+};
+export declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "icon" | "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ButtonProps = ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
+    /** Rend le style sur l'enfant au lieu d'un `<button>` (Radix `Slot`). */
+    asChild?: boolean;
+};
+export declare function Button({ className, variant, size, asChild, ...props }: ButtonProps): import("react").JSX.Element;

package/dist/types/components/button/manifest.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/**
+ * Le manifeste du Bouton (ADR 0005). Il déclare les deux groupes de variantes —
+ * `variant` (le ton) et `size` (la taille) — que le test de cohérence confronte à la
+ * config réelle.
+ */
+export declare const buttonManifest: ComponentManifest;

package/dist/types/components/card/card.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentProps } from 'react';
+/**
+ * La carte : une surface qui regroupe un contenu apparenté — un en-tête (titre +
+ * description), un corps, un pied. En parts importables séparément ; aucune part ne
+ * nomme un produit, les textes viennent de l'appelant.
+ */
+export declare function Card({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+export declare function CardHeader({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+export declare function CardTitle({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+export declare function CardDescription({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+export declare function CardContent({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+export declare function CardFooter({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;

package/dist/types/components/card/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste de la carte (ADR 0005). Le catalogue enregistre la coquille `Card`. */
+export declare const cardManifest: ComponentManifest;

package/dist/types/components/checkbox/checkbox.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentProps } from 'react';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+/** Une case à cocher contrôlée. Le cœur fournit l'apparence et l'a11y (Radix), pas l'état. */
+export declare function Checkbox({ className, ...props }: ComponentProps<typeof CheckboxPrimitive.Root>): import("react").JSX.Element;

package/dist/types/components/checkbox/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste de la case à cocher (ADR 0005, ADR 0015). */
+export declare const checkboxManifest: ComponentManifest;

package/dist/types/components/chip/chip.d.ts

@@ -0,0 +1,36 @@
+import type { ReactNode } from 'react';
+import { type Tone } from '../../lib/tone';
+/** La hauteur d'une puce selon sa taille. */
+export declare const chipSizeClasses: Record<'default' | 'sm', string>;
+type ChipBase = {
+    /** Le ton : une intention, pas une couleur (cf. `toneClasses`). Défaut `neutral`. */
+    tone?: Tone;
+    /** La taille de la puce. Défaut `default`. */
+    size?: 'default' | 'sm';
+    /** Une icône de tête, fournie par l'appelant. */
+    icon?: ReactNode;
+    /** Le libellé de la puce : court, jamais une phrase. */
+    children: ReactNode;
+    /** Désactive le bouton de retrait. */
+    disabled?: boolean;
+    /** Les classes de l'appelant, fusionnées après celles du cœur. */
+    className?: string;
+};
+/**
+ * Le bouton de retrait exige son libellé accessible : `onRemove` et `removeLabel` vont
+ * ensemble, ou pas du tout (le cœur n'a pas d'i18n, il n'invente aucun texte).
+ */
+type ChipRemove = {
+    onRemove: () => void;
+    removeLabel: string;
+} | {
+    onRemove?: undefined;
+    removeLabel?: undefined;
+};
+export type ChipProps = ChipBase & ChipRemove;
+/**
+ * La puce : une étiquette compacte, éventuellement retirable. Présentation seule — l'app
+ * fournit le libellé, l'icône et l'action de retrait (ADR 0015).
+ */
+export declare function Chip({ tone, size, icon, children, onRemove, removeLabel, disabled, className, }: ChipProps): import("react").JSX.Element;
+export {};

package/dist/types/components/chip/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste de la puce (ADR 0005, ADR 0015). Le ton réutilise `toneClasses`. */
+export declare const chipManifest: ComponentManifest;

package/dist/types/components/counter/counter.d.ts

@@ -0,0 +1,14 @@
+import type { HTMLAttributes } from 'react';
+/**
+ * Le compteur (ADR 0015) : un nombre mis en avant, avec un suffixe et un libellé fournis
+ * par l'app. Aucun formatage, aucune unité, aucune animation dans le cœur — le formatage
+ * appartient à l'app (ADR 0010).
+ */
+export type CounterProps = HTMLAttributes<HTMLSpanElement> & {
+    value: number;
+    /** L'unité ou le signe qui suit le nombre (`%`, `s`, `pts`), fourni par l'appelant. */
+    suffix?: string;
+    /** Le nom de ce qui est compté. */
+    label?: string;
+};
+export declare function Counter({ value, suffix, label, className, ...props }: CounterProps): import("react").JSX.Element;

package/dist/types/components/counter/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste du Counter (ADR 0005). */
+export declare const counterManifest: ComponentManifest;

package/dist/types/components/data-table-pagination/data-table-pagination.d.ts

@@ -0,0 +1,20 @@
+/**
+ * La pagination d'une table, en atome autonome : elle ne connaît pas TanStack, seulement
+ * la page, les bornes et les rappels. Elle se rend donc hors d'une table. Aucun libellé
+ * ne vient de l'app — ils sont injectés (ADR 0010).
+ */
+export type DataTablePaginationProps = {
+    page: number;
+    pageCount: number;
+    pageSize: number;
+    onPageSizeChange: (size: number) => void;
+    onPrevious: () => void;
+    onNext: () => void;
+    canPrevious: boolean;
+    canNext: boolean;
+    rowsLabel: string;
+    pageOf: (page: number, total: number) => string;
+    previousLabel: string;
+    nextLabel: string;
+};
+export declare function DataTablePagination({ page, pageCount, pageSize, onPageSizeChange, onPrevious, onNext, canPrevious, canNext, rowsLabel, pageOf, previousLabel, nextLabel, }: DataTablePaginationProps): import("react").JSX.Element;

package/dist/types/components/data-table-pagination/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste de la pagination (ADR 0005). Elle ne connaît pas TanStack, seulement des nombres. */
+export declare const dataTablePaginationManifest: ComponentManifest;

package/dist/types/components/data-table-toolbar/data-table-toolbar.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from 'react';
+import { type Facet } from '../facet-filter/facet-filter';
+/**
+ * La barre d'outils d'une table : la recherche, les facettes, la gestion des colonnes et
+ * le compte affiché. Elle ne connaît ni l'i18n de l'app ni ses query-params — libellés et
+ * état sont injectés (ADR 0010).
+ */
+export type DataTableColumnOption = {
+    id: string;
+    label: string;
+    visible: boolean;
+};
+export type DataTableToolbarProps = {
+    globalFilter: string;
+    onGlobalFilterChange: (value: string) => void;
+    placeholder: string;
+    facets: Facet[];
+    shownLabel: string;
+    canReset: boolean;
+    resetLabel: string;
+    clearFacetLabel: string;
+    onReset: () => void;
+    columns?: {
+        label: string;
+        clearLabel: string;
+        options: DataTableColumnOption[];
+        onToggle: (id: string, visible: boolean) => void;
+        onMove?: (id: string, direction: -1 | 1) => void;
+        moveUpLabel?: (label: string) => string;
+        moveDownLabel?: (label: string) => string;
+    };
+    actions?: ReactNode;
+};
+export declare function DataTableToolbar({ globalFilter, onGlobalFilterChange, placeholder, facets, shownLabel, canReset, resetLabel, clearFacetLabel, onReset, columns, actions, }: DataTableToolbarProps): import("react").JSX.Element;

package/dist/types/components/data-table-toolbar/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste de la barre d'outils de table (ADR 0005). Aucun libellé propre au cœur. */
+export declare const dataTableToolbarManifest: ComponentManifest;

package/dist/types/components/empty-state/empty-state.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+/**
+ * L'état vide d'une vue : une carte centrée à montrer quand une donnée manque ou est vide.
+ * **Aucun moteur** — l'app fournit l'icône, les textes et l'action (ADR 0015). Le `detail`
+ * brut sert à nommer la vraie panne plutôt que de la masquer.
+ */
+export type EmptyStateProps = {
+    /** L'illustration ou l'icône, fournie par l'appelant. */
+    icon?: ReactNode;
+    /** Le titre de l'état : court, jamais une phrase. */
+    title: string;
+    /** Une description d'une phrase, optionnelle. */
+    description?: string;
+    /** Le détail brut (message d'erreur, cause) — affiché tel quel, jamais masqué. */
+    detail?: string;
+    /** Ce qu'on peut faire devant cet état : un bouton, un lien. */
+    action?: ReactNode;
+    /** Passer le détail sur plusieurs lignes plutôt que de le laisser défiler. */
+    wrap?: boolean;
+    /** Les classes de l'appelant, fusionnées après celles du cœur. */
+    className?: string;
+};
+export declare function EmptyState({ icon, title, description, detail, action, wrap, className, }: EmptyStateProps): import("react").JSX.Element;

package/dist/types/components/empty-state/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste de l'état vide (ADR 0005, ADR 0015). Présentation seule, sans moteur. */
+export declare const emptyStateManifest: ComponentManifest;

package/dist/types/components/facet-filter/facet-filter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Le filtre à facettes : un menu à choix multiples sur une facette. Il ne connaît ni
+ * la table ni l'i18n de l'app — les options, la sélection et le libellé « effacer »
+ * sont injectés (ADR 0010).
+ */
+export type FacetOption = {
+    value: string;
+    label: string;
+    count: number;
+};
+export type Facet = {
+    id: string;
+    label: string;
+    options: FacetOption[];
+    selected: string[];
+    onChange: (next: string[]) => void;
+};
+export type FacetFilterProps = Omit<Facet, 'id'> & {
+    /** Le libellé de l'entrée qui efface la sélection (le cœur n'a pas d'i18n). */
+    clearLabel: string;
+    className?: string;
+};
+export declare function FacetFilter({ label, options, selected, onChange, clearLabel, className, }: FacetFilterProps): import("react").JSX.Element;

package/dist/types/components/facet-filter/manifest.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/**
+ * Le manifeste du filtre à facettes (ADR 0005). Les options, la sélection et les
+ * libellés sont injectés : c'est ce qui l'importe hors d'une table.
+ */
+export declare const facetFilterManifest: ComponentManifest;

package/dist/types/components/field/field.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+/**
+ * L'emplacement d'un champ : le libellé, le contrôle (fourni par l'appelant) et, dessous,
+ * soit le message d'erreur, soit l'aide. **Aucun moteur** : l'app décide de l'état, de la
+ * validation et du texte (ADR 0015). Le cœur ne fait que disposer.
+ */
+export type FieldProps = {
+    label?: ReactNode;
+    hint?: ReactNode;
+    error?: string | null;
+    htmlFor?: string;
+    className?: string;
+    children: ReactNode;
+};
+export declare function Field({ label, hint, error, htmlFor, className, children }: FieldProps): import("react").JSX.Element;

package/dist/types/components/field/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste de l'emplacement de champ (ADR 0005, ADR 0015). */
+export declare const fieldManifest: ComponentManifest;

package/dist/types/components/fieldset/fieldset.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentProps } from 'react';
+/** Un regroupement de champs apparentés ; l'app fournit le titre (`legend`). */
+export declare function Fieldset({ className, ...props }: ComponentProps<'fieldset'>): import("react").JSX.Element;

package/dist/types/components/fieldset/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste du regroupement de champs (ADR 0005, ADR 0015). */
+export declare const fieldsetManifest: ComponentManifest;

package/dist/types/components/form/form.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentProps, ReactNode } from 'react';
+/**
+ * Le bloc de mise en page d'un formulaire : une grille de champs et une zone d'actions,
+ * dans un `<form>` sémantique. **Aucun moteur** — aucune validation, aucun état, aucun
+ * texte : tout vient de l'appelant (ADR 0015). Les champs se groupent avec `Fieldset` et
+ * se posent avec `Field` ; les actions sont des nœuds fournis (boutons de l'app).
+ */
+export type FormProps = ComponentProps<'form'> & {
+    /** Deux colonnes de champs à partir du palier `md` ; une seule en dessous. */
+    columns?: 1 | 2;
+    /** La zone d'actions, alignée à droite sous les champs. */
+    actions?: ReactNode;
+};
+export declare function Form({ columns, actions, children, className, ...props }: FormProps): import("react").JSX.Element;

package/dist/types/components/form/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste du bloc de formulaire (ADR 0005, ADR 0015). Mise en page seule, sans moteur. */
+export declare const formManifest: ComponentManifest;

package/dist/types/components/freshness/freshness.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes } from 'react';
+/**
+ * L'indicateur de fraîcheur d'une donnée : l'âge de la dernière mise à jour, avec une
+ * pastille qui vire au rouge quand la donnée est périmée. Il se rend seul, hors d'une
+ * table — une cellule comme un bandeau de provenance l'utilisent (ADR 0010).
+ *
+ * Aucun libellé ne vient de l'app : l'âge est déjà formaté par l'appelant (le cœur n'a
+ * pas d'i18n), et c'est l'appelant qui décide du seuil de péremption via `stale`.
+ */
+export type FreshnessProps = HTMLAttributes<HTMLSpanElement> & {
+    /** L'âge déjà formaté par l'appelant, ex. « il y a 2 heures ». */
+    label: string;
+    /** L'horodatage absolu, pour l'infobulle ; absent, pas d'infobulle. */
+    title?: string | null;
+    /** Vrai quand la donnée dépasse le seuil de péremption décidé par l'appelant. */
+    stale?: boolean;
+};
+export declare function Freshness({ label, title, stale, className, ...props }: FreshnessProps): import("react").JSX.Element;

package/dist/types/components/freshness/manifest.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/**
+ * Le manifeste de l'indicateur de fraîcheur (ADR 0005). L'âge est injecté par
+ * l'appelant : c'est lui qui formate (« il y a 2 heures ») et qui décide du seuil de
+ * péremption ; le cœur ne fait que le rendre.
+ */
+export declare const freshnessManifest: ComponentManifest;

package/dist/types/components/input/input.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentProps } from 'react';
+/**
+ * Le champ de saisie du cœur : un `<input>` stylé par les tokens. Il n'impose aucune
+ * validation ni aucun état d'app — l'appelant passe ses props HTML et ses classes.
+ */
+export declare function Input({ className, type, ...props }: ComponentProps<'input'>): import("react").JSX.Element;

package/dist/types/components/input/manifest.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/**
+ * Le manifeste du champ de saisie (ADR 0005). Le cœur ne pose ni validation ni état :
+ * l'appelant passe ses props HTML, la valeur et le rappel restent chez lui.
+ */
+export declare const inputManifest: ComponentManifest;

package/dist/types/components/label/label.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentProps } from 'react';
+/** Le libellé d'un champ : associé au contrôle par `htmlFor`. Tout texte vient de l'app. */
+export declare function Label({ className, ...props }: ComponentProps<'label'>): import("react").JSX.Element;

package/dist/types/components/label/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste du libellé (ADR 0005, ADR 0015). */
+export declare const labelManifest: ComponentManifest;

package/dist/types/components/meter/manifest.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/**
+ * Le manifeste du Meter (ADR 0005). Il documente les deux tailles du même atome :
+ * la barre large, qui a besoin du libellé du seuil, et la barre compacte d'une cellule.
+ */
+export declare const meterManifest: ComponentManifest;

package/dist/types/components/meter/meter.d.ts

@@ -0,0 +1,23 @@
+import type { HTMLAttributes } from 'react';
+type Scale = {
+    /** La valeur mesurée, sur `0..max`. */
+    value: number;
+    /** Le haut de l'échelle (`3` pour un score, `1` pour un Noul). */
+    max: number;
+    /** Le seuil de comparaison, marqué sur la barre. */
+    threshold?: number | null;
+};
+export type MeterProps = HTMLAttributes<HTMLDivElement> & Scale & {
+    label: string;
+    decimals?: number;
+    confidence?: number | null;
+    /** Le texte du seuil, donné par l'appelant (le cœur n'a pas d'i18n). */
+    thresholdLabel?: (threshold: number) => string;
+};
+export declare function Meter({ label, value, max, threshold, decimals, confidence, thresholdLabel, className, ...props }: MeterProps): import("react").JSX.Element;
+export type CompactMeterProps = HTMLAttributes<HTMLDivElement> & Scale & {
+    label: string;
+};
+/** La même barre, en plus court : une cellule de table dense. */
+export declare function CompactMeter({ label, value, max, threshold, className, ...props }: CompactMeterProps): import("react").JSX.Element;
+export {};

package/dist/types/components/number-field/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste du champ numérique (ADR 0005, ADR 0015). Le natif porte pas et bornes. */
+export declare const numberFieldManifest: ComponentManifest;

package/dist/types/components/number-field/number-field.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentProps } from 'react';
+/**
+ * Le champ numérique du cœur : un `<input>` en `type="number"`, donc le pas (`step`) et
+ * les bornes (`min`/`max`) viennent du natif. Aucune validation ni i18n : la valeur et le
+ * rappel restent chez l'appelant, comme `Input` (ADR 0015).
+ */
+export declare function NumberField({ type, ...props }: ComponentProps<'input'>): import("react").JSX.Element;

package/dist/types/components/progress-bar/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste de la ProgressBar (ADR 0005). */
+export declare const progressBarManifest: ComponentManifest;

package/dist/types/components/progress-bar/progress-bar.d.ts

@@ -0,0 +1,12 @@
+import type { HTMLAttributes } from 'react';
+export type ProgressBarProps = HTMLAttributes<HTMLDivElement> & {
+    /** L'avancement, sur `0..max`. */
+    value: number;
+    /** Le total : `100` par défaut. */
+    max?: number;
+    /** Le nom de ce qui avance ; sert aussi de nom accessible. */
+    label?: string;
+    /** Affiche le pourcentage à droite, calculé (jamais un texte produit). */
+    showValue?: boolean;
+};
+export declare function ProgressBar({ value, max, label, showValue, className, ...props }: ProgressBarProps): import("react").JSX.Element;

package/dist/types/components/radio/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste du groupe radio (ADR 0005, ADR 0015). */
+export declare const radioManifest: ComponentManifest;