@stackcraftmx/calcita 0.32.2 → 0.47.0

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

@@ -0,0 +1,31 @@
+/**
+ * @param {object} props
+ * @param {string|number|Date} props.until el momento: un instante en texto, un Date o milisegundos
+ * @param {string} [props.label] ya traducido: qué se cuenta («Tiempo para que cierren las inscripciones»), para un lector de pantalla
+ * @param {() => void} [props.onComplete] al llegar a cero (una vez)
+ * @param {import('react').ReactNode} [props.completedText] lo que dice al terminar; por omisión «Ya terminó»
+ * @param {boolean} [props.showSeconds] por omisión, sí
+ * @param {(parts: {days: number, hours: number, minutes: number, seconds: number, totalSeconds: number, isOver: boolean}) => import('react').ReactNode} [props.children]
+ *     para pintarla a su manera
+ * @param {import('@mui/material/Typography').TypographyProps['variant']} [props.variant] por omisión body1
+ * @param {object} [props.sx]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function 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;
+}): 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;

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,21 @@
+/**
+ * @param {object} props
+ * @param {boolean} props.open
+ * @param {() => void} props.onClose
+ * @param {string} props.title ya traducido: qué documento es
+ * @param {string|Blob|null} props.src la dirección del PDF o el archivo (Blob o File)
+ * @param {string} [props.fileName] con qué nombre se descarga (por omisión, el título con .pdf)
+ * @param {import('react').ReactNode} [props.actions] botones suyos junto a «Abrir en otra pestaña» y «Descargar»
+ * @param {() => void} [props.onDownload] al descargar (para registrarlo, por ejemplo)
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function PdfViewerDialog(props: {
+    open: boolean;
+    onClose: () => void;
+    title: string;
+    src: string | Blob | null;
+    fileName?: string;
+    actions?: import('react').ReactNode;
+    onDownload?: () => void;
+    texts?: object;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,34 @@
+/** De qué lado sale el cajón. */
+export declare const FILTER_DRAWER_ANCHOR: Readonly<{
+    left: "left";
+    right: "right";
+}>;
+/**
+ * @param {object} props
+ * @param {boolean} props.open
+ * @param {() => void} props.onClose
+ * @param {object[]} props.fields los campos (filterDrawerFields.js): {name, label, kind, options?, keys?, prefix?, suffix?, decimals?, operators?, render?…}
+ * @param {Record<string, unknown>} props.values los filtros puestos hoy (de ahí sale el borrador al abrir)
+ * @param {(values: Record<string, unknown>) => void} props.onApply todos los campos del cajón juntos, al picar «Buscar»
+ * @param {'left'|'right'} [props.anchor] de qué lado sale (FILTER_DRAWER_ANCHOR); por omisión la derecha
+ * @param {number} [props.width] su ancho en escritorio, en px
+ * @param {string} [props.title] ya traducido; por omisión «Filtros»
+ * @param {string} [props.applyLabel] ya traducido; por omisión «Buscar»
+ * @param {boolean} [props.closeOnApply] por omisión sí
+ * @param {import('react').ReactNode} [props.children] algo más abajo de los campos (una nota, un enlace)
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function FilterDrawer(props: {
+    open: boolean;
+    onClose: () => void;
+    fields: object[];
+    values: Record<string, unknown>;
+    onApply: (values: Record<string, unknown>) => void;
+    anchor?: 'left' | 'right';
+    width?: number;
+    title?: string;
+    applyLabel?: string;
+    closeOnApply?: boolean;
+    children?: import('react').ReactNode;
+    texts?: object;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,139 @@
+/** Los tipos de campo del cajón. */
+export declare const FILTER_FIELD_KIND: Readonly<{
+    text: "text";
+    select: "select";
+    multiSelect: "multiSelect";
+    catalog: "catalog";
+    checkboxes: "checkboxes";
+    numberRange: "numberRange";
+    dateRange: "dateRange";
+    comparison: "comparison";
+    custom: "custom";
+}>;
+/** Los operadores de un campo de comparación, como viajan ('gte:500'). */
+export declare const COMPARISON_OPERATOR: Readonly<{
+    equals: "eq";
+    greaterThan: "gt";
+    greaterOrEqual: "gte";
+    lessThan: "lt";
+    lessOrEqual: "lte";
+}>;
+/**
+ * ¿El campo guarda una lista?
+ *
+ * @param {{kind: string, multiple?: boolean}} field
+ * @returns {boolean}
+ */
+export declare function isListField(field: {
+    kind: string;
+    multiple?: boolean;
+}): boolean;
+/**
+ * Los nombres con que viaja un campo en los filtros: uno, o dos para un rango.
+ *
+ * @param {{name: string, kind: string, keys?: {from?: string, to?: string}}} field
+ * @returns {string[]}
+ */
+export declare function filterKeysOf(field: {
+    name: string;
+    kind: string;
+    keys?: {
+        from?: string;
+        to?: string;
+    };
+}): string[];
+/**
+ * Un valor de comparación ('gte:500') en sus partes; null si viene vacío o no se entiende.
+ *
+ * @param {unknown} text
+ * @returns {{operator: string, value: string}|null}
+ */
+export declare function comparisonOf(text: unknown): {
+    operator: string;
+    value: string;
+} | null;
+/**
+ * Las partes de una comparación como viajan; '' si falta el número.
+ *
+ * @param {string} operator COMPARISON_OPERATOR
+ * @param {string} value
+ * @returns {string}
+ */
+export declare function comparisonTextOf(operator: string, value: string): string;
+/**
+ * ¿Ese valor de filtro está puesto? Un texto vacío o una lista vacía no cuentan.
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+export declare function isFilterValueSet(value: unknown): boolean;
+/**
+ * Los tipos de filtro para ServerTable (filterKinds): los de lista se leen como lista en la dirección.
+ *
+ * @param {object[]} fields
+ * @returns {Record<string, string>}
+ */
+export declare function filterDrawerKindsOf(fields: object[]): Record<string, string>;
+/**
+ * Lo que hay en los filtros para los campos del cajón (lo demás no se toca).
+ *
+ * @param {object[]} fields
+ * @param {Record<string, unknown>} filters
+ * @returns {Record<string, unknown>}
+ */
+export declare function drawerValuesOf(fields: object[], filters: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Los campos del cajón vacíos: lo que deja «Limpiar».
+ *
+ * @param {object[]} fields
+ * @returns {Record<string, unknown>}
+ */
+export declare function emptyDrawerValuesOf(fields: object[]): Record<string, unknown>;
+/**
+ * Los campos del cajón vacíos, para sumarlos a filterDefaults de ServerTable: la tabla solo guarda en la dirección los
+ * filtros que declara ahí.
+ *
+ * @param {object[]} fields
+ * @returns {Record<string, unknown>}
+ */
+export declare function filterDrawerDefaultsOf(fields: object[]): Record<string, unknown>;
+/**
+ * Cuántos campos del cajón tienen algo puesto (un rango con «desde» y «hasta» cuenta uno): el número del botón «Filtros».
+ *
+ * @param {object[]} fields
+ * @param {Record<string, unknown>} filters
+ * @returns {number}
+ */
+export declare function activeDrawerFilterCountOf(fields: object[], filters: Record<string, unknown>): number;
+/**
+ * Los rangos que no tienen sentido («hasta» menor que «desde»): {llave de «hasta»: true}.
+ *
+ * @param {object[]} fields
+ * @param {Record<string, unknown>} values
+ * @returns {Record<string, boolean>}
+ */
+export declare function invalidRangesOf(fields: object[], values: Record<string, unknown>): Record<string, boolean>;
+/**
+ * Los chips de los campos del cajón, con la forma de buildChipConfig: cada valor con su etiqueta, ya dicho en palabras.
+ *
+ * @param {object[]} fields
+ * @param {object} helpers
+ * @param {(key: string, values?: object) => string} helpers.t el de common (filterDrawer.chipFrom, chipTo)
+ * @param {(date: string) => string} [helpers.formatDate] cómo se ve una fecha
+ * @returns {{text: Array<{key: string, label: string, format?: (value: string) => string}>, multiSelect: Array<{key: string, label: string, itemLabel?: (value: string) => string}>}}
+ */
+export declare function filterDrawerChipsOf(fields: object[], { t, formatDate }: {
+    t: (key: string, values?: object) => string;
+    formatDate?: (date: string) => string;
+}): {
+    text: Array<{
+        key: string;
+        label: string;
+        format?: (value: string) => string;
+    }>;
+    multiSelect: Array<{
+        key: string;
+        label: string;
+        itemLabel?: (value: string) => string;
+    }>;
+};

package/dist/types/ui/help/HelpButton.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {object} props
+ * @param {() => void} props.onClick
+ * @param {string} [props.label] ya traducido; por omisión «Ayuda de esta pantalla»
+ * @param {'small'|'medium'|'large'} [props.size]
+ * @param {object} [props.sx]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function HelpButton({ onClick, label, size, sx, texts, ...unknownProps }: {
+    onClick: () => void;
+    label?: string;
+    size?: 'small' | 'medium' | 'large';
+    sx?: object;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/ui/help/HelpCarouselDialog.d.ts

@@ -0,0 +1,35 @@
+/** Por qué se cerró la ayuda. */
+export declare const HELP_CLOSE_REASON: Readonly<{
+    finished: "finished";
+    closed: "closed";
+}>;
+/**
+ * @param {object} props
+ * @param {boolean} props.open
+ * @param {(reason: string, details: {dontShowAgain: boolean}) => void} props.onClose HELP_CLOSE_REASON y si marcó «No volver a mostrar»
+ * @param {Array<{title: string, content: import('react').ReactNode, image?: string, imageAlt?: string, media?: import('react').ReactNode}>} props.steps
+ *     title y content ya traducidos; image (una dirección) o media (una ilustración propia) arriba
+ * @param {string} [props.title] ya traducido: de qué es la ayuda («Cómo usar el tablero»), arriba de los pasos
+ * @param {boolean} [props.showDontShowAgain] la casilla «No volver a mostrar al entrar» (por omisión sí)
+ * @param {(index: number) => void} [props.onStepChange]
+ * @param {number} [props.initialStep]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function HelpCarouselDialog(props: {
+    open: boolean;
+    onClose: (reason: string, details: {
+        dontShowAgain: boolean;
+    }) => void;
+    steps: Array<{
+        title: string;
+        content: import('react').ReactNode;
+        image?: string;
+        imageAlt?: string;
+        media?: import('react').ReactNode;
+    }>;
+    title?: string;
+    showDontShowAgain?: boolean;
+    onStepChange?: (index: number) => void;
+    initialStep?: number;
+    texts?: object;
+}): import("react").JSX.Element | null;

package/dist/types/ui/help/useHelpCarousel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @param {object} options
+ * @param {string} options.helpKey de qué pantalla es la ayuda ('tasks'): una llave por ayuda
+ * @param {string} [options.version] súbala cuando la ayuda cambie y deba volver a salir
+ * @param {boolean} [options.autoOpen] que salga sola la primera vez (por omisión sí)
+ * @param {boolean} [options.seen] lo que sabe el servidor del proyecto: true = ya la vio (no sale sola)
+ * @returns {{open: boolean, openHelp: () => void, closeHelp: (reason?: string, details?: {dontShowAgain: boolean}) => void, wasSeen: boolean}}
+ */
+export declare function useHelpCarousel({ helpKey, version, autoOpen, seen }: {
+    helpKey: string;
+    version?: string;
+    autoOpen?: boolean;
+    seen?: boolean;
+}): {
+    open: boolean;
+    openHelp: () => void;
+    closeHelp: (reason?: string, details?: {
+        dontShowAgain: boolean;
+    }) => void;
+    wasSeen: boolean;
+};

package/dist/types/ui/index.d.ts

@@ -18,14 +18,24 @@ export { LANGUAGES, default as LanguageToggle } from './navigation/LanguageToggl
 export { default as FontSizeToggle } from './navigation/FontSizeToggle.js';
 export { FONT_SIZE_LEVELS } from './navigation/fontSizeLevels.js';
 export { default as PageBreadcrumbs } from './navigation/PageBreadcrumbs.js';
+export { ROUTE_TABS_MODE, default as RouteTabs, useActiveRouteTab } from './navigation/RouteTabs.js';
+export { default as HelpButton } from './help/HelpButton.js';
+export { HELP_CLOSE_REASON, default as HelpCarouselDialog } from './help/HelpCarouselDialog.js';
+export { default as RecordCard } from './cards/RecordCard.js';
+export { default as RecordCardSkeleton } from './cards/RecordCardSkeleton.js';
+export { useHelpCarousel } from './help/useHelpCarousel.js';
 export { default as DateRangeFilter } from './filters/DateRangeFilter.js';
+export { FILTER_DRAWER_ANCHOR, default as FilterDrawer } from './filters/FilterDrawer.js';
+export { COMPARISON_OPERATOR, FILTER_FIELD_KIND, activeDrawerFilterCountOf, comparisonOf, comparisonTextOf, filterDrawerChipsOf, filterDrawerDefaultsOf, filterDrawerKindsOf, filterKeysOf, } from './filters/filterDrawerFields.js';
 export { default as PeriodRangeSelector } from './filters/PeriodRangeSelector.js';
 export { default as QuickFilters } from './filters/QuickFilters.js';
 export { default as SegmentedControl, SEGMENTED_CONTROL_SX } from './filters/SegmentedControl.js';
 export { default as DictionaryText } from './labels/DictionaryText.js';
 export { default as StatusChip } from './labels/StatusChip.js';
+export { ICON_BADGE_CLASSES, ICON_BADGE_VARIANT, default as IconBadge } from './labels/IconBadge.js';
 export { default as Tag } from './labels/Tag.js';
 export { default as CopyButton } from './actions/CopyButton.js';
+export { tableRowTextOf } from './actions/tableRowText.js';
 export { default as DownloadMenu } from './actions/DownloadMenu.js';
 export { default as SecretField } from './actions/SecretField.js';
 export { default as CalendarHeatmap } from './metrics/CalendarHeatmap.js';

package/dist/types/ui/labels/IconBadge.d.ts

@@ -0,0 +1,34 @@
+/** Los estilos de la insignia. */
+export declare const ICON_BADGE_VARIANT: Readonly<{
+    outlined: "outlined";
+    soft: "soft";
+    plain: "plain";
+}>;
+export declare const ICON_BADGE_CLASSES: Readonly<{
+    root: "CalcitaIconBadge-root";
+    icon: "CalcitaIconBadge-icon";
+    label: "CalcitaIconBadge-label";
+}>;
+/**
+ * @param {object} props
+ * @param {Record<string, object>} [props.dictionary] de donde sale la etiqueta, el tooltip, el color y el ícono
+ * @param {string|null} [props.value] con dictionary: el código del API
+ * @param {import('react').ElementType} [props.icon] suelta: el ícono (un componente, p. ej. VerifiedUserOutlinedIcon)
+ * @param {import('react').ReactNode} [props.label] suelta: el texto, ya traducido
+ * @param {'primary'|'secondary'|'success'|'warning'|'error'|'info'|'default'} [props.tone] suelta: el color
+ * @param {'outlined'|'soft'|'plain'} [props.variant] ICON_BADGE_VARIANT
+ * @param {'small'|'medium'} [props.size]
+ * @param {import('react').ReactNode} [props.tooltip] lo que explica al pasar el cursor (con dictionary, el del diccionario)
+ * @param {object} [props.sx]
+ */
+export default function IconBadge(props: {
+    dictionary?: Record<string, object>;
+    value?: string | null;
+    icon?: import('react').ElementType;
+    label?: import('react').ReactNode;
+    tone?: 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info' | 'default';
+    variant?: 'outlined' | 'soft' | 'plain';
+    size?: 'small' | 'medium';
+    tooltip?: import('react').ReactNode;
+    sx?: object;
+}): import("react").JSX.Element;

package/dist/types/ui/navigation/RouteTabs.d.ts

@@ -0,0 +1,44 @@
+/** Dónde vive la pestaña: en la ruta o en la consulta. */
+export declare const ROUTE_TABS_MODE: Readonly<{
+    path: "path";
+    query: "query";
+}>;
+/**
+ * La pestaña activa, para que la pantalla pinte lo suyo (sobre todo con mode query: la pantalla es una sola).
+ *
+ * @param {object[]} tabs las mismas de RouteTabs
+ * @param {{mode?: string, paramName?: string}} [options]
+ * @returns {string|null} el `to` (por ruta) o el `value` (por consulta) de la activa
+ */
+export declare function useActiveRouteTab(tabs: object[], { mode, paramName }?: {
+    mode?: string;
+    paramName?: string;
+}): string | null;
+/**
+ * @param {object} props
+ * @param {Array<{to?: string, value?: string, label: import('react').ReactNode, icon?: import('react').ReactElement, badge?: import('react').ReactNode, access?: object, exact?: boolean, disabled?: boolean, hidden?: boolean}>} props.tabs
+ *     to (por ruta) o value (por consulta); label ya traducido; badge: un conteo o un texto corto junto a la etiqueta
+ * @param {string} props.ariaLabel ya traducido: de qué son estas pestañas (para el lector de pantalla)
+ * @param {'path'|'query'} [props.mode] ROUTE_TABS_MODE
+ * @param {string} [props.paramName] con mode query: el nombre en la consulta (por omisión 'tab')
+ * @param {(tab: object) => void} [props.onChange] avisa la pestaña que se eligió (la navegación ya la hace la liga)
+ * @param {object} [props.sx]
+ */
+export default function RouteTabs(props: {
+    tabs: Array<{
+        to?: string;
+        value?: string;
+        label: import('react').ReactNode;
+        icon?: import('react').ReactElement;
+        badge?: import('react').ReactNode;
+        access?: object;
+        exact?: boolean;
+        disabled?: boolean;
+        hidden?: boolean;
+    }>;
+    ariaLabel: string;
+    mode?: 'path' | 'query';
+    paramName?: string;
+    onChange?: (tab: object) => void;
+    sx?: object;
+}): import("react").JSX.Element;

package/dist/types/ui/navigation/routeTabMatching.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @param {Array<{to: string, exact?: boolean}>} tabs
+ * @param {string} pathname
+ * @returns {string|null} el `to` de la pestaña activa
+ */
+export declare function activeRouteTabOf(tabs: Array<{
+    to: string;
+    exact?: boolean;
+}>, pathname: string): string | null;
+/**
+ * @param {Array<{value: string}>} tabs
+ * @param {string} search la consulta de la dirección ('?tab=pagos&page=2')
+ * @param {string} paramName 'tab'
+ * @returns {string|null} la pestaña de la consulta si existe; si no, la primera
+ */
+export declare function queryTabOf(tabs: Array<{
+    value: string;
+}>, search: string, paramName: string): string | null;
+/**
+ * La consulta con otra pestaña, sin perder lo demás que traía (?page=2 se queda).
+ *
+ * @param {string} search
+ * @param {string} paramName
+ * @param {string} value
+ * @returns {string} '?tab=pagos&page=2'
+ */
+export declare function searchWithTab(search: string, paramName: string, value: string): string;

package/dist/types/upload/AttachmentsInput.d.ts

@@ -0,0 +1,62 @@
+/**
+ * La lista conserva el tipo que usa la pantalla para lo ya guardado (T): onChange regresa esos mismos y los File nuevos.
+ *
+ * @template {File|{id?: string, name: string, size?: number}} T
+ * @param {object} props
+ * @param {string} [props.name]
+ * @param {import('react').ReactNode} [props.label] ya traducida; sin ella, va sin etiqueta (dentro de un correo, por ejemplo)
+ * @param {T[]} [props.value] los nuevos y los que ya están guardados
+ * @param {(files: Array<T|File>) => void} props.onChange la lista completa
+ * @param {() => void} [props.onBlur] se llama al agregar o quitar (para que el formulario lo marque como tocado)
+ * @param {(file: T) => void} [props.onRemove] al quitar uno (antes de onChange)
+ * @param {string|string[]} [props.accept] 'excel' | ['pdf', 'image'] | '.xlsx,.xls' | 'image/*'
+ * @param {number|string} [props.maxSize] el peso máximo de cada archivo: bytes o '10 MB'
+ * @param {number} [props.maxFiles] cuántos como máximo
+ * @param {number|string} [props.maxTotalSize] cuánto pueden pesar todos juntos
+ * @param {string|{key: string, values?: object}} [props.error]
+ * @param {string} [props.helperText] ya traducida
+ * @param {string} [props.buttonLabel] ya traducido; por omisión «Adjuntar»
+ * @param {boolean} [props.showButton] false esconde «Adjuntar» (la ventana se abre con pickerRef desde un botón suyo)
+ * @param {import('react').Ref<{open: () => void}>} [props.pickerRef] recibe {open} para abrir la ventana de archivos
+ * @param {boolean} [props.disabled]
+ * @param {boolean} [props.busy] candado mientras se sube: no se puede agregar ni quitar
+ * @param {(file: File, reason: string) => void} [props.onReject] reason es uno de FILE_REJECTION; sin él, un aviso
+ * @param {Parameters<typeof import('./TemplateDownloadButton.js').default>[0]} [props.template] «Descargar la
+ *     plantilla» junto a «Adjuntar»
+ * @param {import('react').ReactNode} [props.actions] botones suyos junto a «Adjuntar»
+ * @param {object} [props.sx]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function AttachmentsInput<T extends File | {
+    id?: string;
+    name: string;
+    size?: number;
+}>(props: {
+    name?: string;
+    label?: import('react').ReactNode;
+    value?: T[];
+    onChange: (files: Array<T | File>) => void;
+    onBlur?: () => void;
+    onRemove?: (file: T) => void;
+    accept?: string | string[];
+    maxSize?: number | string;
+    maxFiles?: number;
+    maxTotalSize?: number | string;
+    error?: string | {
+        key: string;
+        values?: object;
+    };
+    helperText?: string;
+    buttonLabel?: string;
+    showButton?: boolean;
+    pickerRef?: import('react').Ref<{
+        open: () => void;
+    }>;
+    disabled?: boolean;
+    busy?: boolean;
+    onReject?: (file: File, reason: string) => void;
+    template?: Parameters<typeof import('./TemplateDownloadButton.js').default>[0];
+    actions?: import('react').ReactNode;
+    sx?: object;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/upload/FileChip.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {object} props
+ * @param {{name: string, size?: number}} props.file
+ * @param {(() => void)|undefined} [props.onRemove] sin él no hay × (con el candado puesto, por ejemplo)
+ * @param {string} props.removeLabel ya traducido: «Quitar contrato.pdf»
+ * @param {import('react').ElementType} [props.ChipComponent] la parte del tema del cargador (por omisión, el Chip de MUI)
+ * @param {object} [props.ownSx] el estilo de la casa, debajo del tema del proyecto
+ */
+export default function FileChip({ file, onRemove, removeLabel, ChipComponent, ownSx }: {
+    file: {
+        name: string;
+        size?: number;
+    };
+    onRemove?: (() => void) | undefined;
+    removeLabel: string;
+    ChipComponent?: import('react').ElementType;
+    ownSx?: object;
+}): import("react").JSX.Element;

package/dist/types/upload/FileDropzone.d.ts

@@ -10,6 +10,8 @@
  * @param {boolean} [props.busy] candado mientras se sube: no se puede soltar, elegir ni quitar
  * @param {boolean|{title?: string, text?: string}} [props.busyModal] además bloquea la pantalla mientras busy
  * @param {(file: File, reason: string) => void} [props.onReject] reason es uno de FILE_REJECTION; sin él, un aviso
+ * @param {Parameters<typeof import('./TemplateDownloadButton.js').default>[0]} [props.template] «Descargar la
+ *     plantilla» junto a «Elegir archivo»: {href} de un archivo fijo o {request} al API
  * @param {import('react').ReactNode} [props.actions]
  * @param {import('react').ReactNode} [props.children]
  * @param {object} [props.sx] ajustes del recuadro
@@ -29,6 +31,7 @@ export default function FileDropzone(props: {
         text?: string;
     };
     onReject?: (file: File, reason: string) => void;
+    template?: Parameters<typeof import('./TemplateDownloadButton.js').default>[0];
     actions?: import('react').ReactNode;
     children?: import('react').ReactNode;
     sx?: object;

package/dist/types/upload/FileInput.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @param {object} props
+ * @param {string} [props.name]
+ * @param {import('react').ReactNode} [props.label] ya traducida
+ * @param {File|{name: string, size?: number}|null} [props.value] el archivo nuevo o el que ya está guardado
+ * @param {(file: File|null) => void} props.onChange null al quitarlo
+ * @param {() => void} [props.onBlur] se llama al elegir o quitar (para que el formulario lo marque como tocado)
+ * @param {string|string[]} [props.accept] 'excel' | ['pdf', 'image'] | '.xlsx,.xls' | 'image/*'
+ * @param {number|string} [props.maxSize] bytes o '10 MB'
+ * @param {string|{key: string, values?: object}} [props.error]
+ * @param {string} [props.helperText] ya traducida
+ * @param {string} [props.buttonLabel] ya traducido; por omisión «Elegir archivo»
+ * @param {string} [props.emptyText] ya traducido; por omisión «Ningún archivo elegido»
+ * @param {boolean} [props.disabled]
+ * @param {boolean} [props.busy] candado mientras se sube: no se puede elegir, soltar ni quitar
+ * @param {(file: File, reason: string) => void} [props.onReject] reason es uno de FILE_REJECTION; sin él, un aviso
+ * @param {Parameters<typeof import('./TemplateDownloadButton.js').default>[0]} [props.template] «Descargar la
+ *     plantilla» junto al botón
+ * @param {import('react').ReactNode} [props.actions] botones suyos en el mismo renglón
+ * @param {object} [props.sx] ajustes del renglón
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function FileInput(props: {
+    name?: string;
+    label?: import('react').ReactNode;
+    value?: File | {
+        name: string;
+        size?: number;
+    } | null;
+    onChange: (file: File | null) => void;
+    onBlur?: () => void;
+    accept?: string | string[];
+    maxSize?: number | string;
+    error?: string | {
+        key: string;
+        values?: object;
+    };
+    helperText?: string;
+    buttonLabel?: string;
+    emptyText?: string;
+    disabled?: boolean;
+    busy?: boolean;
+    onReject?: (file: File, reason: string) => void;
+    template?: Parameters<typeof import('./TemplateDownloadButton.js').default>[0];
+    actions?: import('react').ReactNode;
+    sx?: object;
+    texts?: object;
+}): import("react").JSX.Element;