@stackcraftmx/calcita 0.0.0-stage → 0.25.0

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

@@ -0,0 +1,36 @@
+/** Las respuestas de un invitado. */
+export declare const ATTENDEE_RESPONSE: Readonly<{
+    accepted: "accepted";
+    declined: "declined";
+    pending: "pending";
+}>;
+/**
+ * @param {object} props
+ * @param {{title: string, start: string, end?: string|null, allDay?: boolean, tone?: string, location?: string, meetingUrl?: string, attendees?: Array<{id: string, name: string, email?: string, response?: 'accepted'|'declined'|'pending'}>, reminderMinutes?: number|null, description?: string}} props.event
+ *     start y end como texto ISO (o AAAA-MM-DD un día completo); tone: el color de su tipo
+ * @param {import('react').ReactNode} [props.actions] botones de la pantalla (editar, borrar, responder…)
+ * @param {string} [props.titleId] el id del título: la ventana que lo contiene se nombra con él (aria-labelledby)
+ * @param {object} [props.texts] los textos que cambian, con la forma de `calendar` en los textos del paquete
+ */
+export default function EventDetails({ event, actions, titleId, texts }: {
+    event: {
+        title: string;
+        start: string;
+        end?: string | null;
+        allDay?: boolean;
+        tone?: string;
+        location?: string;
+        meetingUrl?: string;
+        attendees?: Array<{
+            id: string;
+            name: string;
+            email?: string;
+            response?: 'accepted' | 'declined' | 'pending';
+        }>;
+        reminderMinutes?: number | null;
+        description?: string;
+    };
+    actions?: import('react').ReactNode;
+    titleId?: string;
+    texts?: object;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,27 @@
+/** La unidad del recordatorio (la llave de su texto: calendar.reminder.<unidad>). */
+export declare const REMINDER_UNIT: Readonly<{
+    none: "none";
+    atStart: "atStart";
+    minutes: "minutes";
+    hours: "hours";
+    days: "days";
+}>;
+/**
+ * Cómo se dice un recordatorio: «sin recordatorio», «al empezar», «15 minutos antes», «2 horas antes», «1 día antes». Usa la
+ * unidad más grande que lo dice exacto (90 minutos se quedan en minutos).
+ *
+ * @param {number|null|undefined} minutes cuántos minutos antes; null sin recordatorio
+ * @returns {{unit: string, count: number}}
+ */
+export declare function reminderOf(minutes: number | null | undefined): {
+    unit: string;
+    count: number;
+};
+/**
+ * ¿La liga de reunión se puede abrir? Solo http y https: una liga «javascript:» o con otro esquema no se ofrece para abrir
+ * (la pinta quien la escribió, pero nadie le da clic a algo raro desde la app).
+ *
+ * @param {string|null|undefined} url
+ * @returns {boolean}
+ */
+export declare function isOpenableMeetingUrl(url: string | null | undefined): boolean;

package/dist/types/calendar.d.ts

@@ -0,0 +1,3 @@
+export { CALENDAR_VIEW, default as EventCalendar } from './calendar/EventCalendar.js';
+export { ATTENDEE_RESPONSE, default as EventDetails } from './calendar/EventDetails.js';
+export { REMINDER_UNIT, isOpenableMeetingUrl, reminderOf } from './calendar/calendarEvents.js';

package/dist/types/charts.d.ts

@@ -0,0 +1,6 @@
+export { default as BarList } from './ui/metrics/BarList.js';
+export { default as ColumnChart } from './ui/metrics/ColumnChart.js';
+export { default as LineChart } from './ui/metrics/LineChart.js';
+export { default as ChartTooltip } from './ui/metrics/ChartTooltip.js';
+export { CHART_LINE_DASHES, CHART_SERIES_TONES } from './ui/metrics/chartParts.js';
+export { CHART_VIEW } from './ui/metrics/TableToggle.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,41 @@
+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]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function DateInput({ name, label, value, onChange, onBlur, error, helperText, minDate, maxDate, disableFuture, disablePast, openTo, disabled, inputRef, texts, }: {
+    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>;
+    texts?: object;
+}): 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,7 @@
+/**
+ * @param {object} [props]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function DownloadManager({ texts }?: {
+    texts?: object;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,50 @@
+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 {string} [options.format] el tipo de archivo, para su ícono en el panel: xlsx, csv, pdf o uno del proyecto
+ *     (ToolkitProvider fileTypes)
+ * @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)
+ * @param {(error: unknown) => void} [options.onFailed] cuando no se pudo (el panel ya lo dice; para avisar o reportarlo)
+ * @param {() => void} [options.onCanceled] cuando la persona la canceló
+ * @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, onFailed, onCanceled }: {
+    label: string;
+    format?: string;
+    request: (transferOptions: {
+        signal: AbortSignal;
+        onDownloadProgress: (progress: {
+            loaded: number;
+            total?: number | null;
+        }) => void;
+    }) => Promise<{
+        blob: Blob;
+        fileName: string;
+    }>;
+    onCompleted?: (fileName: string) => void;
+    onFailed?: (error: unknown) => void;
+    onCanceled?: () => 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/fileTypes.d.ts

@@ -0,0 +1,39 @@
+/** Los tipos de la casa: su ícono y su color (de la paleta del tema, claro y oscuro). */
+export declare const DEFAULT_FILE_TYPES: Readonly<{
+    xlsx: Readonly<{
+        Icon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material/SvgIcon").SvgIconTypeMap<{}, "svg">> & {
+            muiName: string;
+        };
+        color: "success.main";
+    }>;
+    csv: Readonly<{
+        Icon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material/SvgIcon").SvgIconTypeMap<{}, "svg">> & {
+            muiName: string;
+        };
+        color: "info.main";
+    }>;
+    pdf: Readonly<{
+        Icon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material/SvgIcon").SvgIconTypeMap<{}, "svg">> & {
+            muiName: string;
+        };
+        color: "error.main";
+    }>;
+}>;
+/** Un tipo que nadie declaró: el ícono de archivo y el gris del texto. */
+export declare const UNKNOWN_FILE_TYPE: Readonly<{
+    Icon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material/SvgIcon").SvgIconTypeMap<{}, "svg">> & {
+        muiName: string;
+    };
+    color: "text.secondary";
+}>;
+/**
+ * Los tipos que conoce esta app: los de la casa y los del proyecto (el del proyecto gana si se llama igual).
+ *
+ * @returns {Record<string, {Icon: import('react').ElementType, color: string, label?: string, hint?: string}>}
+ */
+export declare function useFileTypes(): Record<string, {
+    Icon: import('react').ElementType;
+    color: string;
+    label?: string;
+    hint?: string;
+}>;

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

