@stackcraftmx/calcita 0.0.0-stage → 0.23.0

package/dist/types/appShell/pageTitle.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @param {{children: import('react').ReactNode}} props
+ */
+export declare function PageTitleProvider({ children }: {
+    children: import('react').ReactNode;
+}): import("react").JSX.Element;
+/**
+ * El título registrado y si se está viendo.
+ *
+ * @returns {{title: string|null, setTitle: Function, isTitleVisible: boolean, setTitleVisible: Function}}
+ */
+export declare function usePageTitle(): {
+    title: string | null;
+    setTitle: Function;
+    isTitleVisible: boolean;
+    setTitleVisible: Function;
+};
+/**
+ * Registra el título de la página y avisa si su elemento se está viendo (para la barra).
+ *
+ * @param {string|null|undefined} title
+ * @param {{current: Element|null}} titleRef el elemento del título grande
+ */
+export declare function useRegisterPageTitle(title: string | null | undefined, titleRef: {
+    current: Element | null;
+}): void;

package/dist/types/appShell/shellSizes.d.ts

@@ -0,0 +1,45 @@
+/** El id del contenido: a donde lleva «Saltar al contenido». */
+export declare const MAIN_CONTENT_ID = "main-content";
+/** El menú lateral abierto (ícono y nombre; 240 como las plantillas de MUI) y encogido (solo íconos, el rail). */
+export declare const DRAWER_WIDTH_EXPANDED = 240;
+export declare const DRAWER_WIDTH_COLLAPSED = 64;
+/** El alto de la barra de arriba (sin avisos). */
+export declare const APP_BAR_HEIGHT_PIXELS = 56;
+/**
+ * Con vidrio (createToolkitTheme({glass: true})), el menú lateral y la barra flotan separados de la orilla de la ventana
+ * y entre ellos, como los paneles de macOS 26: así el contenido pasa por detrás y el vidrio tiene qué desenfocar. Es la
+ * misma separación que el tema les da a los cajones y a la hoja de abajo (GLASS_INSET_PIXELS), para que todo flote igual.
+ */
+export declare const GLASS_PANEL_GAP_PIXELS = 8;
+/**
+ * Teléfono o escritorio. Teléfono: angosto (menos de 900 px, el «md» de MUI) O bajito (menos de 500 px de alto: un teléfono
+ * acostado). Solo con el ancho, un iPhone Pro Max acostado (932 × 430) salía con el marco de escritorio y su menú lateral
+ * no cabía (lo reportaron). Van como media queries para usarse en sx: [PHONE_MEDIA_QUERY]: {...}.
+ */
+export declare const PHONE_MEDIA_QUERY = "@media (max-width: 899.95px), (max-height: 499.95px)";
+export declare const DESKTOP_MEDIA_QUERY = "@media (min-width: 900px) and (min-height: 500px)";
+/** El teléfono acostado: la barra de pestañas va compacta (ícono y nombre lado a lado) para dejarle el alto al contenido. */
+export declare const PHONE_LANDSCAPE_MEDIA_QUERY = "@media (max-height: 499.95px)";
+/** La barra de pestañas del teléfono con vidrio (MobileTabBar): su alto parado y acostado. */
+export declare const MOBILE_TAB_BAR_HEIGHT_PIXELS: Readonly<{
+    portrait: 60;
+    landscape: 46;
+}>;
+/**
+ * Lo que flota abajo al centro en el teléfono con vidrio (el aviso de versión nueva, la invitación a instalar): encima de
+ * la barra de pestañas, con la separación de la barra a la orilla, su alto, la separación pedida y la zona del gesto de
+ * inicio del iPhone. Para el sx: ...aboveMobileTabBarOf(8).
+ *
+ * @param {number} gapPixels lo que se separa de la barra de pestañas (px)
+ * @returns {object}
+ */
+export declare function aboveMobileTabBarOf(gapPixels: number): object;
+/**
+ * La transición que comparten el menú, la barra y el botón flotante: si cada uno usara la suya, terminarían en frames
+ * distintos y el ojo lo lee como un salto.
+ *
+ * @param {object} theme el tema de MUI
+ * @param {string[]} [properties] lo que se anima
+ * @returns {string}
+ */
+export declare function drawerTransitionOf(theme: object, properties?: string[]): string;

