@studiolxd/brand 38.12.4

package/dist/_types/atoms/Slider/Slider.d.ts

@@ -0,0 +1,39 @@
+import { Slider as BaseSlider } from '@base-ui/react/slider';
+import './Slider.css';
+type BaseSliderRootProps = Omit<React.ComponentPropsWithoutRef<typeof BaseSlider.Root>, 'className' | 'value' | 'defaultValue' | 'onValueChange' | 'onValueCommitted'>;
+export interface SliderProps extends BaseSliderRootProps {
+    /** Valor actual (controlado). Un número, o una lista para un rango. */
+    value?: number | number[];
+    /** Valor al montar (no controlado). */
+    defaultValue?: number | number[];
+    /** Se llama mientras se mueve. Devuelve la misma forma que recibió `value`. */
+    onValueChange?: (value: number | number[]) => void;
+    /** Se llama al soltar: el sitio para guardar, no `onValueChange`. */
+    onValueCommitted?: (value: number | number[]) => void;
+    /**
+     * Nombre accesible del deslizador. Con un solo pulgar es su nombre; con
+     * varios lo completa `thumbLabel`.
+     */
+    label?: string;
+    /**
+     * Nombre accesible de cada pulgar. Por defecto, en castellano: con dos
+     * pulgares «Mínimo» y «Máximo»; con más, «Valor 1», «Valor 2»…
+     */
+    thumbLabel?: (index: number, total: number) => string;
+    /** Muestra el valor formateado junto a la banda. */
+    showValue?: boolean;
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * Deslizador de un valor o de un rango (Base UI Slider): el espaciado de un
+ * editor de tema, el precio máximo de un filtro, la opacidad de una capa.
+ *
+ * Devuelve **la misma forma que recibe**: un número si se le dio un número, una
+ * lista si se le dio una lista. Un pulgar por entrada de la lista.
+ *
+ * `onValueChange` avisa mientras se arrastra —para la vista previa— y
+ * `onValueCommitted` al soltar, que es donde va el guardado.
+ */
+export declare function Slider({ value, defaultValue, onValueChange, onValueCommitted, label, thumbLabel, showValue, orientation, className, ...rest }: SliderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/_types/atoms/Sparkline/Sparkline.d.ts

@@ -0,0 +1,41 @@
+import './Sparkline.css';
+/** Las ocho ranuras categóricas del sistema — `chart-series-1`…`8`. */
+export type SparklineSeries = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export interface SparklineProps extends Omit<React.ComponentPropsWithoutRef<'svg'>, 'width' | 'height' | 'values' | 'color'> {
+    /** Serie a dibujar, en orden. Doce puntos es la longitud de referencia. */
+    values: number[];
+    /** Trazo suelto o trazo con velo por debajo. Default `line`. */
+    type?: 'line' | 'area';
+    /** Ancho en px. Default 80, espejo de `--sparkline-width`. */
+    width?: number;
+    /** Alto en px. Default 24, espejo de `--sparkline-height`. */
+    height?: number;
+    /** Punto al final de la serie, en el color de acento. Default `true`. */
+    marker?: boolean;
+    /** Línea del cero cuando la serie lo cruza. Default `true`. */
+    baseline?: boolean;
+    /**
+     * Ranura de serie del trazo (1–8), para emparejar la chispa con un gráfico
+     * que esté al lado. Sin ella la chispa va en el gris de atenuación: el dato
+     * que se lee es la cifra que tiene al lado.
+     */
+    series?: SparklineSeries;
+    /**
+     * Descripción para lectores de pantalla. Sin ella la chispa se marca como
+     * decorativa —lo correcto dentro de un `StatTile`, donde la cifra y su
+     * variación ya dicen lo que la chispa enseña—.
+     */
+    ariaLabel?: string;
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * La chispa: una serie diminuta sin ejes ni rótulos, para acompañar a una cifra
+ * dentro de un `StatTile`. No es un gráfico —no se leen valores en ella—, es la
+ * forma de la tendencia.
+ *
+ * La ranura de color viaja en `data-series` y la resuelve la hoja: un atributo
+ * `style` con la referencia al token lo descartaría una app servida con
+ * `style-src 'self'`.
+ */
+export declare const Sparkline: import("react").ForwardRefExoticComponent<SparklineProps & import("react").RefAttributes<SVGSVGElement>>;

package/dist/_types/atoms/Spinner/Spinner.d.ts

@@ -0,0 +1,10 @@
+import './Spinner.css';
+export type SpinnerSize = 'sm' | 'md' | 'lg';
+export interface SpinnerProps {
+    size?: SpinnerSize;
+    /** Texto anunciado por lectores de pantalla. Default castellano: «Cargando…». Ignorado cuando aria-hidden es true. */
+    label?: string;
+    /** Cuando true, el spinner es puramente decorativo (sin rol ni anuncio). */
+    'aria-hidden'?: boolean;
+}
+export declare function Spinner({ size, label, 'aria-hidden': ariaHidden }: SpinnerProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/atoms/Stack/Stack.d.ts

@@ -0,0 +1,39 @@
+import type { ReactNode } from 'react';
+import './Stack.css';
+export interface StackProps extends React.ComponentPropsWithoutRef<'div'> {
+    /**
+     * Aire entre piezas: compacto, base o amplio. `sm` agrupa **líneas de un
+     * mismo dato** (nombre y correo, título y subtítulo); `md` (por defecto)
+     * separa campos y piezas distintas; `lg`, secciones.
+     */
+    gap?: 'sm' | 'md' | 'lg';
+    /**
+     * Alineación de las piezas en el eje cruzado. `'start'` (por defecto):
+     * cada pieza mide lo suyo, sin estirarse —el caso de uso documentado de
+     * agrupar piezas pequeñas—. `'stretch'`: las piezas ocupan todo el ancho
+     * disponible —para cuando `Stack` hace de raíz de una página con
+     * contenido ancho (tablas, formularios, tarjetas) que debe llegar al
+     * borde del contenedor.
+     */
+    align?: 'start' | 'stretch';
+    /**
+     * Orden en móvil (por debajo de `md`): el del JSX o el inverso. En
+     * escritorio manda siempre el JSX. Invierte solo el orden visual —no el del
+     * DOM ni el de tabulación—, así que solo para piezas donde eso no importa
+     * (un enlace de vuelta sobre la cabecera).
+     */
+    mobileOrder?: 'normal' | 'reverse';
+    children: ReactNode;
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * Apila piezas con aire por token. Es el envoltorio explícito de «estas piezas
+ * van juntas» (una cabecera y su enlace de vuelta en una celda de `Columns`),
+ * sin fondo ni semántica: `div.stack`.
+ *
+ * `{...rest}` (`role`, `aria-*`, `id`, `data-*`…) se reenvía al `<div>`: una
+ * pila puede ser el grupo con nombre accesible que pide un formulario sin
+ * tener que envolverla en un elemento nativo aparte.
+ */
+export declare function Stack({ gap, align, mobileOrder, children, className, ...rest }: StackProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/atoms/StarRating/StarRating.d.ts

@@ -0,0 +1,55 @@
+import './StarRating.css';
+export interface StarRatingProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onChange' | 'defaultValue'> {
+    /** Valoración mostrada. En lectura se redondea a media estrella. */
+    value?: number;
+    /** Valoración al montar, cuando la entrada no está controlada. */
+    defaultValue?: number;
+    /** Se llama con la valoración elegida. Solo en entrada (`readOnly={false}`). */
+    onValueChange?: (value: number) => void;
+    /** Cuántas estrellas tiene la escala. */
+    max?: number;
+    /**
+     * Solo lectura (por defecto). El componente nace para **mostrar** una media;
+     * para capturar una valoración hay que pedirlo con `readOnly={false}`.
+     */
+    readOnly?: boolean;
+    /** Deshabilita la entrada. */
+    disabled?: boolean;
+    /** Talla de la estrella, relativa al texto que la rodea. */
+    size?: 'sm' | 'md' | 'lg';
+    /** `name` de los radios que envían la valoración con el formulario. */
+    name?: string;
+    /** Idioma con el que se escribe el número del nombre accesible. */
+    locale?: string;
+    /**
+     * Nombre accesible en lectura: recibe el valor ya redondeado a media estrella
+     * y el máximo. Default: «4,5 de 5 estrellas» (castellano). Una app
+     * multiidioma debe pasarlo traducido.
+     */
+    valueLabel?: (value: number, max: number) => string;
+    /**
+     * Nombre accesible de cada estrella elegible. Default: «3 de 5 estrellas»
+     * (castellano). Una app multiidioma debe pasarlo traducido.
+     */
+    optionLabel?: (value: number, max: number) => string;
+    /**
+     * Nombre accesible del grupo en modo entrada. Default: «Valoración»
+     * (castellano). Una app multiidioma debe pasarlo traducido.
+     */
+    groupLabel?: string;
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * Valoración en estrellas, de lectura o de entrada.
+ *
+ * **En lectura** es una sola imagen: `role="img"` con el valor exacto en el
+ * nombre accesible («4,5 de 5 estrellas»), no cinco iconos que el lector tenga
+ * que contar. Admite **media estrella**, que es como se lee una media.
+ *
+ * **En entrada** (`readOnly={false}`) es un grupo de radios nativos —teclado,
+ * envío de formulario y estado marcado vienen del navegador— con una estrella
+ * por opción. La entrada va en pasos enteros: la media estrella describe una
+ * media calculada, no algo que una persona elija.
+ */
+export declare function StarRating({ value: valueProp, defaultValue, onValueChange, max, readOnly, disabled, size, name: nameProp, locale, valueLabel, optionLabel, groupLabel, className, ...rest }: StarRatingProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/atoms/StepMarker/StepMarker.d.ts

@@ -0,0 +1,35 @@
+import { type IconName } from '../Icon/Icon';
+import './StepMarker.css';
+/** Estado del paso: decide si la marca va rellena o hueca y qué contenido lleva por defecto. */
+export type StepMarkerState = 'done' | 'current' | 'pending' | 'neutral';
+/** Color del relleno. Las mismas variantes que `NumberBadgeVariant`, mapeadas 1:1. */
+export type StepMarkerTone = 'primary' | 'accent-1' | 'accent-2' | 'support-1' | 'support-2' | 'danger' | 'success' | 'neutral';
+export type StepMarkerSize = 'sm' | 'md';
+export interface StepMarkerProps {
+    /**
+     * Estado del paso. `done` y `current` van rellenos con el tono; `pending`
+     * es una marca hueca (filete y cifra secundaria, sin tono); `neutral` —el
+     * de `Steps`, que no tiene noción de progreso— va relleno con el tono,
+     * igual que `current`. Default `neutral`.
+     */
+    state?: StepMarkerState;
+    /** Color del relleno en los estados rellenos (`done`, `current`, `neutral`). Sin efecto en `pending`. Default `primary`. */
+    tone?: StepMarkerTone;
+    /** Talla de la marca. Default `md` (32px, la de `Stepper`). */
+    size?: StepMarkerSize;
+    /** La cifra del paso. Se ignora si hay `icon` o si `state` es `done`. */
+    count?: number;
+    /** Icono del paso, en vez de la cifra. Se ignora si `state` es `done`, que siempre muestra el check. */
+    icon?: IconName;
+    className?: string;
+}
+/**
+ * La marca de un paso: un cuadrado —el radio del sistema, no un círculo—
+ * con una cifra, un icono o el check de completado dentro. La comparten
+ * `Stepper` (que tiene estado: completado, actual, pendiente) y `Steps`
+ * (que no lo tiene, y usa el estado `neutral`).
+ *
+ * Es puramente decorativa: `aria-hidden` siempre, porque la numeración
+ * semántica la da el `<ol>` que la contiene, no la cifra pintada dentro.
+ */
+export declare function StepMarker({ state, tone, size, count, icon, className }: StepMarkerProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/atoms/Switcher/Switcher.d.ts

@@ -0,0 +1,22 @@
+import { Switch as BaseSwitch } from '@base-ui/react/switch';
+import './Switcher.css';
+type BaseSwitchRootProps = Omit<React.ComponentPropsWithoutRef<typeof BaseSwitch.Root>, 'className'>;
+export interface SwitcherProps extends Omit<BaseSwitchRootProps, 'onCheckedChange'> {
+    /** Cambio de estado. Solo el estado: el DS no expone los detalles del evento. */
+    onCheckedChange?: (checked: boolean) => void;
+    size?: 'sm' | 'md' | 'lg';
+    /** Marca el estado de error: aplica la clase `switcher--error` y `aria-invalid`. */
+    error?: boolean;
+    /** Valor enviado con el formulario cuando está activo. Default del navegador: `"on"`. */
+    value?: string;
+    className?: string;
+}
+/**
+ * Switcher (Base UI Switch). `ref` y `{...rest}` se reenvían al **Root de Base UI** —
+ * el elemento interactivo con `role="switch"` — para soportar react-hook-form
+ * (`Controller`) y la inyección de props del consumidor (`aria-*`, `data-*`, `id`,
+ * `name`, `checked`, `onCheckedChange`…). `className` se concatena tras las propias.
+ * Para componer con otro elemento, usa la prop `render` de Base UI.
+ */
+export declare const Switcher: import("react").ForwardRefExoticComponent<SwitcherProps & import("react").RefAttributes<HTMLElement>>;
+export {};

package/dist/_types/atoms/Tabs/Tabs.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+import './Tabs.css';
+export interface TabsProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: 'horizontal' | 'vertical';
+    className?: string;
+    children: ReactNode;
+}
+export declare function Tabs({ orientation, className, children, onValueChange, ...props }: TabsProps): import("react/jsx-runtime").JSX.Element;
+export interface TabsListProps extends React.ComponentPropsWithoutRef<'div'> {
+    variant?: 'underline' | 'pill';
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * La barra de pestañas. `{...rest}` (`aria-label`, `aria-labelledby`, `id`,
+ * `data-*`…) se reenvía al `role="tablist"`: es la forma de darle nombre
+ * accesible cuando hay más de un juego de pestañas en la página.
+ */
+export declare function TabsList({ variant, className, children, ...rest }: TabsListProps): import("react/jsx-runtime").JSX.Element;
+export interface TabsTriggerProps {
+    value: string;
+    disabled?: boolean;
+    className?: string;
+    children: ReactNode;
+}
+export declare function TabsTrigger({ value, disabled, className, children }: TabsTriggerProps): import("react/jsx-runtime").JSX.Element;
+export interface TabsContentProps {
+    value: string;
+    className?: string;
+    children: ReactNode;
+}
+export declare function TabsContent({ value, className, children }: TabsContentProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/atoms/Tag/Tag.d.ts

@@ -0,0 +1,12 @@
+import './Tag.css';
+export type TagVariant = 'primary' | 'accent-1' | 'accent-2' | 'support-1' | 'support-2' | 'neutral' | 'info' | 'warning' | 'success' | 'danger';
+export interface TagProps extends React.ComponentPropsWithoutRef<'span'> {
+    /** Variante de color del tag. */
+    variant?: TagVariant;
+}
+/**
+ * Tag / badge. Extiende los atributos nativos de `<span>` y reenvía `{...rest}`
+ * (`data-*`, `aria-*`, `id`…) al elemento. `className` se concatena tras las
+ * clases propias.
+ */
+export declare const Tag: import("react").ForwardRefExoticComponent<TagProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/_types/atoms/Text/Text.d.ts

@@ -0,0 +1,55 @@
+import './Text.css';
+export interface TextProps extends React.ComponentPropsWithoutRef<'span'> {
+    /**
+     * Qué elemento se pinta, que es lo mismo que decir **qué significa**:
+     * `span` no añade significado, `em` marca énfasis de lectura (cambia cómo se
+     * dice la frase) y `strong` marca importancia. No es una prop de estilo.
+     */
+    as?: 'span' | 'em' | 'strong';
+    /**
+     * Intención del fragmento. `destructive` es la palabra que dice que algo se
+     * pierde («esta acción **borra** el curso»); `success`, la que dice que salió
+     * bien; `muted`, una aclaración secundaria.
+     */
+    tone?: 'default' | 'muted' | 'destructive' | 'success';
+    /**
+     * Idioma de **este fragmento**, cuando no es el de la página: una cita, un
+     * término sin traducir, un segmento de traducción. Marca el idioma para el
+     * lector de pantalla, que cambia de voz, y para el corte de línea.
+     */
+    lang?: string;
+    /** Dirección del fragmento. Con un idioma RTL dentro de texto LTR hace falta. */
+    dir?: 'ltr' | 'rtl' | 'auto';
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * Texto **en línea**: un trozo de una frase que hay que marcar sin salirse de
+ * ella. Dos usos, y ningún otro:
+ *
+ * - **Otro idioma** (`lang`): el fragmento se anuncia con la voz correcta y se
+ *   corta según sus reglas. Antes esto era un `<span lang>` a mano en cada
+ *   producto.
+ * - **Intención** (`tone`): énfasis con carga —destructiva o de logro— en tinta
+ *   de feedback. Es color de texto sobre la superficie, **nunca un relleno**:
+ *   una palabra resaltada dentro de un párrafo no lleva fondo.
+ *
+ * No es un componente de maquetación: para poner cosas en fila está `Inline`;
+ * para un párrafo, `Paragraph`.
+ */
+export declare const Text: import("react").ForwardRefExoticComponent<TextProps & import("react").RefAttributes<HTMLElement>>;
+export interface LineBreakProps extends React.ComponentPropsWithoutRef<'br'> {
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * Salto de línea **dentro de una frase**: un `<br>` con nombre, sin pintura
+ * propia. Existe porque un texto traducido no puede traer marcado —una app
+ * escribe `t.rich('…', { br: () => <LineBreak /> })` y no puede escribir
+ * `<br>` en el catálogo de cadenas.
+ *
+ * Solo para cortar una línea dentro de una misma frase: un lema, una
+ * dirección, un verso. **Entre párrafos no**: eso es separación, y la dan
+ * `Paragraph` y `Stack`.
+ */
+export declare const LineBreak: import("react").ForwardRefExoticComponent<LineBreakProps & import("react").RefAttributes<HTMLBRElement>>;

package/dist/_types/atoms/Textarea/Textarea.d.ts

@@ -0,0 +1,25 @@
+import './Textarea.css';
+export interface TextareaProps extends React.ComponentPropsWithoutRef<'textarea'> {
+    /** Tamaño del textarea. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Marca el estado de error: aplica la clase `textarea--error` y `aria-invalid`. */
+    error?: boolean;
+    /**
+     * El campo renuncia a su caja —borde, fondo, aire, altura mínima, asa de
+     * redimensionado y anillo de foco— para que la dibuje el contenedor que lo
+     * enmarca. Es lo que usa `MessageComposer`: un solo marco alrededor del
+     * campo y del botón de enviar. Quien lo monte debe dibujar el foco en ese
+     * contenedor (`:focus-within`), o el campo se queda sin indicador.
+     */
+    bare?: boolean;
+    /** Se añade DESPUÉS de las clases propias del componente (el consumidor añade, no sustituye). */
+    className?: string;
+    /** @deprecated Usa el atributo nativo `aria-describedby`. */
+    describedBy?: string;
+}
+/**
+ * Textarea. Extiende los atributos nativos de `<textarea>` y reenvía `{...rest}`
+ * al elemento (incluye `ref` para react-hook-form; `data-*`, `aria-*`, `maxLength`,
+ * `required`, etc.).
+ */
+export declare const Textarea: import("react").ForwardRefExoticComponent<TextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;

package/dist/_types/atoms/TimeSelect/TimeSelect.d.ts

@@ -0,0 +1,48 @@
+import './TimeSelect.css';
+export interface TimeValue {
+    h: number;
+    m: number;
+}
+export interface TimeSelectProps {
+    value?: TimeValue | null;
+    onChange?: (value: TimeValue) => void;
+    /** Paso en minutos. Default: 5 */
+    step?: number;
+    size?: 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+    readOnly?: boolean;
+    error?: boolean;
+    /** id aplicado al trigger de horas */
+    id?: string;
+    /** Nombre del campo en el formulario: se monta un input oculto con `HH:MM`. */
+    name?: string;
+    /** Campo obligatorio: se marca el grupo y los dos desplegables. */
+    required?: boolean;
+    /** Id de la etiqueta que nombra el grupo (lo pone el campo). */
+    'aria-labelledby'?: string;
+    /** Ids de ayuda/error que describen el grupo (lo pone el campo). */
+    'aria-describedby'?: string;
+    /** Se llama al salir de cualquiera de los dos desplegables. */
+    onBlur?: React.FocusEventHandler<HTMLButtonElement>;
+    /** Se añade DESPUÉS de las clases propias del componente. */
+    className?: string;
+    /**
+     * aria-label del selector de horas. Default: "Horas" (castellano).
+     * Una app multiidioma debe pasarla traducida.
+     */
+    hoursLabel?: string;
+    /**
+     * aria-label del selector de minutos. Default: "Minutos" (castellano).
+     * Una app multiidioma debe pasarla traducida.
+     */
+    minutesLabel?: string;
+    /** Placeholder del selector de horas. Default: "HH" */
+    hoursPlaceholder?: string;
+    /** Placeholder del selector de minutos. Default: "MM" */
+    minutesPlaceholder?: string;
+}
+/**
+ * Hora repartida en dos desplegables. El `ref` va al de **horas**, que es el
+ * primero que se enfoca.
+ */
+export declare const TimeSelect: import("react").ForwardRefExoticComponent<TimeSelectProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/_types/atoms/Toggle/Toggle.d.ts

@@ -0,0 +1,42 @@
+import { Toggle as BaseToggle } from '@base-ui/react/toggle';
+import './Toggle.css';
+type BaseToggleProps = Omit<React.ComponentPropsWithoutRef<typeof BaseToggle>, 'className'>;
+/** La misma disyuntiva que en `Button`: solo icono ⇒ nombre accesible obligatorio. */
+export type ToggleIconOnlyProps = {
+    iconOnly: true;
+    'aria-label': string;
+} | {
+    iconOnly: true;
+    'aria-labelledby': string;
+} | {
+    iconOnly?: false | undefined;
+};
+/** Todo lo que no es la disyuntiva de `iconOnly`. */
+export interface ToggleBaseProps extends Omit<BaseToggleProps, 'onPressedChange'> {
+    /** Cambio de estado. Solo el estado: el DS no expone los detalles del evento. */
+    onPressedChange?: (pressed: boolean) => void;
+    /** Talla del sistema. Dentro de un `ToggleGroup` la hereda de él. */
+    size?: 'sm' | 'md' | 'lg';
+    /**
+     * Solo icono: el botón se hace cuadrado. Con `iconOnly` el tipo exige
+     * `aria-label` o `aria-labelledby`: no hay texto que nombre el control.
+     */
+    iconOnly?: boolean;
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+export type ToggleProps = ToggleBaseProps & ToggleIconOnlyProps;
+/**
+ * Botón de dos estados: pulsado o no (Base UI Toggle). Es un **valor que se
+ * conmuta** —negrita en una barra de texto, «solo pendientes» en un filtro—, no
+ * una acción: por eso queda relleno mientras está pulsado.
+ *
+ * El hover no pone fondo (solo marca el borde), como el resto del sistema: el
+ * relleno significa «elegido», y usarlo también para el paso del ratón haría
+ * ambiguo lo que está activo.
+ *
+ * Dentro de un `ToggleGroup` toma de él la talla; el estado marcado y la
+ * exclusividad las lleva el grupo.
+ */
+export declare const Toggle: import("react").ForwardRefExoticComponent<ToggleProps & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/_types/atoms/ToggleGroup/ToggleGroup.d.ts

@@ -0,0 +1,41 @@
+import { type ReactNode } from 'react';
+import { ToggleGroup as BaseToggleGroup } from '@base-ui/react/toggle-group';
+import './ToggleGroup.css';
+type BaseToggleGroupProps = Omit<React.ComponentPropsWithoutRef<typeof BaseToggleGroup>, 'className' | 'value' | 'defaultValue' | 'onValueChange'>;
+export interface ToggleGroupProps extends BaseToggleGroupProps {
+    /**
+     * Valores pulsados (controlado). Siempre una lista, también en exclusivo:
+     * ahí tiene como mucho un elemento, `value[0]`.
+     */
+    value?: string[];
+    /** Valores pulsados al montar (no controlado). */
+    defaultValue?: string[];
+    /** Se llama con la lista de valores pulsados. */
+    onValueChange?: (value: string[]) => void;
+    /**
+     * `false` (por defecto) para conmutación **exclusiva**: elegir uno suelta el
+     * anterior. `true` para poder tener varios pulsados a la vez.
+     */
+    multiple?: boolean;
+    /** Talla que heredan todos los `Toggle` del grupo. */
+    size?: 'sm' | 'md' | 'lg';
+    /** En fila (por defecto) o en columna. Fija también las flechas del teclado. */
+    orientation?: 'horizontal' | 'vertical';
+    children: ReactNode;
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * Una serie de `Toggle` que comparten estado (Base UI Toggle Group): la
+ * conmutación es **exclusiva** por defecto —elegir uno suelta el anterior, como
+ * el selector de plan o la vista de un listado— y `multiple` la abre a varios.
+ *
+ * El grupo es un único parada de tabulación: dentro se recorre con las flechas.
+ * El **nombre accesible** no es una prop: lo pone un `aria-label` /
+ * `aria-labelledby` sobre el grupo (`role="group"`) o un `Fieldset` alrededor.
+ *
+ * Ninguno de los botones pinta fondo al pasar el ratón: el relleno significa
+ * «este es el valor elegido», no «aquí está el puntero».
+ */
+export declare const ToggleGroup: import("react").ForwardRefExoticComponent<ToggleGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/_types/atoms/ToggleGroup/ToggleGroupContext.d.ts

@@ -0,0 +1,7 @@
+export interface ToggleGroupContextValue {
+    /** Talla que el grupo reparte a sus botones. */
+    size?: 'sm' | 'md' | 'lg';
+}
+export declare const ToggleGroupContext: import("react").Context<ToggleGroupContextValue | undefined>;
+/** Lo que un `Toggle` hereda del grupo que lo contiene, si lo hay. */
+export declare function useToggleGroup(): ToggleGroupContextValue | undefined;

package/dist/_types/atoms/Tooltip/Tooltip.d.ts

@@ -0,0 +1,61 @@
+import type { ReactNode } from 'react';
+import './Tooltip.css';
+export interface TooltipProviderProps {
+    children: ReactNode;
+    /** Retardo en ms antes de abrir el primer bocadillo. */
+    delayDuration?: number;
+    /** Ventana en ms durante la que pasar de un trigger a otro abre sin retardo. */
+    skipDelayDuration?: number;
+}
+/**
+ * Proveedor de tooltips. Va una sola vez por shell de aplicación — todos los
+ * `Tooltip` que cuelguen de él comparten retardo y agrupación de foco.
+ */
+export declare function TooltipProvider({ children, delayDuration, skipDelayDuration, }: TooltipProviderProps): import("react/jsx-runtime").JSX.Element;
+export interface TooltipProps extends Omit<React.HTMLAttributes<HTMLElement>, 'children' | 'className'> {
+    /** Contenido del bocadillo. */
+    label: ReactNode;
+    /** Elemento que dispara el bocadillo. Recibe los props del trigger vía `render`. */
+    children: ReactNode;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    /** Separación en px entre disparador y bocadillo. Sin él se lee el token `--tooltip-offset` (`:root`) en runtime. */
+    sideOffset?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Retardo propio en ms. Sin él hereda el del `TooltipProvider`. */
+    delayDuration?: number;
+    /**
+     * Enlaza el bocadillo con su disparador por `aria-describedby`, que es lo
+     * normal: el bocadillo añade algo que el disparador no dice.
+     *
+     * `false` para el caso contrario —el bocadillo **solo repite el nombre
+     * accesible que el disparador ya tiene**, porque lo que lo corta es el CSS
+     * (`text-overflow: ellipsis`) y el texto entero sigue en el DOM—. Ahí
+     * describir con el mismo texto que nombra hace que el lector de pantalla
+     * anuncie la frase dos veces, sin aportar nada: el bocadillo es una ayuda
+     * para el ojo, no para el oído. Es lo que hace `ConversationList` con el
+     * título cortado de una conversación.
+     *
+     * @default true
+     */
+    describe?: boolean;
+    /** Clase adicional para el **bocadillo** (no para el disparador). */
+    className?: string;
+}
+/**
+ * Bocadillo de ayuda sobre un elemento. Base UI gestiona el retardo, el
+ * posicionamiento y el cierre con Escape; el DS pone la superficie y el
+ * enlace `aria-describedby` entre disparador y bocadillo (Base UI, a
+ * diferencia de otros motores, no lo cablea por su cuenta).
+ *
+ * Requiere un `TooltipProvider` por encima (normalmente en el shell).
+ *
+ * Reenvía `ref` y `{...rest}` (handlers, `aria-*`, `id`, `data-*`) a su
+ * **disparador**, no al bocadillo: eso es lo que le permite ser a su vez el
+ * `render`/`trigger` de otro componente —un `Popover` sobre el mismo botón—,
+ * porque las props que le inyecta el motor de fuera llegan al elemento real.
+ * `className`, en cambio, es del bocadillo.
+ */
+export declare const Tooltip: import("react").ForwardRefExoticComponent<TooltipProps & import("react").RefAttributes<HTMLElement>>;

package/dist/_types/atoms/TypingIndicator/TypingIndicator.d.ts

@@ -0,0 +1,7 @@
+import './TypingIndicator.css';
+export interface TypingIndicatorProps {
+    /** Texto anunciado por lectores de pantalla. Default castellano: «El asistente está escribiendo…». */
+    label?: string;
+}
+/** Tres puntos cuadrados que laten en secuencia: «alguien está escribiendo». */
+export declare function TypingIndicator({ label }: TypingIndicatorProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/atoms/VisuallyHidden/VisuallyHidden.d.ts

@@ -0,0 +1,19 @@
+import './VisuallyHidden.css';
+export interface VisuallyHiddenProps extends React.ComponentPropsWithoutRef<'span'> {
+    children: React.ReactNode;
+    /**
+     * Elemento que se pinta. `span` por defecto; `div` para envolver contenido de
+     * flujo que no cabe dentro de un `span` (una tabla, una lista, un párrafo) —
+     * el caso de la tabla equivalente de `Chart`.
+     */
+    as?: 'span' | 'div';
+    /** Se añade DESPUÉS de la clase propia. */
+    className?: string;
+}
+/**
+ * Oculta contenido visualmente y lo deja en el árbol de accesibilidad.
+ * Reenvía `ref` y cualquier atributo (`id`, `aria-*`…): así sirve de
+ * `render` para los primitivos de Base UI (p. ej. un título de diálogo que
+ * no se ve pero al que apunta `aria-labelledby`).
+ */
+export declare const VisuallyHidden: import("react").ForwardRefExoticComponent<VisuallyHiddenProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/_types/constants/copy-to-clipboard.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Cómo fue el último intento de copiar. `idle` es también el estado al que se
+ * vuelve cuando el acuse caduca.
+ */
+export type CopyStatus = 'idle' | 'copied' | 'error';
+/** Cuánto dura el acuse por defecto, en milisegundos. */
+export declare const COPY_FEEDBACK_MS = 1500;
+/**
+ * La conducta de copiar al portapapeles: escribir el texto, acusar un rato y
+ * volver al estado inicial. No dibuja nada — el botón, el icono y el anuncio
+ * los pone quien la usa.
+ *
+ * Vive fuera de `CopyButton` porque hay tres sitios que copian con el mismo
+ * acuse (`CopyButton`, `CodeBlock` y `DescriptionDetails` con `copyable`) y el
+ * `CopyButton` es una molécula: un átomo no puede colgar de él sin invertir
+ * las capas. Lo que comparten es la conducta, así que es la conducta lo que se
+ * comparte.
+ *
+ * Si el portapapeles no está disponible —contexto no seguro, permiso
+ * denegado— el estado pasa a `error` en vez de fingir que copió; quien la usa
+ * decide si lo dice o se calla.
+ */
+export declare function useCopyToClipboard(feedbackDuration?: number): {
+    status: CopyStatus;
+    copy: (value: string | (() => string)) => Promise<{
+        ok: true;
+        text: string;
+        error?: undefined;
+    } | {
+        ok: false;
+        text: string;
+        error: unknown;
+    }>;
+};