@nomosui/react 0.4.0

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

@@ -0,0 +1,5 @@
+import type { ComponentProps } from 'react';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+/** Un groupe de boutons radio ; l'app possède la valeur et le rappel. */
+export declare function RadioGroup({ className, ...props }: ComponentProps<typeof RadioGroupPrimitive.Root>): import("react").JSX.Element;
+export declare function RadioGroupItem({ className, ...props }: ComponentProps<typeof RadioGroupPrimitive.Item>): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * La note (ADR 0015) : `value` sur `max` étoiles, **contrôlée**. Interactive seulement si
+ * l'app fournit `onValueChange` (sinon un affichage, `role="img"`). A11y : `radiogroup` de
+ * `radio`, flèches et Home/End. Aucun libellé n'est inventé : le nom accessible vient de
+ * l'appelant.
+ */
+export type RatingProps = {
+    value: number;
+    /** Le nombre d'étoiles : 5 par défaut. */
+    max?: number;
+    /** Rend la note interactive quand fourni ; l'app porte la valeur. */
+    onValueChange?: (value: number) => void;
+    /** Affichage seul, même si `onValueChange` est fourni. */
+    readOnly?: boolean;
+    /** Le nom accessible du groupe ; le cœur n'a pas d'i18n. */
+    ariaLabel?: string;
+    className?: string;
+};
+export declare function Rating({ value, max, onValueChange, readOnly, ariaLabel, className, }: RatingProps): import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste du champ de recherche (ADR 0005, ADR 0015). Le cœur ne connaît pas l'i18n. */
+export declare const searchFieldManifest: ComponentManifest;

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