package/dist/types/appShell/tabBarRule.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param {object} theme el tema de MUI
+ * @returns {boolean}
+ */
+export declare function usesMobileTabBar(theme: object): boolean;

package/dist/types/appShell/tabBarScroll.d.ts

@@ -0,0 +1,26 @@
+export declare const MINIMIZE_AFTER_PIXELS = 24;
+export declare const EXPAND_AFTER_PIXELS = 12;
+export declare const ALWAYS_EXPANDED_UNTIL_PIXELS = 60;
+/** Al abrir la pantalla: completa, arriba y sin recorrido. */
+export declare const TAB_BAR_SCROLL_START: Readonly<{
+    isMinimized: false;
+    lastY: 0;
+    travel: 0;
+}>;
+/**
+ * El estado de la barra después de que la página se deslizó a scrollY.
+ *
+ * @param {{isMinimized: boolean, lastY: number, travel: number}} state travel: lo recorrido en la dirección de ahorita
+ *     (positivo hacia abajo)
+ * @param {number} scrollY cuánto está deslizada la página (window.scrollY)
+ * @returns {{isMinimized: boolean, lastY: number, travel: number}}
+ */
+export declare function tabBarStateAfterScroll(state: {
+    isMinimized: boolean;
+    lastY: number;
+    travel: number;
+}, scrollY: number): {
+    isMinimized: boolean;
+    lastY: number;
+    travel: number;
+};

package/dist/types/appShell/useDrawerCollapsed.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {boolean} [defaultCollapsed]
+ * @returns {{collapsed: boolean, toggle: () => void}}
+ */
+export declare function useDrawerCollapsed(defaultCollapsed?: boolean): {
+    collapsed: boolean;
+    toggle: () => void;
+};

package/dist/types/appShell/useFittingActionCount.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {Element|null} slot el renglón flotante del teléfono (null: no se mide y se ven todos)
+ * @param {HTMLElement|null} capsule la cápsula de este grupo
+ * @param {number} actionCount cuántos botones trae el grupo
+ * @returns {number} cuántos se ven como ícono; si es menor que actionCount, los demás van al «⋯»
+ */
+export default function useFittingActionCount(slot: Element | null, capsule: HTMLElement | null, actionCount: number): number;

package/dist/types/appShell/usePinnedMobileTabs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @returns {{pinnedKeys: string[]|null, setPinnedKeys: (keys: string[]|null) => void}} las llaves son menuItemKeyOf
+ */
+export declare function usePinnedMobileTabs(): {
+    pinnedKeys: string[] | null;
+    setPinnedKeys: (keys: string[] | null) => void;
+};

package/dist/types/appShell/useTabBarMinimized.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {boolean} isEnabled false: siempre completa
+ * @returns {{isMinimized: boolean, expand: () => void}}
+ */
+export declare function useTabBarMinimized(isEnabled: boolean): {
+    isMinimized: boolean;
+    expand: () => void;
+};

package/dist/types/auth/PasswordChecklist.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {object} props
+ * @param {string} props.password lo que lleva escrito la persona
+ * @param {object} [props.policy] las reglas; por omisión DEFAULT_PASSWORD_POLICY
+ * @param {string} [props.id]
+ */
+export default function PasswordChecklist({ password, policy, id }: {
+    password: string;
+    policy?: object;
+    id?: string;
+}): import("react").JSX.Element;

package/dist/types/auth/passwordRules.d.ts

