@studiolxd/brand 38.12.4

package/dist/_types/molecules/Prose/Prose.d.ts

@@ -0,0 +1,36 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+import './Prose.css';
+/** Elementos con los que puede montarse el contenedor de texto largo. */
+export type ProseElement = 'div' | 'article' | 'section' | 'main' | 'aside';
+export interface ProseProps extends ComponentPropsWithoutRef<'div'> {
+    /**
+     * Elemento del contenedor. `div` por defecto; `article` cuando el bloque es
+     * el documento en sí (una página de documentación, un texto legal).
+     */
+    as?: ProseElement;
+    /** Cuerpo del texto: `md` (el de la superficie) o `sm` (un peldaño por debajo). */
+    size?: 'sm' | 'md';
+    /**
+     * Limita el ancho a la medida de lectura (`--prose-measure`). `false` deja
+     * que el contenido ocupe todo el contenedor: para documentos con tablas
+     * anchas o figuras a sangre.
+     */
+    measure?: boolean;
+    children: ReactNode;
+}
+/**
+ * Contenedor de contenido largo: viste la semántica cruda que sale de un
+ * markdown o de un CMS (`h2`–`h6`, `p`, `ul`/`ol`, `blockquote`, `pre`/`code`,
+ * `table`, `hr`, `img`) con la escala del sistema, y limita el ancho a la
+ * medida de lectura.
+ *
+ * Es la **excepción documentada** del sistema al estilado de etiquetas nativas:
+ * el contenido no viene de React, viene de un `.mdx` o de una cadena de HTML,
+ * así que no hay dónde poner una clase. Fuera de `Prose`, la maquetación sigue
+ * siendo de componentes (el único otro caso, mucho menor, es el `<mark>` del
+ * extracto de `DocsSearch`).
+ *
+ * Reenvía el resto de props del elemento (`data-*`, `aria-*`, `id`…) y
+ * concatena `className` tras las clases propias.
+ */
+export declare const Prose: import("react").ForwardRefExoticComponent<ProseProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/_types/molecules/RadioField/RadioField.d.ts

@@ -0,0 +1,29 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+import './RadioField.css';
+export interface RadioFieldProps extends Omit<ComponentPropsWithoutRef<'input'>, 'size' | 'type' | 'id'> {
+    /** Texto de la opción, a la derecha de la marca. Acepta JSX (un enlace, por ejemplo). */
+    label: ReactNode;
+    /** `id` del control. Si no se pasa, se genera con `useId`. */
+    id?: string;
+    /** Talla del sistema. Sin ella, la del `Form` que lo envuelva; sin `Form`, `md`. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Marca el control en error sin mensaje. Un `errorMessage` ya lo implica. */
+    error?: boolean;
+    /** Mensaje de error: se anuncia (`role="alert"`) y pone el control en error. */
+    errorMessage?: string;
+    /** Texto de ayuda, enlazado por `aria-describedby`. */
+    helperText?: string;
+    /** Se añade DESPUÉS de las clases propias (el consumidor añade, no sustituye). */
+    className?: string;
+}
+/**
+ * El `Radio` como campo: marca, texto de la opción, ayuda y error. El `ref` y
+ * el resto de props nativas de `<input type="radio">` van al input real
+ * (react-hook-form, `name`, `onBlur`, `aria-*`, `data-*`…); el `className`, al
+ * contenedor.
+ *
+ * Dentro de un `RadioGroup` toma de él la talla, el error y el estado
+ * deshabilitado (el `name` y el marcado los toma el propio `Radio`). Lo que se
+ * pase a mano manda sobre lo que dice el grupo.
+ */
+export declare const RadioField: import("react").ForwardRefExoticComponent<RadioFieldProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/_types/molecules/RecoveryCodes/RecoveryCodes.d.ts

