@studiolxd/brand 38.12.4

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

@@ -0,0 +1,127 @@
+import { type ReactNode } from 'react';
+import './Consent.css';
+import { Modal } from '../Modal/Modal';
+/** Una categoría de tecnologías sobre la que se pide (o no) consentimiento. */
+export interface ConsentCategory {
+    /** Identificador de la categoría. Es la clave dentro de `value`. */
+    id: string;
+    /** Nombre visible de la categoría. */
+    name: string;
+    /** Qué hace esa categoría. Se muestra como ayuda del interruptor. */
+    description?: string;
+    /**
+     * Categoría necesaria: siempre activa y sin interruptor operable. No se
+     * incluye en el objeto que devuelven `onSave`/`onChange` como algo que
+     * decidir — se guarda siempre a `true`.
+     */
+    required?: boolean;
+}
+/** La decisión: qué categorías están aceptadas, por `id`. */
+export type ConsentValue = Record<string, boolean>;
+export interface ConsentBannerProps extends Omit<React.ComponentPropsWithoutRef<'aside'>, 'title' | 'children' | 'onChange'> {
+    /**
+     * Muestra la banda. Es la primera visita, o la decisión ha caducado: quién lo
+     * sabe es el consumidor, que es también quien guarda la cookie. Default: `true`.
+     */
+    open?: boolean;
+    /** Acepta todas las categorías. */
+    onAcceptAll: () => void;
+    /** Rechaza todas las opcionales. Tiene exactamente el mismo peso visual que aceptar. */
+    onRejectAll: () => void;
+    /** Abre el panel de preferencias. Sin ella no se pinta el botón. */
+    onOpenPreferences?: () => void;
+    /** Título de la banda. Default castellano: `'Cookies'`. */
+    title?: ReactNode;
+    /** Texto de la banda. Default castellano. */
+    description?: ReactNode;
+    /** URL de la política de cookies. Sin ella no se pinta el enlace. */
+    policyHref?: string;
+    /** Texto del enlace a la política. Default castellano: `'Política de cookies'`. */
+    policyLabel?: string;
+    /** Abre la política en otra pestaña (la política suele vivir en la web pública). */
+    policyExternal?: boolean;
+    /** Etiqueta del botón de aceptar. Default castellano: `'Aceptar todas'`. */
+    acceptAllLabel?: string;
+    /** Etiqueta del botón de rechazar. Default castellano: `'Rechazar'`. */
+    rejectAllLabel?: string;
+    /** Etiqueta del botón de preferencias. Default castellano: `'Preferencias'`. */
+    preferencesLabel?: string;
+    /**
+     * Nombre accesible de la región. Default: el propio `title` cuando es texto;
+     * si el título lleva JSX, pásalo. Default castellano: `'Consentimiento de cookies'`.
+     */
+    regionLabel?: string;
+}
+/**
+ * La banda de consentimiento: qué se quiere guardar y tres salidas —aceptar,
+ * rechazar, decidir por categorías—. **No es un diálogo**: no atrapa el foco, no
+ * bloquea la página y no lleva velo. Rechazar cuesta exactamente lo mismo que
+ * aceptar (un clic, el mismo peso visual), que es lo que pide la ePrivacy.
+ *
+ * El DS no toca cookies ni `localStorage`: la decisión, su persistencia y su
+ * caducidad las lleva el consumidor. Aquí solo están la superficie y las
+ * llamadas.
+ */
+export declare function ConsentBanner({ open, onAcceptAll, onRejectAll, onOpenPreferences, title, description, policyHref, policyLabel, policyExternal, acceptAllLabel, rejectAllLabel, preferencesLabel, regionLabel, className, ...rest }: ConsentBannerProps): import("react/jsx-runtime").JSX.Element | null;
+export interface ConsentPreferencesProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Las categorías, en el orden en que se enseñan. Las `required` van primero por convención. */
+    categories: ConsentCategory[];
+    /** La decisión vigente. Es lo que se lee al abrir el panel. */
+    value: ConsentValue;
+    /**
+     * Cambio de categorías: se llama con la decisión completa cada vez que se
+     * conmuta un interruptor — el panel no lleva botón «Guardar», persiste al
+     * instante. **Si se pasa, el panel es controlado**: `value` manda en todo
+     * momento y el consumidor decide qué hacer con cada cambio (normalmente,
+     * guardarlo). Sin ella el panel lleva su propio estado interno, sembrado de
+     * `value` cada vez que se abre.
+     */
+    onChange?: (value: ConsentValue) => void;
+    /**
+     * @deprecated Alias de `onChange`, por compatibilidad con quien ya lo
+     * pasaba. Desde que el panel dejó de tener botón «Guardar» (v25.32.0),
+     * `onSave` se llama en el mismo momento y con la misma decisión que
+     * `onChange` — en cada conmutación de interruptor, no al pulsar un guardado
+     * explícito que ya no existe. Pasa a `onChange`.
+     */
+    onSave?: (value: ConsentValue) => void;
+    /** Superficie sobre la que se abre el panel. Default: `'sheet'`. */
+    surface?: 'sheet' | 'modal';
+    /** Borde por el que entra el panel (solo con `surface="sheet"`, la alternativa lateral que el sistema conserva para otros usos). Default: `'right'`. */
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    /** Título del panel. Default castellano: `'Preferencias de cookies'`. */
+    title?: ReactNode;
+    /** Etiqueta del botón de cerrar. Default castellano: `'Cerrar'`. */
+    closeLabel?: string;
+    /** Marca de una categoría necesaria. Default castellano: `'Siempre activa'`. */
+    alwaysOnLabel?: string;
+    /**
+     * Nodo DOM donde montar el portal del panel, reenviado a `Modal`/`Sheet`.
+     * Necesario cuando el panel se abre dentro de `SiteShell`: por defecto el
+     * portal monta en `document.body`, que no hereda los tokens de la
+     * superficie pública (a diferencia del tema oscuro, que se activa en
+     * `<html>`) — pásale el nodo de `SiteShell` (su `ref`).
+     */
+    container?: React.ComponentPropsWithoutRef<typeof Modal>['container'];
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * El panel de preferencias por categorías: título y la lista de categorías —un
+ * interruptor por categoría opcional y una fila fija para las necesarias—. Sin
+ * párrafo de descripción bajo el título: la propia lista explica qué se
+ * decide. Se abre sobre `Modal` (default) o sobre `Sheet`; el foco, el cierre
+ * con Escape y el velo los pone Base UI.
+ *
+ * **No hay pie de acciones**: ni «Guardar» ni «Aceptar todas»/«Rechazar
+ * todas». Quien entra aquí viene a decidir categoría por categoría, así que
+ * cada interruptor persiste al instante — se conmuta y `onChange` (u `onSave`,
+ * su alias) se llama en el momento con la decisión completa. Las salidas de un
+ * clic («Aceptar todas»/«Rechazar») viven en `ConsentBanner`, que es donde la
+ * ePrivacy las pide. Sin `onChange` el panel lleva su propio estado interno,
+ * sembrado de `value` cada vez que se abre, y sigue disparando `onSave` en
+ * cada cambio.
+ */
+export declare function ConsentPreferences({ open, onOpenChange, categories, value, onChange, onSave, surface, side, title, closeLabel, alwaysOnLabel, container, className, }: ConsentPreferencesProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import { type MenuItem, type MenuRenderLinkProps } from '../Menu/Menu';
+/** Los ítems del ContextMenu son los del `Menu`. */
+export type ContextMenuItem = MenuItem;
+export type ContextMenuRenderLinkProps = MenuRenderLinkProps;
+export interface ContextMenuProps {
+    items: MenuItem[];
+    renderLink?: (props: MenuRenderLinkProps) => ReactNode;
+    onOpenChange?: (open: boolean) => void;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    minWidth?: string;
+    maxWidth?: string;
+    /** Talla del botón de tres puntos (talla del sistema). */
+    triggerSize?: 'sm' | 'md' | 'lg';
+    triggerOrientation?: 'horizontal' | 'vertical';
+    /** Nombre accesible del botón. */
+    label?: string;
+}
+/**
+ * El menú de acciones de una fila, una tarjeta, un elemento: un `Menu` cuyo
+ * disparador es el botón de tres puntos (`DotsButton`). Todo lo demás —ítems,
+ * enlaces del router, colocación, cara— es del `Menu`.
+ */
+export declare function ContextMenu({ items, renderLink, onOpenChange, side, align, minWidth, maxWidth, triggerSize, triggerOrientation, label, }: ContextMenuProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,55 @@
+import { type ReactNode } from 'react';
+import './ConversationList.css';
+export interface ConversationItem {
+    id: string;
+    label: string;
+}
+export interface ConversationListProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onSelect'> {
+    conversations: ConversationItem[];
+    activeId?: string;
+    onNew: () => void;
+    onSelect: (id: string) => void;
+    onDelete: (id: string) => void;
+    /** Texto del botón que abre una conversación nueva. Default castellano. */
+    newLabel?: string;
+    /** `aria-label` del `<nav>` que envuelve la lista. Default castellano. */
+    navLabel?: string;
+    /** Nombre accesible del aspa de cada fila. Recibe el título de la conversación. */
+    deleteLabel?: (label: string) => string;
+    /**
+     * La lista aún está cargando: en su sitio se pintan marcadores (`Skeleton`)
+     * y el `<nav>` se anuncia ocupado (`aria-busy`). Mismo nombre que en
+     * `DataTable`.
+     */
+    isLoading?: boolean;
+    /** Cuántos marcadores pinta la carga. Default: `4`. */
+    loadingCount?: number;
+    /**
+     * La lista no se pudo cargar: en su sitio se pinta un `Alert` de error con
+     * este contenido. Manda sobre `isLoading` y sobre la lista vacía.
+     */
+    error?: ReactNode;
+    /**
+     * Título del `EmptyState` que la lista pinta **ella misma** cuando no hay
+     * conversaciones. Default: "Todavía no hay conversaciones" (castellano). Sin
+     * pasarla, el consumidor se lleva ese texto: el hueco vacío nunca se queda en
+     * blanco, así que la pantalla no tiene que añadir un aviso propio encima —si
+     * lo añade, se ven dos.
+     */
+    emptyMessage?: string;
+    /** `title` del `Alert` de error. Default castellano. */
+    errorTitle?: string;
+    /** Se añade DESPUÉS de las clases propias del componente (el consumidor añade, no sustituye). */
+    className?: string;
+}
+/**
+ * La lista de conversaciones de un chat: el botón para abrir una nueva y la
+ * navegación con las que ya existen, cada una con su aspa para borrarla.
+ *
+ * Un título que no cabe se corta con puntos suspensivos y, **solo entonces**,
+ * se lee entero en un bocadillo al apuntar la fila o al enfocarla con el
+ * teclado. Ver la doc, «El título cortado se lee en un bocadillo».
+ *
+ * Reenvía el resto de props del `<div>` (`data-*`, `id`…) y el `ref`.
+ */
+export declare const ConversationList: import("react").ForwardRefExoticComponent<ConversationListProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,57 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+import './CopyButton.css';
+export interface CopyButtonProps extends Omit<ComponentPropsWithoutRef<'button'>, 'value' | 'children' | 'onClick' | 'onCopy'> {
+    /**
+     * Lo que se copia. Como función, se evalúa en el momento del clic: para
+     * copiar algo que puede haber cambiado desde el render (el contenido de un
+     * campo, el texto de un bloque de código).
+     */
+    value: string | (() => string);
+    /**
+     * Rótulo visible junto al icono. Sin él, el botón es solo icono y `label`
+     * se queda como nombre accesible.
+     */
+    children?: ReactNode;
+    /**
+     * Nombre accesible del botón. Default castellano.
+     * @default 'Copiar'
+     */
+    label?: string;
+    /**
+     * Acuse tras copiar: se anuncia en una región viva y, si hay rótulo visible,
+     * lo sustituye mientras dura. Default castellano.
+     * @default 'Copiado'
+     */
+    copiedLabel?: string;
+    /**
+     * Aviso cuando el portapapeles no está disponible (contexto no seguro,
+     * permiso denegado). Default castellano.
+     * @default 'No se pudo copiar'
+     */
+    errorLabel?: string;
+    /** Variante del botón. */
+    variant?: 'ghost' | 'outline' | 'text';
+    /** Talla del botón. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Cuánto dura el acuse, en milisegundos. */
+    feedbackDuration?: number;
+    /** Se llama con el texto copiado cuando la copia sale bien. */
+    onCopy?: (text: string) => void;
+    /** Se llama cuando el portapapeles falla. */
+    onCopyError?: (error: unknown) => void;
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * Copiar al portapapeles con acuse: una clave de API, un identificador, un
+ * fragmento de código. Es el `Button` del sistema con el icono de copiar y la
+ * conducta del acuse; no aporta cara propia.
+ *
+ * El acuse es doble: el icono pasa a un tic para quien ve, y una región viva
+ * (`role="status"`) lo anuncia para quien escucha. Un cambio de icono solo no
+ * es feedback accesible.
+ *
+ * Si el portapapeles no está disponible —contexto no seguro, permiso
+ * denegado— el botón lo dice en vez de fingir que ha copiado.
+ */
+export declare const CopyButton: import("react").ForwardRefExoticComponent<CopyButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,87 @@
+import type { CalendarProps } from '../Calendar/Calendar';
+import { type DateMaskLetters } from './dateMask';
+import './DatePicker.css';
+export interface DatePickerProps {
+    value?: Date | null;
+    /**
+     * Se llama con la fecha escrita o elegida, y con `null` al vaciar el campo.
+     * Una fecha a medio escribir no lo llama: el campo se pone en error.
+     */
+    onChange?: (date: Date | null) => void;
+    /**
+     * Pista dentro del campo. Por defecto, la máscara del locale con las letras
+     * castellanas (`dd/mm/aaaa`, `mm/dd/aaaa` en `en-US`). Una app multiidioma
+     * pasa `maskLetters` para traducir las letras sin tocar el orden.
+     */
+    placeholder?: string;
+    /**
+     * Letras de la máscara del marcador de posición. Default castellano
+     * (`{ day: 'dd', month: 'mm', year: 'aaaa' }`). El orden y el separador no
+     * son props: salen del `locale` con `Intl`.
+     */
+    maskLetters?: DateMaskLetters;
+    /**
+     * Mensaje cuando lo escrito no es una fecha completa y válida. Default
+     * castellano; se anuncia con `role="alert"`.
+     */
+    invalidMessage?: string;
+    /** Nombre accesible del botón que abre el calendario. Default castellano. */
+    openCalendarLabel?: string;
+    minDate?: CalendarProps['minDate'];
+    maxDate?: CalendarProps['maxDate'];
+    disabledDates?: CalendarProps['disabledDates'];
+    size?: 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+    readOnly?: boolean;
+    error?: boolean;
+    locale?: string;
+    /** id aplicado al campo de texto */
+    id?: string;
+    /** @deprecated Usa el atributo nativo `aria-describedby`. */
+    describedBy?: string;
+    /** Ids de ayuda/error que describen el control (lo pone el campo). */
+    'aria-describedby'?: string;
+    /** Nombre accesible cuando el control va suelto. En un campo lo nombra la etiqueta. */
+    'aria-label'?: string;
+    /** Nombre accesible del panel del calendario (`role="dialog"`). */
+    calendarLabel?: string;
+    /**
+     * aria-label del botón de mes anterior del calendario. Default: «Mes
+     * anterior» (castellano). Una app multiidioma debe pasarla traducida.
+     */
+    previousMonthLabel?: CalendarProps['previousMonthLabel'];
+    /**
+     * aria-label del botón de mes siguiente. Default: «Mes siguiente»
+     * (castellano).
+     */
+    nextMonthLabel?: CalendarProps['nextMonthLabel'];
+    /**
+     * aria-label del botón de retroceso **en la vista de años**. Default: «Años
+     * anteriores» (castellano).
+     */
+    previousYearsLabel?: CalendarProps['previousYearsLabel'];
+    /**
+     * aria-label del botón de avance en la vista de años. Default: «Años
+     * siguientes» (castellano).
+     */
+    nextYearsLabel?: CalendarProps['nextYearsLabel'];
+    /** aria-label de la rejilla de años. Default: «Elegir año» (castellano). */
+    yearGridLabel?: CalendarProps['yearGridLabel'];
+    /**
+     * aria-label de la rejilla de días. Por defecto toma `calendarLabel`, que ya
+     * nombra el panel entero.
+     */
+    gridLabel?: CalendarProps['gridLabel'];
+    /** Nombre del campo en el formulario: se monta un input oculto con la fecha en ISO. */
+    name?: string;
+    /** Se llama al salir del campo (react-hook-form lo usa para validar). */
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+    /** Se añade DESPUÉS de las clases propias del componente. */
+    className?: string;
+}
+/**
+ * Selector de fecha: un campo de texto que se escribe y se borra, con el
+ * calendario a un botón de distancia. El `ref` va al **campo**, para que
+ * react-hook-form pueda enfocarlo al fallar la validación.
+ */
+export declare const DatePicker: import("react").ForwardRefExoticComponent<DatePickerProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/_types/molecules/DatePicker/dateMask.d.ts

@@ -0,0 +1,21 @@
+export type DatePartName = 'day' | 'month' | 'year';
+/** Letras de la máscara del marcador de posición: `dd/mm/aaaa` en castellano. */
+export interface DateMaskLetters {
+    day: string;
+    month: string;
+    year: string;
+}
+export declare const SPANISH_MASK_LETTERS: DateMaskLetters;
+export interface DateMask {
+    /** Orden de las partes en ese locale, p. ej. `['day', 'month', 'year']`. */
+    order: DatePartName[];
+    /** Literal que separa las partes: `/`, `.`, `-`… */
+    separator: string;
+    /** La fecha escrita en ese orden, con las cifras rellenadas: `25/09/2026`. */
+    format(date: Date): string;
+    /** La máscara de ejemplo con las letras dadas: `dd/mm/aaaa`. */
+    mask(letters: DateMaskLetters): string;
+    /** Lee la fecha tecleada. `null` si está incompleta o no existe. */
+    parse(text: string): Date | null;
+}
+export declare function getDateMask(locale: string): DateMask;

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

@@ -0,0 +1,26 @@
+import type { DatePickerProps } from '../DatePicker/DatePicker';
+import './DatePickerField.css';
+export interface DatePickerFieldProps extends Omit<DatePickerProps, 'id' | 'describedBy' | 'aria-describedby' | 'aria-label'> {
+    /** `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, como en el resto de campos.
+     * 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;
+    /** 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 `DatePicker` como campo de formulario. El `ref` va al **campo de texto**,
+ * para que react-hook-form pueda enfocarlo al fallar la validación; el
+ * `className`, al contenedor.
+ */
+export declare const DatePickerField: import("react").ForwardRefExoticComponent<DatePickerFieldProps & import("react").RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,69 @@
+import type { DatePickerProps } from '../DatePicker/DatePicker';
+import type { CalendarProps } from '../Calendar/Calendar';
+import './DateTimeField.css';
+export interface DateTimeFieldProps {
+    /** `id` del campo. 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, como en el resto de campos.
+     * 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;
+    value?: Date | null;
+    placeholder?: string;
+    /** Paso en minutos del selector de hora. */
+    timeStep?: number;
+    minDate?: CalendarProps['minDate'];
+    maxDate?: CalendarProps['maxDate'];
+    disabledDates?: CalendarProps['disabledDates'];
+    /** Nombre del campo en el formulario: se monta un input oculto con la fecha en ISO. */
+    name?: string;
+    size?: 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+    readOnly?: 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;
+    locale?: string;
+    /** Se añade DESPUÉS de las clases propias (el consumidor añade, no sustituye). */
+    className?: string;
+    /** Nombre accesible del panel del calendario. Default: la etiqueta del campo. */
+    calendarLabel?: DatePickerProps['calendarLabel'];
+    /** Nombre accesible del botón que abre el calendario. Default castellano. */
+    openCalendarLabel?: DatePickerProps['openCalendarLabel'];
+    /** Mensaje de fecha incompleta del campo de texto. Default castellano. */
+    invalidMessage?: DatePickerProps['invalidMessage'];
+    /** Letras de la máscara del marcador de posición. Default castellano. */
+    maskLetters?: DatePickerProps['maskLetters'];
+    /** aria-label del botón de mes anterior del calendario. Default castellano. */
+    previousMonthLabel?: DatePickerProps['previousMonthLabel'];
+    /** aria-label del botón de mes siguiente. Default castellano. */
+    nextMonthLabel?: DatePickerProps['nextMonthLabel'];
+    /** aria-label del botón de retroceso en la vista de años. Default castellano. */
+    previousYearsLabel?: DatePickerProps['previousYearsLabel'];
+    /** aria-label del botón de avance en la vista de años. Default castellano. */
+    nextYearsLabel?: DatePickerProps['nextYearsLabel'];
+    /** aria-label de la rejilla de años. Default castellano. */
+    yearGridLabel?: DatePickerProps['yearGridLabel'];
+    /** aria-label de la rejilla de días. Default: `calendarLabel`. */
+    gridLabel?: DatePickerProps['gridLabel'];
+    /** aria-label del desplegable de horas. Default: "Horas" (castellano). */
+    hoursLabel?: string;
+    /** aria-label del desplegable de minutos. Default: "Minutos" (castellano). */
+    minutesLabel?: string;
+    onChange?: (date: Date | null) => void;
+    /** Se llama al salir de cualquiera de los dos controles: el campo de fecha (un `<input>`) o los desplegables de hora (dos `<button>`). */
+    onBlur?: React.FocusEventHandler<HTMLElement>;
+}
+/**
+ * Fecha y hora en un solo campo: un `DatePicker` y un `TimeSelect` que
+ * comparten valor. El `ref` va al campo de la fecha, que es el primero que se
+ * enfoca; el `className`, al contenedor.
+ */
+export declare const DateTimeField: import("react").ForwardRefExoticComponent<DateTimeFieldProps & import("react").RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,95 @@
+import { type ReactNode } from 'react';
+import './DocsSearch.css';
+export interface DocsSearchResult {
+    /** URL del documento. Es también la clave del resultado. */
+    href: string;
+    /** Título del documento. */
+    title: string;
+    /**
+     * Fragmento del documento con la coincidencia. Es `ReactNode` para que el
+     * buscador pueda resaltar con `<mark>` lo que ha encontrado.
+     */
+    excerpt?: ReactNode;
+    /** Producto o sección a la que pertenece el documento. */
+    product?: string;
+}
+export type DocsSearchRenderLinkProps = React.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    href: string;
+    className: string;
+};
+export interface DocsSearchProps {
+    /** `id` del campo. Ata la etiqueta con el campo y el campo con la lista. */
+    id?: string;
+    /** Texto escrito. El componente es controlado: no guarda estado propio. */
+    query: string;
+    /** Se llama en cada tecla. Quien lo recibe decide cuándo y cómo buscar. */
+    onQueryChange: (query: string) => void;
+    /** Resultados ya filtrados por el buscador del consumidor. */
+    results: DocsSearchResult[];
+    /** Hay una búsqueda en curso: el aviso de estado lo dice. */
+    loading?: boolean;
+    /**
+     * Etiqueta del campo. Default castellano.
+     * @default 'Buscar en la documentación'
+     */
+    label?: string;
+    /** Oculta la etiqueta a la vista; el lector de pantalla la sigue leyendo. */
+    labelHidden?: boolean;
+    /**
+     * Pista dentro del campo. Default castellano.
+     * @default 'Buscar…'
+     */
+    placeholder?: string;
+    /**
+     * Ofrece un botón-aspa que vacía el campo y devuelve el foco. Es el gesto de
+     * un autocompletar: se borra para volver a preguntar.
+     * @default true
+     */
+    clearable?: boolean;
+    /**
+     * Nombre accesible del botón de borrado. Default castellano.
+     * @default 'Borrar'
+     */
+    clearLabel?: string;
+    /**
+     * Nombre accesible de la lista de resultados. Default castellano.
+     * @default 'Resultados'
+     */
+    resultsLabel?: string;
+    /**
+     * Aviso cuando la búsqueda no encuentra nada. Default castellano.
+     * @default 'Sin resultados.'
+     */
+    emptyLabel?: string;
+    /**
+     * Aviso mientras se busca. Default castellano.
+     * @default 'Buscando…'
+     */
+    loadingLabel?: string;
+    /** Talla del campo. */
+    size?: 'sm' | 'md' | 'lg';
+    /**
+     * Elemento sobre el que renderizar cada resultado: el `Link` del router del
+     * producto. Debe **propagar todas** las props que recibe — el motor inyecta
+     * el rol, el `id` del foco virtual y los handlers de teclado.
+     */
+    renderLink?: (props: DocsSearchRenderLinkProps) => ReactNode;
+    /** Se llama al activar un resultado, además de seguir el enlace. */
+    onSelect?: (result: DocsSearchResult) => void;
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * Buscador de documentación: un campo y sus resultados, con navegación por
+ * teclado y avisos de estado.
+ *
+ * **No busca nada.** No hace `fetch`, no filtra y no guarda estado: recibe
+ * `query`, `results` y `loading`, y los pinta. El índice —Pagefind, Algolia,
+ * una ruta propia— es del producto, y con él el rebote, la cancelación de
+ * respuestas tardías y la paginación.
+ *
+ * La conducta es el `Autocomplete` de Base UI con el filtrado desactivado
+ * (`filter={null}`) y la lista en línea, sin popup: los resultados de una
+ * búsqueda de documentación no son un menú flotante, son la página.
+ */
+export declare function DocsSearch({ id, query, onQueryChange, results, loading, label, labelHidden, placeholder, clearable, clearLabel, resultsLabel, emptyLabel, loadingLabel, size, renderLink, onSelect, className, }: DocsSearchProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,47 @@
+import { type ReactNode } from 'react';
+import { type MenuItem } from '../Menu/Menu';
+import './DropdownField.css';
+export interface DropdownFieldProps {
+    /** `id` del control; enlaza la etiqueta. Si no se pasa, se genera con `useId`. */
+    id?: string;
+    /** Etiqueta visible. Si no hay, es obligatorio `aria-label`. */
+    label?: string;
+    /** Oculta la etiqueta visualmente sin quitarla a los lectores de pantalla.   * 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;
+    /** Nombre accesible cuando no hay etiqueta visible. */
+    'aria-label'?: string;
+    /** Opciones del menú (radio para elección exclusiva, botones, enlaces…). */
+    items: MenuItem[];
+    /** Valor elegido (para los ítems `radio`). */
+    value?: string;
+    onValueChange?: (value: string) => void;
+    /** Lo que muestra el control: el nombre de la opción actual, con icono si lo hay. */
+    children: ReactNode;
+    /** `inline`: etiqueta delante del control, en línea. Por defecto, encima como el resto de campos. */
+    inline?: boolean;
+    /** Talla del sistema (32/40/48). En superficies públicas, `lg`; dentro de las aplicaciones, `md`. */
+    size?: 'sm' | 'md' | 'lg';
+    align?: 'start' | 'center' | 'end';
+    disabled?: boolean;
+    /** Nombre del campo en el formulario: se monta un input oculto con el valor. */
+    name?: string;
+    /** 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 llama al salir del disparador (react-hook-form lo usa para validar). */
+    onBlur?: React.FocusEventHandler<HTMLButtonElement>;
+    /** Se añade DESPUÉS de las clases propias (el consumidor añade, no sustituye). */
+    className?: string;
+}
+/**
+ * Campo desplegable: una etiqueta (visible u oculta) y un control rectangular
+ * a la altura del sistema que abre un `Menu`. Es el Select cuando las
+ * opciones no son un `<select>` — llevan icono, son enlaces o acciones — y
+ * su cara es la misma que la del Select para que convivan en un formulario.
+ */
+export declare const DropdownField: import("react").ForwardRefExoticComponent<DropdownFieldProps & import("react").RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,14 @@
+import './EmptyState.css';
+export interface EmptyStateAction {
+    label: string;
+    onClick?: React.MouseEventHandler<HTMLButtonElement | HTMLAnchorElement>;
+    href?: string;
+}
+export interface EmptyStateProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    title: string;
+    description?: string;
+    icon?: React.ReactNode;
+    action?: EmptyStateAction;
+    size?: 'sm' | 'md';
+}
+export declare function EmptyState({ title, description, icon, action, size, className, ...rest }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;