@@ -0,0 +1,34 @@
+/** Las reglas que se pueden pedir. */
+export declare const PASSWORD_RULE: Readonly<{
+    minLength: "minLength";
+    lowercase: "lowercase";
+    uppercase: "uppercase";
+    number: "number";
+    symbol: "symbol";
+}>;
+/** La política por omisión: 12 caracteres, con minúscula, mayúscula y número. */
+export declare const DEFAULT_PASSWORD_POLICY: Readonly<{
+    minLength: 12;
+    lowercase: true;
+    uppercase: true;
+    number: true;
+    symbol: false;
+}>;
+/**
+ * Cada regla que pide la política, con si ya se cumple: es la lista que se pinta palomeada.
+ *
+ * @param {string} password lo que lleva escrito la persona
+ * @param {object} [policy] por omisión DEFAULT_PASSWORD_POLICY
+ * @returns {Array<{rule: string, isMet: boolean, values: object}>} en el orden de PASSWORD_RULE
+ */
+export declare function passwordChecksOf(password: string, policy?: object): Array<{
+    rule: string;
+    isMet: boolean;
+    values: object;
+}>;
+/**
+ * @param {string} password
+ * @param {object} [policy]
+ * @returns {boolean} si cumple todas las reglas de la política
+ */
+export declare function isPasswordAccepted(password: string, policy?: object): boolean;

package/dist/types/calendar/EventCalendar.d.ts

@@ -0,0 +1,46 @@
+/** Las vistas del calendario (los nombres de FullCalendar). */
+export declare const CALENDAR_VIEW: Readonly<{
+    month: "dayGridMonth";
+    week: "timeGridWeek";
+    day: "timeGridDay";
+    list: "listWeek";
+}>;
+/**
+ * @param {object} props
+ * @param {Array<{id: string, title: string, start: string, end?: string, allDay?: boolean, tone?: string}>} props.events
+ *     start y end como texto ISO; tone: un color del tema (por omisión primary)
+ * @param {string} [props.initialView] una de CALENDAR_VIEW
+ * @param {string[]} [props.views] las que se ofrecen en el control segmentado
+ * @param {(eventId: string) => void} [props.onEventClick]
+ * @param {(range: {start: string, end: string, allDay: boolean}) => void} [props.onDateSelect] al elegir días u horas
+ * @param {(change: {id: string, start: string, end: string|null, allDay: boolean}) => Promise<unknown>|void} [props.onEventChange]
+ *     al arrastrar un evento; si truena, el evento regresa
+ * @param {number|'auto'} [props.height]
+ * @param {string} props.ariaLabel ya traducido
+ */
+export default function EventCalendar({ events, initialView, views, onEventClick, onDateSelect, onEventChange, height, ariaLabel, }: {
+    events: Array<{
+        id: string;
+        title: string;
+        start: string;
+        end?: string;
+        allDay?: boolean;
+        tone?: string;
+    }>;
+    initialView?: string;
+    views?: string[];
+    onEventClick?: (eventId: string) => void;
+    onDateSelect?: (range: {
+        start: string;
+        end: string;
+        allDay: boolean;
+    }) => void;
+    onEventChange?: (change: {
+        id: string;
+        start: string;
+        end: string | null;
+        allDay: boolean;
+    }) => Promise<unknown> | void;
+    height?: number | 'auto';
+    ariaLabel: string;
+}): import("react").JSX.Element;

package/dist/types/calendar.d.ts

@@ -0,0 +1 @@
+export { CALENDAR_VIEW, default as EventCalendar } from './calendar/EventCalendar.js';

package/dist/types/charts.d.ts

@@ -0,0 +1,2 @@
+export { default as BarList } from './ui/metrics/BarList.js';
+export { default as ColumnChart } from './ui/metrics/ColumnChart.js';

package/dist/types/date-pickers.d.ts

@@ -0,0 +1,2 @@
+export { CALENDAR_DATE_FORMAT, default as DateInput } from './datePickers/DateInput.js';
+export { default as FormDateField } from './datePickers/FormDateField.js';

