@stackcraftmx/calcita 0.32.2 → 0.51.0

package/dist/types/table.d.ts

@@ -1,3 +1,5 @@
-export { AuditTrailDialog, AuditTrailTable, EmptyState, FILTER_KINDS, FilterChips, GoToPage, SELECTION_PHONE_LAYOUT, ServerTable, TableFilterContext, buildChipConfig, buildTableActors, detailColumn, facetColumn, isFilterActive, tableMachine, textColumn, toServerTableParams, useDebouncedFilter, useTableFilter, useTableState, } from './DataTable/index.js';
+export { ACTIONS_COLUMN_FIELD, AuditTrailDialog, AuditTrailTable, DETAIL_COLUMN_FIELD, EmptyState, FILTER_KINDS, FilterChips, GoToPage, SELECTION_PHONE_LAYOUT, ServerTable, ServerTableFilterDrawer, StackedCell, TABLE_VIEW, TableCardsView, TableFilterContext, TableViewToggle, actionsColumn, buildChipConfig, buildTableActors, detailColumn, facetColumn, fixedColumnOffsetsOf, fixedFieldsOf, isFilterActive, stackedColumn, statusColumn, statusColumnWidthOf, tableMachine, textColumn, textWidthOf, toServerTableParams, useDebouncedFilter, useTableFilter, useTableState, useTableView, } from './DataTable/index.js';
 export type RowSelection = import('./DataTable/rowSelection.js').RowSelection;
+export type StackedEntry = import('./DataTable/StackedCell.js').StackedEntry;
 /** @typedef {import('./DataTable/rowSelection.js').RowSelection} RowSelection */
+/** @typedef {import('./DataTable/StackedCell.js').StackedEntry} StackedEntry */

package/dist/types/theme/themePieces.d.ts

@@ -1,6 +1,29 @@
+/**
+ * El sx de la pantalla como lista, para ponerlo DESPUÉS del de la pieza sin mezclarlo dentro del mismo objeto.
+ *
+ * OJO, trampa pagada: `{...estiloDeLaPieza, ...sx}` reemplaza la llave entera cuando las dos traen la misma
+ * ('& .MuiDataGrid-cell': la pieza ponía display flex y la pantalla solo quería alinear arriba: se perdía el flex sin
+ * avisar). En una lista, MUI aplica cada elemento encima del anterior y se combinan regla por regla.
+ *
+ *   sx={[{p: 2}, ...sxListOf(sx)]}
+ *
+ * @param {object|Function|Array<object|Function|boolean|null|undefined>|null|undefined} sx
+ * @returns {Array<object|Function|boolean|null|undefined>}
+ */
+export declare function sxListOf(sx: object | Function | Array<object | Function | boolean | null | undefined> | null | undefined): Array<object | Function | boolean | null | undefined>;
+/**
+ * Las props de una parte con las de slotProps encima: las de la pantalla ganan, menos className (se suman), style (se
+ * juntan) y sx (va después y se combina regla por regla).
+ *
+ * @param {object} partProps las que le pone Calcita
+ * @param {object|((partProps: object) => object)|undefined} extra las de slotProps (o una función que las da)
+ * @returns {object}
+ */
+export declare function mergedSlotProps(partProps: object, extra: object | ((partProps: object) => object) | undefined): object;
 /**
  * Un componente con su lugar en el tema: theme.components[name].styleOverrides[parte con minúscula] se aplica después
- * del estilo de Calcita (ownSx) y gana.
+ * del estilo de Calcita (ownSx) y gana. La parte también se puede cambiar o recibir props de más con slots y slotProps
+ * de su pieza.
  *
  * @template {import('react').ElementType} C
  * @param {string} name el nombre de la pieza en el tema (CalcitaMetricCard)
@@ -10,11 +33,40 @@
  */
 export declare function piecePart<C extends import('react').ElementType>(name: string, slot: string, component?: C): import('react').ComponentType<any>;
 /**
- * Los props de la pieza con los defaultProps del tema del proyecto debajo: lo que llega en la pantalla gana.
+ * Los props de la pieza con los defaultProps del tema del proyecto debajo: lo que llega en la pantalla gana. Sin slots ni
+ * slotProps: esos son de sus partes (withPieceSlots).
+ *
+ * OJO: una pieza cuyo `slotProps` ya es de otra cosa (TextInput se lo pasa al TextField de MUI: input, htmlInput…) lo
+ * conserva con {ownSlotProps: true} y no se envuelve con withPieceSlots.
  *
  * @template {object} P
  * @param {P} props
  * @param {string} name el nombre de la pieza en el tema
+ * @param {{ownSlotProps?: boolean}} [options]
  * @returns {P}
  */