@@ -0,0 +1,48 @@
+import type { ReactNode } from 'react';
+import './RecoveryCodes.css';
+export interface RecoveryCodesLabels {
+    /** Nombre accesible de la lista numerada. */
+    list: string;
+    /** Rótulo visible del botón que copia todos los códigos. */
+    copy: string;
+    /** Acuse del botón de copiar, mientras dura. */
+    copied: string;
+}
+export interface RecoveryCodesProps {
+    /** Los códigos, en el orden en que se numeran. */
+    codes: string[];
+    /** Columnas de la rejilla en pantallas anchas. En móvil siempre es 1. */
+    columns?: 1 | 2 | 3;
+    /**
+     * Textos del componente. Sin default: los códigos de recuperación son
+     * credenciales de seguridad y el texto que las rodea no debe quedar a
+     * medias traducir — quien lo use pasa los tres.
+     */
+    labels: RecoveryCodesLabels;
+    /**
+     * Acciones propias del producto (descargar, imprimir…), a continuación del
+     * botón de copiar. `brand` no implementa descarga ni impresión: ese gesto
+     * depende de cómo genera y sirve el archivo cada producto.
+     */
+    actions?: ReactNode;
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+    id?: string;
+}
+/**
+ * Códigos de recuperación de un solo uso (2FA): una lista numerada,
+ * monoespaciada, que se enseña una vez. No es un `CodeBlock` — no hay
+ * lenguaje que resaltar ni código que ejecutar, son credenciales — y no
+ * ofrece "ver otra vez": quien la monta decide si el usuario ya los guardó.
+ *
+ * La numeración es real (`<ol>`), no decorativa: un lector de pantalla
+ * anuncia "código 3 de 10" en vez de una lista plana. La rejilla es CSS
+ * `columns`, así que el orden de lectura sigue siendo el del documento
+ * (arriba a abajo dentro de una columna, luego la siguiente) — no un grid que
+ * numeraría en zigzag.
+ *
+ * Solo trae el botón de copiar todos; descargar o imprimir el archivo es
+ * decisión de producto (nombre de archivo, formato, disparo de
+ * `window.print()`…) y entra por el slot `actions`.
+ */
+export declare function RecoveryCodes({ codes, columns, labels, actions, className, id, }: RecoveryCodesProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/molecules/SearchForm/SearchForm.d.ts

@@ -0,0 +1,66 @@
+import './SearchForm.css';
+export interface SearchFormProps {
+    /** `id` del campo. Si no se pasa, el componente genera uno estable. */
+    id?: string;
+    /**
+     * Nombre del parámetro con el que viaja la consulta en el envío sin JS.
+     * @default 'q'
+     */
+    name?: string;
+    /** Texto escrito. Con `value` el componente es controlado. */
+    value?: string;
+    /** Texto inicial cuando el componente no es controlado. */
+    defaultValue?: string;
+    /** Se llama en cada tecla, con el evento nativo del `<input>`. */
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    /**
+     * Se llama al enviar, con la consulta **recortada**. Previene el envío
+     * nativo, así que sustituye a `action`/`method`. Con el campo vacío no se
+     * llama: un buscador sin consulta no tiene a dónde ir.
+     */
+    onSubmit?: (query: string) => void;
+    /** Destino del envío sin JS. Solo se usa cuando no hay `onSubmit`. */
+    action?: string;
+    /**
+     * Método del envío sin JS. Una búsqueda es una lectura: `get`.
+     * @default 'get'
+     */
+    method?: 'get' | 'post';
+    /**
+     * Etiqueta del campo. Nombra también el punto de referencia `search`.
+     * Default castellano.
+     * @default 'Buscar'
+     */
+    label?: string;
+    /**
+     * Oculta la etiqueta a la vista; el lector de pantalla la sigue leyendo.
+     * @default true
+     */
+    labelHidden?: boolean;
+    /**
+     * Pista dentro del campo. Default castellano.
+     * @default 'Buscar…'
+     */
+    placeholder?: string;
+    /**
+     * Nombre accesible del botón de envío. Default castellano.
+     * @default 'Buscar'
+     */
+    submitLabel?: string;
+    /**
+     * Talla del conjunto: la comparten campo y botón. `xl` es propia de este
+     * componente —el buscador del menú del sitio—; el resto son las tallas de
+     * formulario del sistema, y solo esas se heredan de un `Form`.
+     */
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    /** Deshabilita el campo y el botón. */
+    disabled?: boolean;
+}
+/**
+ * Buscador de sitio: un campo y un botón de envío que llevan a una página de
+ * resultados. No sugiere, no autocompleta y no guarda estado de búsqueda —
+ * para eso está `DocsSearch`.
+ *
+ * El `ref` va al `<input>` interno.
+ */
+export declare const SearchForm: import("react").ForwardRefExoticComponent<SearchFormProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/_types/molecules/SelectField/SelectField.d.ts

@@ -0,0 +1,44 @@
+import './SelectField.css';
+import type { SelectOptionOrGroup } from '../../atoms/Select/Select';
+export interface SelectFieldProps {
+    /** `id` del control. Si no se pasa, se genera con `useId`. */
+    id?: string;
+    label: string;
+    /**
+     * Oculta la etiqueta a la vista (sigue leyéndola el lector de pantalla).
+     * Por defecto `false`: la etiqueta se ve.
+     * Sin valor, lo decide quien lo envuelva: dentro de un `FieldRow` que no
+     * es la primera de la lista, la etiqueta se oculta sola.
+     */
+    labelHidden?: boolean;
+    /**
+     * Opciones del campo. Cada entrada es una opción (`{ value, label }`) o un
+     * grupo con cabecera (`{ label, options }`); las dos formas se pueden
+     * mezclar. La cabecera es una etiqueta, no una opción elegible.
+     */
+    options: SelectOptionOrGroup[];
+    value?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    /** Nombre del campo en el formulario: Base UI monta un input oculto con el valor. */
+    name?: string;
+    disabled?: boolean;
+    required?: boolean;
+    /** Marca el control en error sin mensaje. Un `errorMessage` ya lo implica. */
+    error?: boolean;
+    /** Mensaje de error: se anuncia (`role="alert"`) y pone el control en error. */
+    errorMessage?: string;
+    /** Texto de ayuda, enlazado por `aria-describedby`. */
+    helperText?: string;
+    size?: 'sm' | 'md' | 'lg';
+    /** Se añade DESPUÉS de las clases propias (el consumidor añade, no sustituye). */
+    className?: string;
+    onValueChange?: (value: string) => void;
+    onBlur?: React.FocusEventHandler<HTMLButtonElement>;
+}
+/**
+ * El `Select` como campo de formulario. El control es de Base UI: el `ref` va
+ * al **disparador** para que react-hook-form pueda enfocarlo al fallar la
+ * validación; el `className`, al contenedor.
+ */
+export declare const SelectField: import("react").ForwardRefExoticComponent<SelectFieldProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/_types/molecules/Sheet/Sheet.d.ts

@@ -0,0 +1,56 @@
+import type { ReactNode } from 'react';
+import { Dialog } from '@base-ui/react/dialog';
+import './Sheet.css';
+export interface SheetProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'title'> {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Borde por el que entra el panel. */
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    /** Título del panel. Su texto es también el nombre accesible del diálogo. */
+    title: ReactNode;
+    /** Oculta el título visualmente y lo deja solo como nombre accesible. */
+    titleHidden?: boolean;
+    description?: ReactNode;
+    /** Fila de acciones al pie del panel. */
+    footer?: ReactNode;
+    children: ReactNode;
+    closeLabel?: string;
+    /** Elemento que abre el panel. Sin él, la apertura la controla el consumidor. */
+    trigger?: ReactNode;
+    /**
+     * Nodo DOM donde montar el portal del panel (reenviado a Base UI
+     * `Portal.container`). Por defecto se monta en `document.body`, que
+     * hereda el tema activado a nivel raíz (`html.dark`/`[data-theme="dark"]`)
+     * sin configuración adicional. Solo hace falta pasarlo cuando el Sheet
+     * vive dentro de una superficie **anidada** (un `.surface-dark` que no está
+     * en la raíz, o dentro de `SiteShell`/`.site-shell`), ya que ese contexto
+     * no llega a `document.body` por la cascada.
+     */
+    container?: React.ComponentPropsWithoutRef<typeof Dialog.Portal>['container'];
+    /**
+     * Se dispara cuando termina la animación de entrada o de salida del panel.
+     * Sirve para desmontar el panel solo después de que haya salido de pantalla.
+     */
+    onAnimationEndCapture?: (event: React.AnimationEvent) => void;
+    className?: string;
+}
+/**
+ * Fila de acciones del panel. El caso normal se resuelve con la prop `footer`
+ * de `Sheet`; esta pieza es para los paneles que cambian de pie según el paso
+ * en el que estén y lo renderizan dentro de su propio contenido.
+ */
+export declare function SheetFooter({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Panel que entra deslizándose por un borde de la pantalla. Es el patrón que
+ * `Modal` no cubre — este no se centra, ocupa un lateral (o el borde superior
+ * o inferior) y deja ver el contexto detrás.
+ *
+ * Base UI Dialog aporta el portal, el velo, la trampa de foco y el cierre con
+ * Escape; el DS pone la superficie y la dirección de entrada.
+ *
+ * `{...rest}` (`id`, `data-*`, `aria-*` y los **handlers de evento**) se
+ * reenvía al popup, y `className` se concatena tras las clases propias. Los
+ * handlers son lo que permite montar la barrera de eventos cuando el panel se
+ * abre desde dentro de una tarjeta clicable, sin `div`s de producto alrededor.
+ */
+export declare function Sheet({ open, onOpenChange, side, title, titleHidden, description, footer, children, closeLabel, trigger, container, onAnimationEndCapture, className, ...rest }: SheetProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/molecules/SidebarNav/SidebarNav.d.ts

@@ -0,0 +1,59 @@
+import type { ReactNode } from 'react';
+import './SidebarNav.css';
+export interface SidebarNavItem {
+    id: string;
+    label: string;
+    href: string;
+    active?: boolean;
+    icon?: ReactNode;
+    /**
+     * La entrada existe pero no lleva a ninguna parte todavía: se enseña con su
+     * marca («sin docs») y sin enlace, en vez de esconderla.
+     */
+    empty?: boolean;
+}
+export interface SidebarNavLinkEntry {
+    kind: 'link';
+    id: string;
+    label: string;
+    href: string;
+    active?: boolean;
+    icon?: ReactNode;
+    /** Igual que en `SidebarNavItem`: se enseña marcada y sin enlace. */
+    empty?: boolean;
+}
+export interface SidebarNavGroupEntry {
+    kind: 'group';
+    id: string;
+    label: string;
+    /** Cuando se especifica, el label de la categoría se renderiza como enlace. */
+    href?: string;
+    /** Icono del grupo, visible en modo colapsado. */
+    icon?: ReactNode;
+    items: SidebarNavItem[];
+}
+export type SidebarNavEntry = SidebarNavLinkEntry | SidebarNavGroupEntry;
+export type SidebarNavRenderLinkProps = React.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    href: string;
+    children: ReactNode;
+    className: string;
+    title?: string;
+    'aria-current'?: 'page';
+};
+export interface SidebarNavProps {
+    /** Nombre accesible del `nav`. */
+    label?: string;
+    /**
+     * Marca de las entradas vacías (`empty`). Por defecto, en castellano:
+     * «sin docs».
+     */
+    emptyLabel?: string;
+    /** Solo iconos: los enlaces con tooltip, los grupos como menú. Sin él, lo decide la `Sidebar` (rail). */
+    rail?: boolean;
+    entries: SidebarNavEntry[];
+    defaultValue?: string[];
+    value?: string[];
+    onValueChange?: (value: string[]) => void;
+    renderLink?: (props: SidebarNavRenderLinkProps) => ReactNode;
+}
+export declare function SidebarNav({ label, emptyLabel, rail, entries, defaultValue, value, onValueChange, renderLink, }: SidebarNavProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/molecules/SiteNav/SiteNav.d.ts

@@ -0,0 +1,52 @@
+import type { ReactNode } from 'react';
+import './SiteNav.css';
+export interface SiteNavItem {
+    id: string;
+    label: string;
+    href: string;
+    /** Página actual: se marca con `aria-current="page"`. */
+    current?: boolean;
+    /** Destino del enlace (`_blank` para abrir en otra pestaña). Útil para enlaces a otro dominio. */
+    target?: string;
+    /** Relación del enlace. Con `target="_blank"` y sin valor, se aplica `noopener noreferrer`. */
+    rel?: string;
+}
+export interface SiteNavGroup {
+    id: string;
+    /** Cabecera del grupo. */
+    label: string;
+    /** Si se indica, la cabecera es también un enlace (la portada de la sección). */
+    href?: string;
+    items: SiteNavItem[];
+}
+export type SiteNavRenderLinkProps = {
+    href: string;
+    children: ReactNode;
+    className: string;
+    'aria-current'?: 'page';
+    /** Presente solo si el ítem lo declara; el consumidor debe reenviarlo a su enlace. */
+    target?: string;
+    /** Presente solo si el ítem lo declara o si `target="_blank"` lo impone; reenviar junto a `target`. */
+    rel?: string;
+};
+export interface SiteNavProps {
+    groups: SiteNavGroup[];
+    /** Nombre accesible del `nav`. */
+    label?: string;
+    /** Enlace del router del producto; por defecto, un `<a>`. */
+    renderLink?: (props: SiteNavRenderLinkProps) => ReactNode;
+    className?: string;
+}
+/**
+ * El índice del sitio: grupos con cabecera y enlaces. Una columna en móvil,
+ * una columna por grupo en escritorio. Es lo que llena el panel del
+ * `SiteHeader` y, con la misma forma, el pie de página.
+ *
+ * En el breakpoint ancho el número de columnas sigue al número de grupos
+ * (hasta `COLUMNS_MAX`), para que un quinto grupo no caiga solo en una
+ * segunda fila; en `md` y `lg` el número de columnas es fijo. El dato viaja
+ * en `data-columns`, no en un atributo `style`: una app con
+ * `style-src 'self'` descarta el atributo sin avisar y el grupo de más caía
+ * a la segunda fila.
+ */
+export declare function SiteNav({ groups, label, renderLink, className, }: SiteNavProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/molecules/StatTile/StatTile.d.ts

@@ -0,0 +1,47 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+import './StatTile.css';
+export type StatTileDirection = 'up' | 'down' | 'flat';
+export type StatTileTone = 'positive' | 'negative' | 'neutral';
+export interface StatTileDelta {
+    /** La variación, ya formateada: «+12 %», «−3», «igual». */
+    value: ReactNode;
+    /** Hacia dónde se ha movido la cifra. Pone la flecha. */
+    direction?: StatTileDirection;
+    /**
+     * Si el movimiento es bueno o malo. Por defecto subir es bueno; en una
+     * métrica donde subir es malo (errores, latencia, bajas), se invierte.
+     */
+    tone?: StatTileTone;
+    /**
+     * Cómo se lee la dirección para un lector de pantalla, que no ve la flecha.
+     * Default castellano según `direction`.
+     */
+    label?: string;
+}
+export interface StatTileProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title'> {
+    /** Qué se está midiendo. */
+    label: ReactNode;
+    /** La cifra, ya formateada por quien la tiene (moneda, separadores, unidades). */
+    value: ReactNode;
+    /** Variación respecto al periodo anterior. */
+    delta?: StatTileDelta;
+    /** Una línea de contexto bajo la cifra: el periodo, la fuente, la salvedad. */
+    description?: ReactNode;
+    /** Icono junto a la etiqueta. Decorativo: la etiqueta ya dice qué es. */
+    icon?: ReactNode;
+    /** Talla de la baldosa. */
+    size?: 'sm' | 'md';
+}
+/**
+ * La baldosa de una cifra: qué se mide, cuánto vale, cómo se ha movido y qué
+ * matiza esa lectura. Es la pieza de los paneles de KPIs; la rejilla la pone
+ * `Columns`, que no sabe nada de cifras.
+ *
+ * La baldosa **no calcula ni formatea**: recibe la cifra y el delta ya
+ * escritos. El formato de un número depende de la moneda, del idioma y de la
+ * unidad, y todo eso lo sabe el producto, no el sistema.
+ *
+ * Reenvía el resto de props del elemento (`data-*`, `aria-*`, `id`…) y
+ * concatena `className` tras las clases propias.
+ */
+export declare const StatTile: import("react").ForwardRefExoticComponent<StatTileProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/_types/molecules/Stepper/Stepper.d.ts

@@ -0,0 +1,88 @@
+import type { ReactNode } from 'react';
+import './Stepper.css';
+export interface StepperStep {
+    /** Clave de React. Sin ella se usa la posición. */
+    id?: string;
+    /** Etiqueta del paso: una o dos palabras («Perfil», «Invitaciones»). */
+    label: ReactNode;
+    /** Línea corta bajo la etiqueta. Solo se pinta en la forma horizontal. */
+    description?: ReactNode;
+    /**
+     * Si se puede **ir a este paso** haciendo clic en él. Es una propiedad del
+     * paso, no del componente: solo el flujo sabe si el suyo se puede completar
+     * ya (en un alta, los pasos que vienen después de crear la organización no
+     * existen sin ella).
+     *
+     * Sin declararlo vale lo de siempre: **alcanzables los completados**, porque
+     * volver sobre lo hecho siempre se puede. Ponerlo a `true` abre un pendiente;
+     * a `false`, cierra un completado. Nada de esto aplica sin `onStepSelect`:
+     * sin callback el progreso solo informa. El paso actual nunca es alcanzable
+     * —ya se está en él—, se declare lo que se declare.
+     *
+     * La regla típica —«hacia delante solo con el paso actual completo»— la pone
+     * el flujo: el componente no valida nada. Un paso no alcanzable queda
+     * **inerte**, no deshabilitado: sin `role` de botón, sin foco y sin cursor de
+     * mano, porque un destino al que aún no se puede llegar no es un destino.
+     */
+    reachable?: boolean;
+}
+/** Estado de un paso dentro del flujo. Lo deduce el componente de `current`. */
+export type StepperStatus = 'completed' | 'current' | 'pending';
+export interface StepperLabels {
+    /** Se antepone, solo para lectores de pantalla, a la etiqueta de un paso ya hecho. Default: «Completado». */
+    completed?: string;
+    /** Ídem para el paso actual. Default: «Paso actual». */
+    current?: string;
+    /** Ídem para un paso que aún no toca. Default: «Pendiente». */
+    pending?: string;
+}
+export interface StepperProps {
+    /** Los pasos, en orden. El número lo pone el componente. */
+    steps: StepperStep[];
+    /** Índice (base 0) del paso actual. Los anteriores quedan completados; los siguientes, pendientes. */
+    current: number;
+    /**
+     * Ir a otro paso. Sin este callback ningún paso es interactivo: el progreso
+     * solo informa. Qué pasos se pueden alcanzar lo dice cada paso con su
+     * `reachable`; por defecto, los completados.
+     */
+    onStepSelect?: (index: number, step: StepperStep) => void;
+    /** Nombre accesible de la lista. Default: «Progreso» (castellano). */
+    label?: string;
+    /**
+     * El texto de la forma compacta (por debajo de `md`), donde no caben las
+     * etiquetas. Recibe el número de paso (base 1) y el total.
+     * Default: «Paso 2 de 4» (castellano).
+     */
+    compactLabel?: (current: number, total: number) => string;
+    /** Textos de estado para lectores de pantalla. Todos con default castellano. */
+    labels?: StepperLabels;
+    className?: string;
+    id?: string;
+}
+/**
+ * El progreso de un flujo por pasos: dónde está el usuario, qué lleva hecho y
+ * qué le queda. Es una lista ordenada de verdad (`ol`) con `aria-current="step"`
+ * en el paso actual, así que el orden y la posición los anuncia el navegador
+ * sin que nadie los escriba.
+ *
+ * **No es `Steps`.** `Steps` documenta un proceso (una lista numerada con
+ * título y descripción, sin noción de «dónde estoy»); `Stepper` acompaña a un
+ * flujo en marcha y tiene estado.
+ *
+ * Se adapta a lo que hay:
+ *
+ * - En escritorio, los pasos en fila con su etiqueta; por debajo de `md`
+ *   degrada a la forma compacta («Paso 2 de 4» y la etiqueta del paso actual),
+ *   que es lo único que cabe.
+ * - **Con un solo paso no pinta nada**: un «paso 1 de 1» es ruido. Es lo que
+ *   permite que una plantilla monte siempre el hueco del progreso y sea el
+ *   flujo quien decida si hay algo que contar.
+ *
+ * Con `onStepSelect` los pasos alcanzables son botones. Cuáles lo son no lo
+ * decide el componente: por defecto los completados —volver sobre lo hecho
+ * siempre se puede—, y el flujo abre o cierra los que quiera con el
+ * `reachable` de cada paso, porque solo él sabe cuáles se pueden completar ya.
+ * El paso actual nunca es un botón: ya se está en él.
+ */
+export declare function Stepper({ steps, current, onStepSelect, label, compactLabel, labels, className, id, }: StepperProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/_types/molecules/SwitcherField/SwitcherField.d.ts

@@ -0,0 +1,42 @@
+import { type ReactNode } from 'react';
+import './SwitcherField.css';
+export interface SwitcherFieldProps {
+    /** Texto del interruptor, a su derecha. Acepta JSX. */
+    label: ReactNode;
+    /**
+     * Oculta la etiqueta visualmente sin sacarla del árbol de accesibilidad: el
+     * interruptor sigue nombrándose con ella. Para filas de una tabla de
+     * preferencias, donde el nombre del ajuste ya está en su columna.
+     * Default: `false`.
+     * Sin valor, lo decide quien lo envuelva: dentro de un `FieldRow` que no
+     * es la primera de la lista, la etiqueta se oculta sola.
+     */
+    labelHidden?: boolean;
+    /** `id` del control. Si no se pasa, se genera con `useId`. */
+    id?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    /** Valor enviado con el formulario cuando está activo. */
+    value?: string;
+    /** Talla del sistema. Sin ella, la del `Form` que lo envuelva; sin `Form`, `md`. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Marca el control en error sin mensaje. Un `errorMessage` ya lo implica. */
+    error?: boolean;
+    /** Mensaje de error: se anuncia (`role="alert"`) y pone el control en error. */
+    errorMessage?: string;
+    /** Texto de ayuda, enlazado por `aria-describedby`. */
+    helperText?: string;
+    /** Se añade DESPUÉS de las clases propias (el consumidor añade, no sustituye). */
+    className?: string;
+    onCheckedChange?: (checked: boolean) => void;
+    onBlur?: React.FocusEventHandler<HTMLElement>;
+}
+/**
+ * El `Switcher` como campo: interruptor, texto, ayuda y error. El `ref` va al
+ * disparador (el `<button role="switch">`) para que react-hook-form pueda
+ * enfocarlo al fallar la validación; el `className`, al contenedor.
+ */
+export declare const SwitcherField: import("react").ForwardRefExoticComponent<SwitcherFieldProps & import("react").RefAttributes<HTMLElement>>;