package/dist/types/datePickers/DateInput.d.ts

@@ -0,0 +1,39 @@
+import 'dayjs/locale/es';
+/** Cómo viaja una fecha de calendario. */
+export declare const CALENDAR_DATE_FORMAT = "YYYY-MM-DD";
+/**
+ * @param {object} props
+ * @param {string} [props.name]
+ * @param {string} props.label ya traducido
+ * @param {string|null|undefined} props.value 'AAAA-MM-DD' o ''
+ * @param {(value: string) => void} props.onChange recibe 'AAAA-MM-DD' ('' al borrar o con una fecha a medias)
+ * @param {() => void} [props.onBlur]
+ * @param {string|{key: string, values?: object}} [props.error]
+ * @param {string} [props.helperText]
+ * @param {string} [props.minDate] 'AAAA-MM-DD'
+ * @param {string} [props.maxDate] 'AAAA-MM-DD'
+ * @param {boolean} [props.disableFuture] p. ej. una fecha de nacimiento
+ * @param {boolean} [props.disablePast] p. ej. una cita
+ * @param {'day'|'month'|'year'} [props.openTo] por dónde abre el calendario (year para un nacimiento)
+ * @param {boolean} [props.disabled]
+ * @param {import('react').Ref<HTMLInputElement>} [props.inputRef]
+ */
+export default function DateInput({ name, label, value, onChange, onBlur, error, helperText, minDate, maxDate, disableFuture, disablePast, openTo, disabled, inputRef, }: {
+    name?: string;
+    label: string;
+    value: string | null | undefined;
+    onChange: (value: string) => void;
+    onBlur?: () => void;
+    error?: string | {
+        key: string;
+        values?: object;
+    };
+    helperText?: string;
+    minDate?: string;
+    maxDate?: string;
+    disableFuture?: boolean;
+    disablePast?: boolean;
+    openTo?: 'day' | 'month' | 'year';
+    disabled?: boolean;
+    inputRef?: import('react').Ref<HTMLInputElement>;
+}): import("react").JSX.Element;