@@ -0,0 +1,4 @@
+export { default as DownloadManager } from './DownloadManager.js';
+export { cancelDownload, clearFinishedDownloads, startDownload } from './downloadQueue.js';
+export { DEFAULT_FILE_TYPES, UNKNOWN_FILE_TYPE, useFileTypes } from './fileTypes.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,31 @@
+/**
+ * @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]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function ConfirmDialog({ open, title, description, confirmLabel, cancelLabel, tone, isPending, isConfirmDisabled, errorMessage, onConfirm, onClose, children, texts, }: {
+    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;
+    texts?: object;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,13 @@
+/**
+ * @param {object} props
+ * @param {boolean} props.open
+ * @param {string} [props.title] ya traducido; por omisión common:waiting.title
+ * @param {string} [props.text] ya traducido; por omisión common:waiting.text
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function ModalWaiting({ open, title, text, texts }: {
+    open: boolean;
+    title?: string;
+    text?: string;
+    texts?: object;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,20 @@
+/** 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
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function NewBuildNotice({ message, reloadLabel, onReload, variant, texts }?: {
+    message?: string;
+    reloadLabel?: string;
+    onReload?: () => void;
+    variant?: 'ribbon' | 'floating';
+    texts?: object;
+}): import("react").JSX.Element | null;

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

@@ -0,0 +1,21 @@
+import { Component } from 'react';
+/**
+ * @extends {Component<{resetKey?: string, homePath?: string, children?: import('react').ReactNode}, {error: unknown}>}
+ */
+export default class StaleBuildBoundary extends Component<{
+    resetKey?: string;
+    homePath?: string;
+    children?: import('react').ReactNode;
+}, {
+    error: unknown;
+}> {
+    state: {
+        error: null;
+    };
+    static getDerivedStateFromError(error: any): {
+        error: any;
+    };
+    componentDidCatch(error: any): void;
+    componentDidUpdate(previousProps: any): void;
+    render(): 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/feedback/Toaster.d.ts

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

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

@@ -0,0 +1,19 @@
+export declare const confirmActionMachine: import("xstate").StateMachine<import("xstate").MachineContext, import("xstate").AnyEventObject, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<never, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+}, {
+    src: "runAction";
+    logic: import("xstate").PromiseActorLogic<never, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+}, {
+    type: "onDone";
+    params: unknown;
+}, never, never, "confirming" | "done" | "failed" | "idle" | "running", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "confirmAction";
+    states: {
+        readonly idle: {};
+        readonly confirming: {};
+        readonly running: {};
+        readonly done: {};
+        readonly failed: {};
+    };
+}, import("xstate").MetaObject>;

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

@@ -0,0 +1,8 @@
+export { default as ConfirmDialog } from './ConfirmDialog.js';
+export { default as ModalWaiting } from './ModalWaiting.js';
+export { NEW_BUILD_NOTICE_VARIANT, default as NewBuildNotice } from './NewBuildNotice.js';
+export { default as StaleBuildBoundary } from './StaleBuildBoundary.js';
+export { default as Toaster } from './Toaster.js';
+export { confirmActionMachine } from './confirmActionMachine.js';
+export { TOAST_DEFAULT_OPTIONS, dismissToast, errorsObjectToMessage, toastDefault, toastError, toastInfo, toastLoading, toastProblem, toastPromise, toastSuccess, toastWarn, } from './toast.js';
+export { useConfirmAction } from './useConfirmAction.js';