-export declare function usePieceProps<P extends object>(props: P, name: string): P;
+export declare function usePieceProps<P extends object>(props: P, name: string, { ownSlotProps }?: {
+    ownSlotProps?: boolean;
+}): P;
+/**
+ * La pieza con slots y slotProps: lee los de la pantalla (y los de defaultProps del tema) y se los da a sus partes.
+ *
+ * OJO con el tipo: se toma del componente entero (Parameters) y no de un genérico de sus props: con las props opcionales
+ * (ColorSchemeToggle) TypeScript las deducía como `object` y se perdían.
+ *
+ * Una parte que también se exporta sola y se pinta DENTRO de su pieza madre con el mismo nombre (las tarjetas de
+ * TableCardsView dentro de ServerTable, las dos CalcitaServerTable) va con {sharedWithParent: true}: adentro usa los slots
+ * de la madre (sin eso los borraría con los suyos, vacíos), salvo que la pantalla le dé los suyos; sola, los suyos.
+ *
+ * @template {(props: any) => any} C
+ * @param {C} Content la pieza
+ * @param {string} name el nombre de la pieza en el tema
+ * @param {{sharedWithParent?: boolean}} [options]
+ * @returns {(props: NonNullable<Parameters<C>[0]> & {slots?: Record<string, import('react').ElementType>, slotProps?: Record<string, object|((partProps: object) => object)>}) => ReturnType<C>}
+ */
+export declare function withPieceSlots<C extends (props: any) => any>(Content: C, name: string, { sharedWithParent }?: {
+    sharedWithParent?: boolean;
+}): (props: NonNullable<Parameters<C>[0]> & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => ReturnType<C>;

package/dist/types/toolkit/ToolkitProvider.d.ts

@@ -8,6 +8,12 @@
  *     tipos de archivo del proyecto para las descargas, además de Excel, CSV y PDF (downloads/fileTypes.js)
  * @param {(language: string) => void} [props.onLanguageChange] lo llama LanguageToggle; el proyecto cambia su idioma
  * @param {object} [props.texts] textos propios por idioma, con la forma de locales/ ({es: {table: {...}}})
+ * @param {(error: unknown) => unknown} [props.readValidationMessage] cómo leer los mensajes de validación de un sistema que ya
+ *     existe (su propio setLocale de yup, su forma de error): regresa un texto, {key, values} o undefined para la lectura de
+ *     siempre. Ej. ({msg, values}) de muchos sistemas con i18next ya se entiende solo; esto es para lo demás
+ * @param {(missing: {namespace: string, key: string, language: string}) => void} [props.onMissingText] avisa cada texto que
+ *     no existe (la pantalla enseña la llave): para mandarlo a Sentry o tronar una prueba. Sin él, Calcita avisa en la
+ *     consola una vez por idioma y llave
  * @param {(namespace: string, key: string, values?: object) => string|undefined} [props.translate] traductor del
  *     proyecto (por ejemplo i18next); undefined deja el texto del paquete
  * @param {string} [props.timeZone] zona de las fechas (por omisión la del navegador)
@@ -23,7 +29,7 @@
  *     tiene regla
  * @param {import('react').ReactNode} props.children
  */
-export declare const ToolkitProvider: ({ language, languages, onLanguageChange, texts, translate, timeZone, currency, hourCycle, appName, navigation, buildId, canAccess, fileTypes, children, ...unknownProps }: {
+export declare const ToolkitProvider: ({ language, languages, onLanguageChange, onMissingText, readValidationMessage, texts, translate, timeZone, currency, hourCycle, appName, navigation, buildId, canAccess, fileTypes, children, ...unknownProps }: {
     language?: string;
     languages?: Array<{
         code: string;
@@ -38,6 +44,12 @@ export declare const ToolkitProvider: ({ language, languages, onLanguageChange,
     }>;
     onLanguageChange?: (language: string) => void;
     texts?: object;
+    readValidationMessage?: (error: unknown) => unknown;
+    onMissingText?: (missing: {
+        namespace: string;
+        key: string;
+        language: string;
+    }) => void;
     translate?: (namespace: string, key: string, values?: object) => string | undefined;
     timeZone?: string;
     currency?: string;

package/dist/types/toolkit/browserNavigation.d.ts

@@ -2,12 +2,14 @@
  * La navegación del navegador, con o sin prefijo.
  *
  * @param {{basePath?: string}} [options] basePath: donde vive la app detrás de un proxy ('/portal'); sin él, la raíz
- * @returns {{useNavigate: () => (destination: string|number) => void, useLocation: () => {pathname: string, search: string, key: string}, Link: import('react').ElementType}}
+ * @returns {{useNavigate: () => (destination: string|number, options?: {replace?: boolean}) => void, useLocation: () => {pathname: string, search: string, key: string}, Link: import('react').ElementType}}
  */
 export declare function createBrowserNavigation({ basePath }?: {
     basePath?: string;
 }): {
-    useNavigate: () => (destination: string | number) => void;
+    useNavigate: () => (destination: string | number, options?: {
+        replace?: boolean;
+    }) => void;
     useLocation: () => {
         pathname: string;
         search: string;
@@ -17,7 +19,9 @@ export declare function createBrowserNavigation({ basePath }?: {
 };
 /** La de omisión: sin prefijo. */
 export declare const browserNavigation: {
-    useNavigate: () => (destination: string | number) => void;
+    useNavigate: () => (destination: string | number, options?: {
+        replace?: boolean;
+    }) => void;
     useLocation: () => {
         pathname: string;
         search: string;

package/dist/types/toolkit/combineTexts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {Array<Record<string, Record<string, object>>>} textFiles los textos de cada módulo, por idioma
+ * @returns {Record<string, Record<string, object>>} todos los textos, por idioma y namespace
+ * @throws {Error} si dos módulos definen el mismo texto
+ */
+export declare function combineTexts(textFiles: Array<Record<string, Record<string, object>>>): Record<string, Record<string, object>>;

package/dist/types/toolkit/hashNavigation.d.ts

@@ -1,8 +1,10 @@
 /**
- * @returns {{useNavigate: () => (destination: string|number) => void, useLocation: () => {pathname: string, search: string, key: string}, Link: import('react').ElementType}}
+ * @returns {{useNavigate: () => (destination: string|number, options?: {replace?: boolean}) => void, useLocation: () => {pathname: string, search: string, key: string}, Link: import('react').ElementType}}
  */
 export declare function createHashNavigation(): {
-    useNavigate: () => (destination: string | number) => void;
+    useNavigate: () => (destination: string | number, options?: {
+        replace?: boolean;
+    }) => void;
     useLocation: () => {
         pathname: string;
         search: string;

package/dist/types/toolkit/navigationPaths.d.ts

@@ -41,3 +41,38 @@ export declare function hashLocationOf(hash: string): {
  * @returns {string}
  */
 export declare function hashHrefOf(destination: string): string;
+/**
+ * Si un clic en un enlace es el normal: el botón principal, sin Cmd/Ctrl/Shift/Alt y sin que nadie lo haya detenido.
+ * Solo ese se hace por dentro (cambiar de pantalla, reemplazar el historial); con Cmd/Ctrl+clic, Shift+clic o el botón de en
+ * medio el navegador hace lo suyo (otra pestaña, otra ventana), como con cualquier liga.
+ *
+ * @param {{button?: number, metaKey?: boolean, ctrlKey?: boolean, shiftKey?: boolean, altKey?: boolean, defaultPrevented?: boolean}} event
+ * @param {string} [target] el target del enlace: con _blank tampoco se hace por dentro
+ * @returns {boolean}
+ */
+export declare function isPlainLeftClick(event: {
+    button?: number;
+    metaKey?: boolean;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    defaultPrevented?: boolean;
+}, target?: string): boolean;
+/**
+ * El prefijo con que el servidor sirvió la página, leído al abrirla de su <base href> ('/ventas'), o null si la página no
+ * trae <base>. Así UNA compilación sirve detrás de cualquier prefijo que decida el servidor (Laravel lo pone con
+ * config('app.url'), un proxy con su ruta): el prefijo no se fija al compilar. Para el basename del router y para
+ * createBrowserNavigation({basePath}).
+ *
+ *   <base href="{{ rtrim(config('app.url'), '/') . '/' }}">          (en la vista que sirve la app)
+ *   createBrowserRouter(routes, {basename: documentBasePath() || '/'})
+ *
+ * OJO: con <base>, todo lo relativo de la página (imágenes, ligas «#sección») se lee desde ese prefijo.
+ *
+ * @param {{baseURI?: string, querySelector?: (selector: string) => unknown}} [currentDocument] por omisión el de la página
+ * @returns {string|null} '' en la raíz; null sin <base> (o sin navegador)
+ */
+export declare function documentBasePath(currentDocument?: {
+    baseURI?: string;
+    querySelector?: (selector: string) => unknown;
+}): string | null;

package/dist/types/toolkit/pathIndex.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Le pone sus partes a una ruta: las que pide con dos puntos y, lo que sobre, la consulta. Los nulos y los vacíos no se
+ * escriben.
+ *
+ * @param {string} route la ruta con sus :partes ('/orders/:orderId', ':page?' es opcional)
+ * @param {Record<string, unknown>} [params]
+ * @param {string} [name] cómo se llama, para decirlo si algo falta
+ * @returns {string}
+ * @throws {Error} si la ruta pide una parte obligatoria que no viene
+ */
+export declare function fillPath(route: string, params?: Record<string, unknown>, name?: string): string;
+/**
+ * El índice de las direcciones que publica cada módulo.
+ *
+ * @param {Record<string, Record<string, unknown>>} modules lo que da import.meta.glob(..., {eager: true}): archivo → sus exports
+ * @param {object} [options]
+ * @param {string} [options.exportName] el export con las direcciones en cada archivo (por omisión 'paths'; para el API, 'uris')
+ * @param {RegExp} [options.modulePattern] saca del nombre del archivo el camino del módulo (el primer grupo, con /)
+ * @returns {{pathOf: (name: string, params?: Record<string, unknown>) => string, allPaths: () => object}}
+ */
+export declare function createPathIndex(modules: Record<string, Record<string, unknown>>, { exportName, modulePattern }?: {
+    exportName?: string;
+    modulePattern?: RegExp;
+}): {
+    pathOf: (name: string, params?: Record<string, unknown>) => string;
+    allPaths: () => object;
+};

package/dist/types/toolkit/toolkitSettings.d.ts

@@ -33,7 +33,7 @@ export declare function browserTimeZone(): string;
  * Cambia la configuración que leen las funciones del paquete. La llama ToolkitProvider; un proyecto sin React (o una
  * prueba) la puede llamar directo.
  *
- * @param {{language?: string, texts?: object, translate?: Function|null, timeZone?: string, currency?: string, hourCycle?: 'h23'|'h12', appName?: string, buildId?: string, languages?: Array<{code: string, label: string, locale?: string}>}} settings
+ * @param {{language?: string, texts?: object, translate?: Function|null, timeZone?: string, currency?: string, hourCycle?: 'h23'|'h12', appName?: string, buildId?: string, languages?: Array<{code: string, label: string, locale?: string}>, onMissingText?: Function|null}} settings
  * @returns {void}
  */
 export declare function configureToolkit(settings: {
@@ -50,6 +50,7 @@ export declare function configureToolkit(settings: {
         label: string;
         locale?: string;
     }>;
+    onMissingText?: Function | null;
 }): void;
 /**
  * La configuración vigente.
@@ -102,16 +103,18 @@ export declare function componentTextOf(layers: Array<{
 /**
  * El texto de una llave con una configuración dada (la del proveedor o la vigente).
  *
- * @param {{language: string, texts: object, translate: Function|null}} settings
+ * @param {{language: string, texts: object, translate: Function|null, onMissingText?: Function|null}} settings
  * @param {string} defaultNamespace el namespace cuando la llave no trae uno («table», «common», «problems»...)
  * @param {string} key «llave» o «namespace:llave»
- * @param {object} [values] las variables del texto y, para el plural, count
- * @returns {string} la llave misma si no hay texto, para que se note qué falta
+ * @param {object} [values] las variables del texto y, para el plural, count. Con `defaultValue` el texto es opcional: si no
+ *     existe se usa ese y no se avisa
+ * @returns {string} la llave misma si no hay texto, para que se note qué falta (y se avisa: reportMissingText)
  */
 export declare function translateWith(settings: {
     language: string;
     texts: object;
     translate: Function | null;
+    onMissingText?: Function | null;
 }, defaultNamespace: string, key: string, values?: object): string;
 /**
  * El texto de una llave con la configuración vigente, para lo que no es componente (avisos, errores del servidor).

package/dist/types/ui/actions/ActionsMenu.d.ts

@@ -1,20 +1,33 @@
-/**
- * @param {object} props
- * @param {string} props.label el nombre del botón (lector de pantalla y su tooltip), ya traducido
- * @param {Array<{key: string, label: string, icon?: import('react').ReactNode, color?: string, disabled?: boolean, onClick: () => void}>} [props.actions]
- * @param {import('react').ReactNode} [props.icon] otro ícono para el botón (por omisión «⋯»)
- * @param {'small'|'medium'} [props.size]
- */
-export default function ActionsMenu(props: {
+/** Los renglones que no son acciones. */
+export declare const ACTIONS_MENU_ROW: Readonly<{
+    section: "section";
+    divider: "divider";
+}>;
+declare const ActionsMenu: (props: {
     label: string;
     actions?: Array<{
         key: string;
-        label: string;
+        type?: string;
+        label?: string;
         icon?: import('react').ReactNode;
+        description?: string;
         color?: string;
         disabled?: boolean;
-        onClick: () => void;
+        onClick?: (event: import('react').MouseEvent<HTMLElement>) => void;
+        to?: string;
+        replace?: boolean;
+        href?: string;
+        download?: string | boolean;
+        children?: object[];
+        render?: (helpers: {
+            close: () => void;
+        }) => import('react').ReactNode;
     }>;
     icon?: import('react').ReactNode;
     size?: 'small' | 'medium';
-}): import("react").JSX.Element | null;
+    texts?: object;
+} & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => import("react").JSX.Element | null;
+export default ActionsMenu;

package/dist/types/ui/actions/CopyButton.d.ts

@@ -1,15 +1,12 @@
-/**
- * @param {object} props
- * @param {string} props.value lo que se copia
- * @param {string} [props.label] ya traducido; por omisión «Copiar»
- * @param {'small'|'medium'} [props.size]
- * @param {() => void} [props.onCopied]
- * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
- */
-export default function CopyButton({ value, label, size, onCopied, texts, ...unknownProps }: {
-    value: string;
+declare const CopyButton: (props: {
+    value: string | (() => string);
     label?: string;
     size?: 'small' | 'medium';
     onCopied?: () => void;
+    onCopyFailed?: (error: unknown) => void;
     texts?: object;
-}): import("react").JSX.Element;
+} & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => import("react").JSX.Element;
+export default CopyButton;

package/dist/types/ui/actions/DownloadMenu.d.ts

@@ -1,31 +1,4 @@
-/**
- * @param {object} props
- * @param {string[]} props.formats los tipos de archivo, en orden: los de la casa (xlsx, csv, pdf) y los que el proyecto declare
- *     en ToolkitProvider fileTypes (zip, xml…)
- * @param {(format: string, transferOptions: {signal: AbortSignal, onDownloadProgress: (progress: {loaded: number, total?: number|null}) => void}) => Promise<{blob: Blob, fileName: string}>} props.download
- * @param {string} [props.label] ya traducido; por defecto "Descargar"
- * @param {string} [props.downloadLabel] ya traducido; lo que se ve en el panel de descargas antes de saber el nombre
- *     del archivo
- * @param {boolean} [props.disabled]
- * @param {(format: string) => {title: string, description: import('react').ReactNode, confirmLabel?: string}} [props.confirmation]
- * @param {(format: string) => void} [props.onDownloaded] p. ej. volver a pedir la tabla (si la descarga cambia algo en
- *     el servidor)
- * @param {(format: string, error: unknown) => void} [props.onFailed] cuando la descarga no se pudo (el panel ya lo dice)
- * @param {(format: string) => void} [props.onCanceled] cuando la persona la canceló desde el panel
- * @param {'button'|'icon'} [props.variant] icon = solo el icono (columna de acciones de una tabla)
- * @param {string} [props.ariaLabel] ya traducido; obligatorio en la variante icon
- * @param {(format: string) => void} [props.onChooseFormat] quien llama se encarga de confirmar y descargar
- * @param {import('react').ElementType} [props.icon] ícono del botón; por defecto el de descarga. Distingue dos descargas en la
- *     misma fila
- *
- * IMPORTANTE: hay que pasar `confirmation` u `onChooseFormat`. Sin ninguno de los dos el menú no descarga nada (regla de
- * tablas: toda descarga pasa por confirmación).
- *
- * OJO onChooseFormat: dentro de una celda del DataGrid el diálogo de confirmación NO puede vivir en la celda (el grid
- * virtualiza y vuelve a pintar sus celdas; el diálogo se perdía al elegir el formato). Ahí el menú solo avisa qué formato
- * se eligió y la pantalla abre SU confirmación (useConfirmAction) fuera de la tabla.
- */
-export default function DownloadMenu(props: {
+declare const DownloadMenu: (props: {
     formats: string[];
     download: (format: string, transferOptions: {
         signal: AbortSignal;
@@ -52,4 +25,8 @@ export default function DownloadMenu(props: {
     ariaLabel?: string;
     onChooseFormat?: (format: string) => void;
     icon?: import('react').ElementType;
-}): import("react").JSX.Element;
+} & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => import("react").JSX.Element;
+export default DownloadMenu;

package/dist/types/ui/actions/SecretField.d.ts

@@ -1,17 +1,12 @@
-/**
- * @param {object} props
- * @param {string} props.value el secreto
- * @param {string} props.label ya traducido
- * @param {string} [props.helperText] p. ej. «Guárdela: no se vuelve a enseñar»
- * @param {() => void} [props.onCopied]
- * @param {(isRevealed: boolean) => void} [props.onRevealChange] se destapó o se tapó (para registrar quién vio el secreto)
- * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
- */
-export default function SecretField({ value, label, helperText, onCopied, onRevealChange, texts, ...unknownProps }: {
+declare const SecretField: (props: {
     value: string;
     label: string;
     helperText?: string;
     onCopied?: () => void;
     onRevealChange?: (isRevealed: boolean) => void;
     texts?: object;
-}): import("react").JSX.Element;
+} & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => import("react").JSX.Element;
+export default SecretField;

package/dist/types/ui/actions/SelectionActions.d.ts

@@ -11,18 +11,7 @@ export declare const SELECTION_PHONE_LAYOUT: Readonly<{
  * @returns {boolean}
  */
 export declare function selectionFloatsOnPhone(theme: object): boolean;
-/**
- * @param {object} props
- * @param {string} props.countText «5 pedidos elegidos», ya traducido. La pieza se pinta mientras la pantalla la ponga: con
- *     nada elegido, no la ponga
- * @param {Array<{key: string, label: string, icon?: import('react').ReactNode, color?: 'inherit'|'primary'|'secondary'|'error'|'info'|'success'|'warning', disabled?: boolean, onClick: () => unknown}>} [props.actions]
- *     label ya traducido; en el teléfono se ve el ícono (sin él, el texto). onClick puede regresar una promesa
- * @param {() => void} props.onClear quitar la selección
- * @param {'top'|'split'} [props.phoneLayout] SELECTION_PHONE_LAYOUT; por omisión todo arriba
- * @param {object} [props.texts] los textos que cambian, con la forma de `common`: {selection: {clear, actionsLabel, summaryLabel}}
- * @param {object} [props.sx] estilos del renglón
- */
-export default function SelectionActions(props: {
+declare const SelectionActions: (props: {
     countText: string;
     actions?: Array<{
         key: string;
@@ -36,4 +25,8 @@ export default function SelectionActions(props: {
     phoneLayout?: 'top' | 'split';
     texts?: object;
     sx?: object;
-}): import("react").JSX.Element;
+} & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => import("react").JSX.Element;
+export default SelectionActions;

package/dist/types/ui/actions/tableRowText.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {Array<string|number|null|undefined>} cells las celdas en el orden de las columnas, ya formateadas
+ * @returns {string} las celdas unidas con tabulador; una vacía o nula queda vacía. Un tabulador o un salto de renglón dentro
+ *     de una celda se cambia por un espacio: partirían el renglón al pegarlo
+ */
+export declare function tableRowTextOf(cells: Array<string | number | null | undefined>): string;

package/dist/types/ui/cards/RecordCard.d.ts

@@ -0,0 +1,40 @@
+declare const RecordCard: (props: {
+    title: import('react').ReactNode;
+    eyebrow?: import('react').ReactNode;
+    subtitle?: import('react').ReactNode;
+    avatar?: string | import('react').ReactNode;
+    status?: import('react').ReactNode;
+    actions?: Parameters<typeof import('../actions/ActionsMenu.js').default>[0]['actions'];
+    groups?: Array<{
+        key?: string;
+        title?: import('react').ReactNode;
+        facts?: Array<{
+            label: import('react').ReactNode;
+            value: import('react').ReactNode;
+            emphasis?: boolean;
+        }>;
+        content?: import('react').ReactNode;
+    }>;
+    header?: import('react').ReactNode;
+    children?: import('react').ReactNode;
+    highlight?: {
+        label: import('react').ReactNode;
+        value: import('react').ReactNode;
+        caption?: import('react').ReactNode;
+    };
+    trailing?: import('react').ReactNode;
+    columns?: string;
+    footer?: import('react').ReactNode;
+    details?: import('react').ReactNode;
+    detailsLabel?: string;
+    defaultDetailsOpen?: boolean;
+    onDetailsToggle?: (isOpen: boolean) => void;
+    onOpen?: () => void;
+    openLabel?: string;
+    sx?: object;
+    texts?: object;
+} & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => import("react").JSX.Element;
+export default RecordCard;

package/dist/types/ui/cards/RecordCardSkeleton.d.ts

@@ -0,0 +1,12 @@
+declare const RecordCardSkeleton: (props: {
+    groups?: number;
+    factsPerGroup?: number;
+    withAvatar?: boolean;
+    withHighlight?: boolean;
+    sx?: object;
+    texts?: object;
+} & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => import("react").JSX.Element;
+export default RecordCardSkeleton;

package/dist/types/ui/countdown/Countdown.d.ts

@@ -0,0 +1,22 @@
+declare const Countdown: (props: {
+    until: string | number | Date;
+    label?: string;
+    onComplete?: () => void;
+    completedText?: import('react').ReactNode;
+    showSeconds?: boolean;
+    children?: (parts: {
+        days: number;
+        hours: number;
+        minutes: number;
+        seconds: number;
+        totalSeconds: number;
+        isOver: boolean;
+    }) => import('react').ReactNode;
+    variant?: import('@mui/material/Typography').TypographyProps['variant'];
+    sx?: object;
+    texts?: object;
+} & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => string | number | bigint | boolean | import("react").JSX.Element | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;
+export default Countdown;

package/dist/types/ui/countdown/countdownParts.d.ts

@@ -0,0 +1,39 @@
+/**
+ * El momento en milisegundos: un instante en texto ('2026-11-01T18:30:00Z'), un Date o milisegundos.
+ *
+ * @param {string|number|Date} until
+ * @returns {number} NaN si no se entiende
+ */
+export declare function instantMillisecondsOf(until: string | number | Date): number;
+/**
+ * Lo que falta, partido. Ya pasado (o un momento que no se entiende) es todo en cero con isOver.
+ *
+ * @param {string|number|Date} until
+ * @param {number} now milisegundos de ahora (Date.now())
+ * @returns {{days: number, hours: number, minutes: number, seconds: number, totalSeconds: number, isOver: boolean}}
+ */
+export declare function countdownPartsOf(until: string | number | Date, now: number): {
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    totalSeconds: number;
+    isOver: boolean;
+};
+/**
+ * Lo que falta como reloj: «02:14:30»; con días, «3 d 02:14:30» (la letra del día la da el idioma); sin segundos,
+ * «02:14».
+ *
+ * @param {{days: number, hours: number, minutes: number, seconds: number}} parts
+ * @param {{daysLabel?: string, showSeconds?: boolean}} [options] daysLabel: la abreviatura de días ya traducida ('d')
+ * @returns {string}
+ */
+export declare function countdownClockOf({ days, hours, minutes, seconds }: {
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+}, { daysLabel, showSeconds }?: {
+    daysLabel?: string;
+    showSeconds?: boolean;
+}): string;

package/dist/types/ui/countdown/useCountdown.d.ts

@@ -0,0 +1,14 @@
+import { countdownPartsOf } from './countdownParts.js';
+/**
+ * @param {string|number|Date} until el momento: un instante en texto, un Date o milisegundos
+ * @param {{onComplete?: () => void, now?: () => number}} [options] onComplete: al llegar a cero (una vez); now: el reloj
+ *     (para probar con una hora fija)
+ * @returns {{parts: ReturnType<typeof countdownPartsOf>, isOver: boolean}}
+ */
+export declare function useCountdown(until: string | number | Date, { onComplete, now }?: {
+    onComplete?: () => void;
+    now?: () => number;
+}): {
+    parts: ReturnType<typeof countdownPartsOf>;
+    isOver: boolean;
+};

package/dist/types/ui/documents/PdfViewerDialog.d.ts

@@ -0,0 +1,14 @@
+declare const PdfViewerDialog: (props: {
+    open: boolean;
+    onClose: () => void;
+    title: string;
+    src: string | Blob | null;
+    fileName?: string;
+    actions?: import('react').ReactNode;
+    onDownload?: () => void;
+    texts?: object;
+} & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => import("react").JSX.Element;
+export default PdfViewerDialog;

package/dist/types/ui/filters/DateRangeFilter.d.ts

@@ -1,12 +1,4 @@
-/**
- * @param {object} props
- * @param {string} [props.from] AAAA-MM-DD o '' si no hay
- * @param {string} [props.to] AAAA-MM-DD o '' si no hay
- * @param {(range: {from: string, to: string}) => void} props.onChange '' para quitar
- * @param {string} [props.label] ya traducido; por defecto "Personalizado"
- * @param {object} [props.texts] los textos que cambian, con la forma de `table` en los textos del paquete
- */
-export default function DateRangeFilter(props: {
+declare const DateRangeFilter: (props: {
     from?: string;
     to?: string;
     onChange: (range: {
@@ -15,4 +7,8 @@ export default function DateRangeFilter(props: {
     }) => void;
     label?: string;
     texts?: object;
-}): import("react").JSX.Element;
+} & {
+    slots?: Record<string, import('react').ElementType>;
+    slotProps?: Record<string, object | ((partProps: object) => object)>;
+}) => import("react").JSX.Element;
+export default DateRangeFilter;