package/dist/types/datePickers/FormDateField.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('./DateInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de
+ *     DateInput (minDate, maxDate, disableFuture, openTo…), sin value / onChange / onBlur / error
+ */
+export default function FormDateField({ name, ...dateInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('./DateInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/dates.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Un instante (ISO con desfase, milisegundos o Date) como Date válido.
+ *
+ * @param {string|Date|number|null|undefined} value
+ * @returns {Date|null} null si no hay dato o no es una fecha válida
+ */
+export declare function parseInstant(value: string | Date | number | null | undefined): Date | null;
+/**
+ * Una fecha de calendario ("2026-08-16") en sus partes, sin moverla de zona.
+ *
+ * @param {string|null|undefined} value
+ * @returns {{year: number, month: number, day: number}|null} null si no tiene la forma o no existe (2026-02-31)
+ */
+export declare function parsePlainDate(value: string | null | undefined): {
+    year: number;
+    month: number;
+    day: number;
+} | null;

package/dist/types/dictionaries/dictionaries.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Una entrada de diccionario, congelada.
+ *
+ * @param {string} value el código del API
+ * @param {string} keyPrefix dónde viven sus textos dentro del namespace dictionaries ('orderStatus.paid' → orderStatus.paid.label)
+ * @param {string} color color de paleta de MUI
+ * @param {{hasShortLabel?: boolean}} [options] hasShortLabel: trae palabra corta (keyPrefix.shortLabel)
+ * @returns {{value: string, labelKey: string, tooltipKey: string, shortLabelKey?: string, color: string, isKnown: boolean}}
+ */
+export declare function dictionaryEntryOf(value: string, keyPrefix: string, color: string, { hasShortLabel }?: {
+    hasShortLabel?: boolean;
+}): {
+    value: string;
+    labelKey: string;
+    tooltipKey: string;
+    shortLabelKey?: string;
+    color: string;
+    isKnown: boolean;
+};
+/**
+ * La entrada del diccionario para un valor del API.
+ *
+ * @param {Record<string, object>} dictionary p. ej. ORDER_STATUS
+ * @param {string|null|undefined} value código del API
+ * @returns {{value: string|null, labelKey: string, tooltipKey: string, color: string, isKnown: boolean}}
+ */
+export declare function lookup(dictionary: Record<string, object>, value: string | null | undefined): {
+    value: string | null;
+    labelKey: string;
+    tooltipKey: string;
+    color: string;
+    isKnown: boolean;
+};
+/**
+ * Texto que se pinta para una entrada: su etiqueta traducida o, si el valor no está en el diccionario, el código
+ * crudo. Un estatus nuevo se lee con su código y no como "Sin estatus".
+ *
+ * @param {{value: string|null, labelKey: string, isKnown: boolean}} dictionaryEntry lo que regresa lookup
+ * @param {(key: string) => string} translate el t de useToolkitTranslation
+ * @returns {string}
+ */
+export declare function labelOf(dictionaryEntry: {
+    value: string | null;
+    labelKey: string;
+    isKnown: boolean;
+}, translate: (key: string) => string): string;
+/**
+ * La palabra corta de una entrada, para una columna angosta. Una entrada sin palabra corta regresa su etiqueta de siempre.
+ *
+ * @param {object} dictionaryEntry entrada del diccionario (lookup)
+ * @param {Function} translate traductor
+ * @returns {string}
+ */
+export declare function shortLabelOf(dictionaryEntry: object, translate: Function): string;

package/dist/types/downloads/DownloadManager.d.ts

@@ -0,0 +1 @@
+export default function DownloadManager(): import("react").JSX.Element;

package/dist/types/downloads/downloadQueue.d.ts

@@ -0,0 +1,45 @@
+export declare const downloadsActor: import("xstate").Actor<import("xstate").StateMachine<import("xstate").MachineContext, import("xstate").AnyEventObject, {}, never, never, never, never, {}, string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "downloads";
+}, import("xstate").MetaObject>>;
+/**
+ * Descarga un archivo con avance en el panel, lo guarda en disco y avisa al terminar.
+ *
+ * @param {object} options
+ * @param {string} options.label ya traducido; lo que se ve en el panel mientras todavía no se sabe el nombre del
+ *     archivo
+ * @param {'xlsx'|'csv'|'pdf'} [options.format] para el ícono del tipo de archivo en el panel
+ * @param {(transferOptions: {signal: AbortSignal, onDownloadProgress: (progress: {loaded: number, total?: number|null}) => void}) => Promise<{blob: Blob, fileName: string}>} options.request
+ * @param {(fileName: string) => void} [options.onCompleted] p. ej. volver a pedir la tabla (si la descarga cambia algo
+ *     en el servidor)
+ * @returns {Promise<string>} id de la descarga; la promesa se cumple cuando termina (bien, mal o cancelada), nunca falla
+ */
+export declare function startDownload({ label, format, request, onCompleted }: {
+    label: string;
+    format?: 'xlsx' | 'csv' | 'pdf';
+    request: (transferOptions: {
+        signal: AbortSignal;
+        onDownloadProgress: (progress: {
+            loaded: number;
+            total?: number | null;
+        }) => void;
+    }) => Promise<{
+        blob: Blob;
+        fileName: string;
+    }>;
+    onCompleted?: (fileName: string) => void;
+}): Promise<string>;
+/**
+ * Cancela una descarga en curso (el panel la marca como cancelada).
+ *
+ * @param {string} downloadId
+ */
+export declare function cancelDownload(downloadId: string): void;
+/** Quita del panel todas las descargas terminadas (completadas, fallidas o canceladas). */
+export declare function clearFinishedDownloads(): void;
+/**
+ * ¿Cuántas siguen descargando? Decide el resumen del panel y si se puede cerrar.
+ *
+ * @param {Array<object>} downloads
+ * @returns {number}
+ */
+export declare function countActiveDownloads(downloads: Array<object>): number;

package/dist/types/downloads/downloadsMachine.d.ts

@@ -0,0 +1,10 @@
+/** Estatus de una descarga; son los que pinta el panel (con su texto en common:downloads.statuses). */
+export declare const DOWNLOAD_STATUS: Readonly<{
+    downloading: "downloading";
+    completed: "completed";
+    failed: "failed";
+    canceled: "canceled";
+}>;
+export declare const downloadsMachine: import("xstate").StateMachine<import("xstate").MachineContext, import("xstate").AnyEventObject, {}, never, never, never, never, {}, string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "downloads";
+}, import("xstate").MetaObject>;

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

@@ -0,0 +1,3 @@
+export { default as DownloadManager } from './DownloadManager.js';
+export { cancelDownload, clearFinishedDownloads, startDownload } from './downloadQueue.js';
+export { DOWNLOAD_STATUS, downloadsMachine } from './downloadsMachine.js';

package/dist/types/excel/reportWorkbook.d.ts

@@ -0,0 +1,157 @@
+/** Cómo se escribe cada cifra: conteo con miles, dinero con dos decimales o porcentaje. */
+export declare const VALUE_FORMAT: Readonly<{
+    count: "count";
+    money: "money";
+    percent: "percent";
+}>;
+/** Los dos tipos de renglón de la hoja: el título de una sección y un concepto con sus cifras. */
+export declare const SHEET_ROW_KIND: Readonly<{
+    section: "section";
+    figures: "figures";
+}>;
+/**
+ * Cómo se ve el Excel, como un reporte: título arriba, encabezado del color principal con letra blanca, secciones con su
+ * fondo, bordes delgados en toda la tabla y los Totales con su fondo. Los colores van en ARGB, como los pide Excel; por
+ * omisión, los del tema por omisión de MUI (primary #1976d2, blue[50], grey).
+ */
+export declare const DEFAULT_REPORT_STYLE: Readonly<{
+    brandColor: "FF1976D2";
+    headerFontColor: "FFFFFFFF";
+    sectionFill: "FFF5F5F5";
+    totalsFill: "FFE3F2FD";
+    borderColor: "FFE0E0E0";
+    sectionBorderColor: "FF9E9E9E";
+    secondaryFontColor: "FF757575";
+    titleFontSize: 14;
+    secondaryFontSize: 9;
+    headerRowHeight: 30;
+    headerLineCount: 2;
+    headerWidthMargin: 4;
+    conceptColumnWidth: 36;
+    howColumnWidth: 22;
+    figureColumnWidth: 20;
+    conceptIndent: 1;
+    conceptCharactersPerLine: 33;
+    lineHeightPoints: 15;
+    numberFormats: Readonly<{
+        count: "#,##0";
+        money: "\"$\"#,##0.00";
+        percent: "0%";
+    }>;
+}>;
+/**
+ * Un color CSS de seis cifras (#017f31) como lo pide Excel (FF017F31). Sirve para pasar el color del tema de MUI a `style`.
+ *
+ * @param {string} cssColor #rrggbb
+ * @returns {string} ARGB
+ */
+export declare function excelColorOf(cssColor: string): string;
+/**
+ * Un nombre como pedazo del nombre de un archivo: sin acentos, en minúsculas y con guiones («Plan Básico» →
+ * plan-basico).
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+export declare function fileNameSlugOf(name: string): string;
+/**
+ * La hoja del reporte: el encabezado y los renglones con sus textos, en el orden de la pantalla.
+ *
+ * @param {object} report
+ * @param {string} report.conceptLabel título de la primera columna («Concepto»)
+ * @param {string} [report.howColumnLabel] título de la columna que explica cómo sale cada total («Cómo salen los
+ *     totales»); sin él no va esa columna
+ * @param {string[]} report.periodLabels un título por periodo, en orden
+ * @param {string} [report.totalsLabel] título de la columna de los Totales; sin él no va (y los renglones no traen su
+ *     total)
+ * @param {Object[]} report.sections las secciones en orden, cada una con sus renglones
+ * @param {string} report.sections[].label
+ * @param {Array<{label: string, howLabel?: string, format: string, isTotal?: boolean, values: Array<number|string|null>}>} report.sections[].rows
+ *     values: una cifra por periodo y, si hay totalsLabel, al final la del total
+ * @param {{section: string, period: string}} report.dataLabels lo que dice la primera columna de los Datos
+ * @returns {{header: string[], dataHeaderLabels: {section: string, concept: string, period: string}, periods: string[], rows: Array<object>, hasHowColumn: boolean, hasTotals: boolean}}
+ */
+export declare function reportSheetOf({ conceptLabel, howColumnLabel, periodLabels, totalsLabel, sections, dataLabels }: {
+    conceptLabel: string;
+    howColumnLabel?: string;
+    periodLabels: string[];
+    totalsLabel?: string;
+    sections: {
+        label: string;
+        rows: Array<{
+            label: string;
+            howLabel?: string;
+            format: string;
+            isTotal?: boolean;
+            values: Array<number | string | null>;
+        }>;
+    }[];
+    dataLabels: {
+        section: string;
+        period: string;
+    };
+}): {
+    header: string[];
+    dataHeaderLabels: {
+        section: string;
+        concept: string;
+        period: string;
+    };
+    periods: string[];
+    rows: Array<object>;
+    hasHowColumn: boolean;
+    hasTotals: boolean;
+};
+/**
+ * La tabla volteada de los Datos: un renglón por periodo y una columna por concepto.
+ *
+ * @param {{periods: string[], rows: Array<object>, hasTotals: boolean}} sheet de reportSheetOf
+ * @returns {{concepts: Array<object>, periodRows: Array<{period: string, isTotals: boolean, values: Array<number|string|null>}>}}
+ *          concepts: los renglones de cifras de la hoja, uno por columna (con su sección, nombre, cómo sale y formato)
+ */
+export declare function reportDataTableOf(sheet: {
+    periods: string[];
+    rows: Array<object>;
+    hasTotals: boolean;
+}): {
+    concepts: Array<object>;
+    periodRows: Array<{
+        period: string;
+        isTotals: boolean;
+        values: Array<number | string | null>;
+    }>;
+};
+/**
+ * El CSV de la hoja, igual que los Datos: sus renglones de encabezado y un renglón por periodo, con la marca de UTF-8 al
+ * principio. La sección va en cada columna de su concepto: el CSV no une celdas.
+ *
+ * @param {object} sheet de reportSheetOf
+ * @returns {string}
+ */
+export declare function reportCsvOf(sheet: object): string;
+/**
+ * El libro de Excel con sus dos hojas:
+ *   Resumen  a lo ancho, con formato de reporte: el título, el encabezado del color principal, las secciones con su
+ *            fondo, cada cifra con su formato (conteo, dinero, porcentaje), bordes, los Totales con su fondo y Concepto
+ *            (y Cómo sale, si va) y el encabezado fijos. Se imprime acostado y ajustado al ancho, con el encabezado en
+ *            cada hoja.
+ *   Datos    hacia abajo, con los filtros de Excel en el encabezado (ahí sí sirven: por sección, concepto o periodo).
+ *
+ * @param {object} ExcelJS el paquete exceljs ya cargado
+ * @param {object} sheet de reportSheetOf
+ * @param {{summarySheetName: string, dataSheetName: string, title: string, subtitle?: string, style?: object}} texts
+ *        los nombres de las dos hojas, lo que va arriba del Resumen y, si se quiere, lo que cambia de DEFAULT_REPORT_STYLE
+ * @returns {{xlsx: {writeBuffer: () => Promise<ArrayBuffer>}} & Record<string, any>} el libro (ExcelJS.Workbook); se escribe
+ *     con workbook.xlsx.writeBuffer(). Tipo propio y no el de ExcelJS: el paquete no depende de sus tipos
+ */
+export declare function reportWorkbookOf(ExcelJS: object, sheet: object, { summarySheetName, dataSheetName, title, subtitle, style: customStyle }: {
+    summarySheetName: string;
+    dataSheetName: string;
+    title: string;
+    subtitle?: string;
+    style?: object;
+}): {
+    xlsx: {
+        writeBuffer: () => Promise<ArrayBuffer>;
+    };
+} & Record<string, any>;

package/dist/types/excel.d.ts

@@ -0,0 +1 @@
+export { DEFAULT_REPORT_STYLE, SHEET_ROW_KIND, VALUE_FORMAT, excelColorOf, fileNameSlugOf, reportCsvOf, reportDataTableOf, reportSheetOf, reportWorkbookOf, } from './excel/reportWorkbook.js';

package/dist/types/feedback/ConfirmDialog.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @param {object} props
+ * @param {boolean} props.open
+ * @param {string} props.title texto ya traducido, con el renglón («¿Dar de baja a Ana López?»)
+ * @param {import('react').ReactNode} [props.description] qué va a pasar, en palabras normales
+ * @param {string} [props.confirmLabel]
+ * @param {string} [props.cancelLabel]
+ * @param {'primary'|'error'|'warning'} [props.tone]
+ * @param {boolean} [props.isPending]
+ * @param {boolean} [props.isConfirmDisabled] la acción ya no aplica (p. ej. conflicto: el registro cambió)
+ * @param {string|null} [props.errorMessage] mensaje ya traducido (ApiError.message)
+ * @param {() => void} props.onConfirm
+ * @param {() => void} props.onClose
+ * @param {import('react').ReactNode} [props.children]
+ */
+export default function ConfirmDialog({ open, title, description, confirmLabel, cancelLabel, tone, isPending, isConfirmDisabled, errorMessage, onConfirm, onClose, children, }: {
+    open: boolean;
+    title: string;
+    description?: import('react').ReactNode;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    tone?: 'primary' | 'error' | 'warning';
+    isPending?: boolean;
+    isConfirmDisabled?: boolean;
+    errorMessage?: string | null;
+    onConfirm: () => void;
+    onClose: () => void;
+    children?: import('react').ReactNode;
+}): import("react").JSX.Element;

package/dist/types/feedback/ModalWaiting.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {{open: boolean, title?: string, text?: string}} props textos ya traducidos; por defecto los de common:waiting
+ */
+export default function ModalWaiting({ open, title, text }: {
+    open: boolean;
+    title?: string;
+    text?: string;
+}): import("react").JSX.Element;

package/dist/types/feedback/NewBuildNotice.d.ts

@@ -0,0 +1,18 @@
+/** Las formas del aviso: franja (dentro de la barra del proyecto) o cápsula flotante (la del marco con vidrio). */
+export declare const NEW_BUILD_NOTICE_VARIANT: Readonly<{
+    ribbon: "ribbon";
+    floating: "floating";
+}>;
+/**
+ * @param {object} [props]
+ * @param {string} [props.message] ya traducido; por omisión el del paquete (en la cápsula, el corto: common:newBuild.short)
+ * @param {string} [props.reloadLabel] ya traducido; por omisión «Recargar»
+ * @param {() => void} [props.onReload] por omisión recarga la página
+ * @param {'ribbon'|'floating'} [props.variant] franja o cápsula flotante (NEW_BUILD_NOTICE_VARIANT); por omisión franja
+ */
+export default function NewBuildNotice({ message, reloadLabel, onReload, variant }?: {
+    message?: string;
+    reloadLabel?: string;
+    onReload?: () => void;
+    variant?: 'ribbon' | 'floating';
+}): import("react").JSX.Element | null;