@@ -0,0 +1,14 @@
+/**
+ * Le champ de recherche du cœur : une icône, un `<input type="search">` et un bouton
+ * d'effacement qui n'apparaît que si le champ est rempli. Contrôlé par props ; aucun
+ * état, aucun i18n — le libellé « effacer » est injecté (ADR 0015).
+ */
+export type SearchFieldProps = {
+    value: string;
+    onChange: (value: string) => void;
+    /** Le libellé du bouton d'effacement (le cœur n'a pas d'i18n). */
+    clearLabel: string;
+    placeholder?: string;
+    className?: string;
+};
+export declare function SearchField({ value, onChange, clearLabel, placeholder, className, }: SearchFieldProps): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,7 @@
+import type { ComponentProps } from 'react';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+/**
+ * Un séparateur : un trait de bordure qui sépare deux contenus, horizontal ou vertical.
+ * Décoratif par défaut (Radix), donc invisible aux lecteurs d'écran sauf demande.
+ */
+export declare function Separator({ className, orientation, decorative, ...props }: ComponentProps<typeof SeparatorPrimitive.Root>): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,3 @@
+import type { ComponentProps } from 'react';
+/** Un bloc de chargement : une surface pulsante qui tient la place d'un contenu. */
+export declare function Skeleton({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,4 @@
+import type { ComponentProps } from 'react';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+/** Un interrupteur contrôlé : le cœur fournit l'apparence et l'a11y (Radix), pas l'état. */
+export declare function Switch({ className, ...props }: ComponentProps<typeof SwitchPrimitive.Root>): import("react").JSX.Element;

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

@@ -0,0 +1,7 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/**
+ * Le manifeste de la table (ADR 0005). La table est un atome composé : le catalogue
+ * enregistre la coquille `Table`, et le manifeste documente le jeu de parts — c'est
+ * l'ensemble qui se pose, pas la coquille seule.
+ */
+export declare const tableManifest: ComponentManifest;

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

@@ -0,0 +1,14 @@
+import type { ComponentProps } from 'react';
+/**
+ * La table dense : une grille de lignes, en parts importables séparément. Aucune part
+ * ne nomme un produit ni ne lit l'i18n de l'app — les libellés viennent de l'appelant,
+ * les cellules de ce qu'il rend (ADR 0010).
+ *
+ * Les classes de l'appelant se fusionnent après celles du cœur, jamais avant.
+ */
+export declare function Table({ className, ...props }: ComponentProps<'table'>): import("react").JSX.Element;
+export declare function TableHeader({ className, ...props }: ComponentProps<'thead'>): import("react").JSX.Element;
+export declare function TableBody({ className, ...props }: ComponentProps<'tbody'>): import("react").JSX.Element;
+export declare function TableRow({ className, ...props }: ComponentProps<'tr'>): import("react").JSX.Element;
+export declare function TableHead({ className, ...props }: ComponentProps<'th'>): import("react").JSX.Element;
+export declare function TableCell({ className, ...props }: ComponentProps<'td'>): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,3 @@
+import type { ComponentProps } from 'react';
+/** Un champ de saisie multiligne, stylé par les tokens. Rien d'autre que les props HTML. */
+export declare function Textarea({ className, ...props }: ComponentProps<'textarea'>): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,19 @@
+import type { HTMLAttributes } from 'react';
+/**
+ * La frise (ADR 0015) : une suite d'événements datés, du plus récent au plus ancien.
+ * Présentation seule — l'ordre, le format de `at` et le texte viennent de l'appelant.
+ * Aucune donnée d'app, aucun état.
+ */
+export type TimelineItem = {
+    id: string;
+    /** La date/l'heure déjà formatée, fournie par l'appelant. */
+    at: string;
+    label: string;
+    detail?: string;
+};
+export type TimelineProps = HTMLAttributes<HTMLOListElement> & {
+    items: TimelineItem[];
+    /** Le nom accessible de la frise ; le cœur n'a pas d'i18n. */
+    ariaLabel?: string;
+};
+export declare function Timeline({ items, ariaLabel, className, ...props }: TimelineProps): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+import { type Tone } from '../../lib/tone';
+type ToastBase = {
+    /** Le ton : une intention, pas une couleur (cf. `toneClasses`). Défaut `info`. */
+    tone?: Tone;
+    /** Le message principal : une ligne, jamais une phrase. */
+    message: ReactNode;
+    /** Un détail sous le message, plus discret (sortie de script, cause). */
+    description?: ReactNode;
+    /** Une action : 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).
+ */
+type ToastClose = {
+    onClose?: undefined;
+    closeLabel?: undefined;
+} | {
+    onClose: () => void;
+    closeLabel: string;
+};
+export type ToastProps = ToastBase & ToastClose;
+/**
+ * La notification : une carte flottante qui dit ce qu'une action a produit. Présentation
+ * seule — la **file** et les minuteurs vivent dans `ToastProvider` (ADR 0020). L'app
+ * fournit le message, l'action et le libellé de fermeture.
+ */
+export declare function Toast({ tone, message, description, action, icon, onClose, closeLabel, className, }: ToastProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,3 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/** Le manifeste de la bascule (ADR 0005, ADR 0015). Deux états, contrôlés par props. */
+export declare const toggleManifest: ComponentManifest;

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

@@ -0,0 +1,31 @@
+import type { ComponentProps } from 'react';
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import { type VariantProps } from 'class-variance-authority';
+/**
+ * Le bouton à deux états : pressé ou non. Un `Switch` dit un réglage qui persiste ; un
+ * `Toggle` est une bascule ponctuelle (mode d'affichage, filtre). Contrôlé par props —
+ * `pressed` + `onPressedChange` — ou laissé libre via `defaultPressed` (ADR 0015).
+ */
+export declare const toggleVariantsConfig: {
+    readonly variants: {
+        readonly variant: {
+            readonly default: "bg-transparent";
+            readonly outline: "border border-input bg-transparent hover:bg-accent hover:text-accent-foreground";
+        };
+        readonly size: {
+            readonly default: "h-10 px-3 min-w-10";
+            readonly sm: "h-9 px-2.5 min-w-9";
+            readonly lg: "h-11 px-5 min-w-11";
+        };
+    };
+    readonly defaultVariants: {
+        readonly variant: "default";
+        readonly size: "default";
+    };
+};
+export declare const toggleVariants: (props?: ({
+    readonly variant?: "default" | "outline" | null | undefined;
+    readonly size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ToggleProps = ComponentProps<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>;
+export declare function Toggle({ className, variant, size, ...props }: ToggleProps): import("react").JSX.Element;

package/dist/types/components/toggle-group/manifest.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/**
+ * Le manifeste du groupe de bascules (ADR 0005, ADR 0015). Le catalogue enregistre le
+ * groupe ; les items sont des parts importables.
+ */
+export declare const toggleGroupManifest: ComponentManifest;

package/dist/types/components/toggle-group/toggle-group.d.ts

@@ -0,0 +1,8 @@
+import { type ComponentProps } from 'react';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import type { VariantProps } from 'class-variance-authority';
+import { toggleVariants } from '../toggle/toggle';
+type ToggleGroupVariants = VariantProps<typeof toggleVariants>;
+export declare function ToggleGroup({ className, variant, size, children, ...props }: ComponentProps<typeof ToggleGroupPrimitive.Root> & ToggleGroupVariants): import("react").JSX.Element;
+export declare function ToggleGroupItem({ className, variant, size, ...props }: ComponentProps<typeof ToggleGroupPrimitive.Item> & ToggleGroupVariants): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import type { ComponentManifest } from '../../catalogue/contract';
+/**
+ * Le manifeste de l'Arbre (ADR 0005, ADR 0015). Il documente les deux exports du même
+ * atome : `Tree` (navigation, sélection simple) et `SelectionTree` (sélection multiple),
+ * comme le Meter documente ses deux tailles.
+ */
+export declare const treeManifest: ComponentManifest;

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

@@ -0,0 +1,42 @@
+/**
+ * L'arbre (ADR 0015) : une hiérarchie de nœuds, **contrôlée par props**. Le cœur ne
+ * possède ni l'expansion ni la sélection — l'app les porte (`expandedIds`, `selectedId`
+ * ou `selectedIds`) et reçoit les gestes par rappel, comme la `DataTable` reçoit son état
+ * (ADR 0010). Seul le **focus** (navigation clavier) est interne : c'est de la mécanique,
+ * pas une donnée d'app.
+ *
+ * `Tree` navigue et ouvre (sélection simple) ; `SelectionTree` coche plusieurs nœuds.
+ * A11y : rôle `tree` / `treeitem`, `aria-expanded`, `aria-selected`, et les flèches.
+ */
+export type TreeNode = {
+    id: string;
+    label: string;
+    /** Les enfants : un nœud sans enfants est une feuille. */
+    children?: TreeNode[];
+};
+type TreeBaseProps = {
+    nodes: TreeNode[];
+    /** Les ids des nœuds ouverts (contrôlé). */
+    expandedIds?: string[];
+    /** Appelé pour ouvrir/fermer un nœud — l'app décide du nouvel état. */
+    onToggle?: (id: string) => void;
+    /** Les ids des nœuds sélectionnés (contrôlé). */
+    selectedIds?: string[];
+    /** Appelé au clic ou à Entrée/Espace — l'app décide de la suite. */
+    onSelect?: (id: string) => void;
+    multi?: boolean;
+    /** Le nom accessible de l'arbre ; le cœur n'invente aucun libellé. */
+    ariaLabel?: string;
+    className?: string;
+};
+export type TreeProps = Omit<TreeBaseProps, 'selectedIds' | 'multi'> & {
+    /** Le nœud sélectionné (contrôlé, optionnel) : la navigation. */
+    selectedId?: string | null;
+};
+export declare function Tree({ selectedId, ...props }: TreeProps): import("react").JSX.Element;
+export type SelectionTreeProps = Omit<TreeBaseProps, 'multi'> & {
+    /** Les nœuds cochés (contrôlé) : la sélection multiple. */
+    selectedIds?: string[];
+};
+export declare function SelectionTree(props: SelectionTreeProps): import("react").JSX.Element;
+export {};

package/dist/types/features/data-table-features.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Ce qu'une colonne peut porter au-delà de sa définition TanStack. Le tri par défaut
+ * vit ici, porté par la colonne : le cœur ne connaît aucun mot produit (ADR 0010).
+ */
+export type DataTableColumnMeta = {
+    defaultSort?: 'asc' | 'desc';
+};
+/**
+ * Le seul jeu de fonctionnalités que partagent les tables d'objets routés : filtrage
+ * par facettes des colonnes, recherche globale, tri et pagination.
+ */
+export declare const dataTableFeatures: {
+    columnFilteringFeature: import("@tanstack/table-core").TableFeature;
+    columnVisibilityFeature: import("@tanstack/table-core").TableFeature;
+    globalFilteringFeature: import("@tanstack/table-core").TableFeature;
+    rowSortingFeature: import("@tanstack/table-core").TableFeature;
+    rowPaginationFeature: import("@tanstack/table-core").TableFeature;
+    filteredRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+    sortedRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+    paginatedRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+    columnMeta: DataTableColumnMeta;
+    sortFns: {
+        alphanumeric: import("@tanstack/table-core").CreatedSortFn<any, any>;
+        basic: import("@tanstack/table-core").CreatedSortFn<any, any>;
+        datetime: import("@tanstack/table-core").CreatedSortFn<any, any>;
+        text: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    };
+};
+export type DataTableFeatures = typeof dataTableFeatures;

package/dist/types/features/faceted-data-table.d.ts

@@ -0,0 +1,99 @@
+import { type ReactNode } from 'react';
+import { type ColumnDef, type ColumnFiltersState, type ColumnVisibilityState, type FilterFn, type RowData, type SortingState } from '@tanstack/react-table';
+import type { FacetOption } from '../components/facet-filter/facet-filter';
+import { type DataTableFeatures } from './data-table-features';
+/**
+ * La coquille de table à facettes : barre d'outils, corps trié/paginé, sélection
+ * optionnelle, détail de ligne optionnel. C'est une **feature** (ADR 0010), pas un
+ * atome : elle porte le comportement — dont le fait qu'une ligne ouvre un détail, et son
+ * placement (surcouche ou en ligne) — quand l'app fournit les colonnes, les facettes et
+ * le **contenu** (du détail comme des actions de masse).
+ *
+ * **Contrôlable** (ADR 0014) : sans `state`, elle garde son état interne ; avec `state` +
+ * `onStateChange`, l'app est la source de vérité — c'est par là que la synchro URL passe,
+ * sans que le cœur connaisse react-router.
+ */
+export type FacetDef = {
+    id: string;
+    label: string;
+    options: FacetOption[];
+};
+export type DataTableLabels = {
+    search: string;
+    reset: string;
+    clear: string;
+    empty: string;
+    unit: string;
+    shown: (shown: number, total: number, unit: string) => string;
+    rows: string;
+    pageOf: (page: number, total: number) => string;
+    previous: string;
+    next: string;
+};
+/**
+ * L'état d'une table, tel qu'on peut le contrôler de l'extérieur. `openedKey` est la clé
+ * (fournie par `rowKey`) de la ligne dont le détail est ouvert, ou `null` ; `selection`
+ * est la liste des clés sélectionnées.
+ */
+export type TableState = {
+    sorting: SortingState;
+    globalFilter: string;
+    columnFilters: ColumnFiltersState;
+    pagination: {
+        pageIndex: number;
+        pageSize: number;
+    };
+    openedKey: string | null;
+    selection: string[];
+    columnVisibility: ColumnVisibilityState;
+    columnOrder: string[];
+};
+/** La clé stable d'une ligne (pour l'URL, le détail partageable, la sélection). */
+export type RowKey<T> = (row: T) => string;
+/**
+ * Le détail d'une ligne : la coquille possède le placement, l'app le contenu. `overlay`
+ * ouvre une surcouche (défaut), `inline` déplie la ligne.
+ */
+export type RowDetail<T> = {
+    placement?: 'overlay' | 'inline';
+    render: (row: T) => ReactNode;
+};
+/**
+ * La sélection de lignes : la coquille possède les cases et la barre, l'app fournit le
+ * **contenu** de la barre d'actions de masse et ses libellés.
+ */
+export type RowSelection<T> = {
+    bulkActions?: (selected: T[]) => ReactNode;
+    selectAllLabel: string;
+    selectRowLabel: (row: T) => string;
+    selectedLabel: (count: number) => string;
+    clearLabel: string;
+};
+/**
+ * La gestion des colonnes : la coquille possède le menu et l'état de visibilité, l'app
+ * fournit la liste des colonnes masquables et leurs libellés.
+ */
+export type ColumnManager = {
+    label: string;
+    clearLabel: string;
+    columns: {
+        id: string;
+        label: string;
+    }[];
+    moveUpLabel: (label: string) => string;
+    moveDownLabel: (label: string) => string;
+};
+export declare function FacetedDataTable<T extends RowData>({ data, renderColumns, facets, globalFilterFn, labels, detail, selection, columnManager, rowKey, state, onStateChange, actions, }: {
+    data: T[];
+    renderColumns: (openDetail: (row: T) => void) => ColumnDef<DataTableFeatures, T>[];
+    facets: FacetDef[];
+    globalFilterFn: FilterFn<DataTableFeatures, T>;
+    labels: DataTableLabels;
+    detail?: RowDetail<T>;
+    selection?: RowSelection<T>;
+    columnManager?: ColumnManager;
+    rowKey?: RowKey<T>;
+    state?: TableState;
+    onStateChange?: (next: TableState) => void;
+    actions?: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/features/toast.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from 'react';
+import type { Tone } from '../lib/tone';
+/**
+ * La file de notifications (ADR 0020) : `ToastProvider` possède l'état (la file, les
+ * minuteurs d'auto-fermeture) et `useToast` l'expose. La **présentation** est le `Toast`
+ * du catalogue ; le cœur fournit la file, l'app le contenu. Aucune dépendance externe.
+ */
+export type ToastOptions = {
+    tone?: Tone;
+    message: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    /** Ne pas fermer automatiquement. */
+    persistent?: boolean;
+    /** La durée avant auto-fermeture (ms), sinon celle du provider. */
+    duration?: number;
+};
+export type ToastApi = {
+    /** Affiche une notification et rend son identifiant. */
+    show: (options: ToastOptions) => string;
+    /** Met à jour une notification existante (même identifiant). */
+    update: (id: string, options: Partial<ToastOptions>) => void;
+    /** Ferme une notification. */
+    dismiss: (id: string) => void;
+};
+export declare function useToast(): ToastApi;
+export declare function ToastProvider({ children, closeLabel, duration, }: {
+    children: ReactNode;
+    /** Le libellé accessible du bouton de fermeture ; absent, pas de bouton (auto-fermeture). */
+    closeLabel?: string;
+    /** La durée d'auto-fermeture par défaut (ms). */
+    duration?: number;
+}): import("react").JSX.Element;

package/dist/types/index.d.ts

@@ -0,0 +1,112 @@
+/**
+ * La surface publique du design system.
+ *
+ * Rien n'entre ici qui nomme un produit : le cœur est app-agnostique et partageable
+ * (ADR 0002). Un composant qui a besoin d'un mot produit pour s'expliquer appartient
+ * à l'app, pas à ce paquet.
+ */
+export { Alert } from './components/alert/alert';
+export type { AlertProps } from './components/alert/alert';
+export { alertManifest } from './components/alert/manifest';
+export { Badge, badgeVariants, badgeVariantsConfig } from './components/badge/badge';
+export type { BadgeProps } from './components/badge/badge';
+export { badgeManifest } from './components/badge/manifest';
+export { Button, buttonVariants, buttonVariantsConfig } from './components/button/button';
+export type { ButtonProps } from './components/button/button';
+export { buttonManifest } from './components/button/manifest';
+export { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, } from './components/card/card';
+export { cardManifest } from './components/card/manifest';
+export { EmptyState } from './components/empty-state/empty-state';
+export type { EmptyStateProps } from './components/empty-state/empty-state';
+export { emptyStateManifest } from './components/empty-state/manifest';
+export { Chip } from './components/chip/chip';
+export type { ChipProps } from './components/chip/chip';
+export { chipManifest } from './components/chip/manifest';
+export { Freshness } from './components/freshness/freshness';
+export type { FreshnessProps } from './components/freshness/freshness';
+export { freshnessManifest } from './components/freshness/manifest';
+export { Input } from './components/input/input';
+export { inputManifest } from './components/input/manifest';
+export { NumberField } from './components/number-field/number-field';
+export { numberFieldManifest } from './components/number-field/manifest';
+export { SearchField } from './components/search-field/search-field';
+export type { SearchFieldProps } from './components/search-field/search-field';
+export { searchFieldManifest } from './components/search-field/manifest';
+export { Label } from './components/label/label';
+export { labelManifest } from './components/label/manifest';
+export { Fieldset } from './components/fieldset/fieldset';
+export { fieldsetManifest } from './components/fieldset/manifest';
+export { Field } from './components/field/field';
+export type { FieldProps } from './components/field/field';
+export { fieldManifest } from './components/field/manifest';
+export { Form } from './components/form/form';
+export type { FormProps } from './components/form/form';
+export { formManifest } from './components/form/manifest';
+export { FacetFilter } from './components/facet-filter/facet-filter';
+export type { Facet, FacetFilterProps, FacetOption } from './components/facet-filter/facet-filter';
+export { facetFilterManifest } from './components/facet-filter/manifest';
+export { DataTableToolbar } from './components/data-table-toolbar/data-table-toolbar';
+export type { DataTableToolbarProps } from './components/data-table-toolbar/data-table-toolbar';
+export { dataTableToolbarManifest } from './components/data-table-toolbar/manifest';
+export { DataTablePagination } from './components/data-table-pagination/data-table-pagination';
+export type { DataTablePaginationProps } from './components/data-table-pagination/data-table-pagination';
+export { dataTablePaginationManifest } from './components/data-table-pagination/manifest';
+export { FacetedDataTable } from './features/faceted-data-table';
+export type { ColumnManager, DataTableLabels, FacetDef, RowDetail, RowKey, RowSelection, TableState, } from './features/faceted-data-table';
+export { dataTableFeatures, type DataTableColumnMeta, type DataTableFeatures, } from './features/data-table-features';
+export { SheetDescription, SheetHeader, SheetTitle } from './internal/sheet';
+export { TooltipProvider } from './internal/tooltip';
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, SelectValue, } from './internal/select';
+export { CompactMeter, Meter } from './components/meter/meter';
+export type { CompactMeterProps, MeterProps } from './components/meter/meter';
+export { meterManifest } from './components/meter/manifest';
+export { Separator } from './components/separator/separator';
+export { separatorManifest } from './components/separator/manifest';
+export { Skeleton } from './components/skeleton/skeleton';
+export { skeletonManifest } from './components/skeleton/manifest';
+export { Table, TableBody, TableCell, TableHead, TableHeader, TableRow, } from './components/table/table';
+export { tableManifest } from './components/table/manifest';
+export { Textarea } from './components/textarea/textarea';
+export { textareaManifest } from './components/textarea/manifest';
+export { Checkbox } from './components/checkbox/checkbox';
+export { checkboxManifest } from './components/checkbox/manifest';
+export { Switch } from './components/switch/switch';
+export { switchManifest } from './components/switch/manifest';
+export { RadioGroup, RadioGroupItem } from './components/radio/radio';
+export { radioManifest } from './components/radio/manifest';
+export { Toggle, toggleVariants, toggleVariantsConfig } from './components/toggle/toggle';
+export type { ToggleProps } from './components/toggle/toggle';
+export { toggleManifest } from './components/toggle/manifest';
+export { ToggleGroup, ToggleGroupItem } from './components/toggle-group/toggle-group';
+export { toggleGroupManifest } from './components/toggle-group/manifest';
+export { Toast } from './components/toast/toast';
+export type { ToastProps } from './components/toast/toast';
+export { toastManifest } from './components/toast/manifest';
+export { ToastProvider, useToast } from './features/toast';
+export type { ToastApi, ToastOptions } from './features/toast';
+export { SelectionTree, Tree } from './components/tree/tree';
+export type { SelectionTreeProps, TreeProps, TreeNode } from './components/tree/tree';
+export { treeManifest } from './components/tree/manifest';
+export { Counter } from './components/counter/counter';
+export type { CounterProps } from './components/counter/counter';
+export { counterManifest } from './components/counter/manifest';
+export { ProgressBar } from './components/progress-bar/progress-bar';
+export type { ProgressBarProps } from './components/progress-bar/progress-bar';
+export { progressBarManifest } from './components/progress-bar/manifest';
+export { Rating } from './components/rating/rating';
+export type { RatingProps } from './components/rating/rating';
+export { ratingManifest } from './components/rating/manifest';
+export { Timeline } from './components/timeline/timeline';
+export type { TimelineItem, TimelineProps } from './components/timeline/timeline';
+export { timelineManifest } from './components/timeline/manifest';
+export { catalogue, componentNames, findComponent, validateCatalogue } from './catalogue/registry';
+export type { CatalogueEntry } from './catalogue/registry';
+export { componentManifestSchema } from './catalogue/contract';
+export type { ComponentManifest, ComponentProp, ComponentUsage, ComponentVariant, } from './catalogue/contract';
+export { cn } from './lib/cn';
+export { TONES, toneClasses } from './lib/tone';
+export type { Tone } from './lib/tone';
+export { resolveSkin } from './tokens/skin';
+export { renderCss } from './tokens/build.mjs';
+export type { TokensDocument } from './tokens/build.mjs';
+export { tokensResource } from './tokens/resource';

package/dist/types/internal/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist/types/internal/select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };