@stackcraftmx/calcita 0.0.0-stage → 0.23.0

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';

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

@@ -0,0 +1,100 @@
+export declare const TOAST_DEFAULT_OPTIONS: Readonly<{
+    duration: 5000;
+    closeButton: true;
+    dismissible: true;
+}>;
+/**
+ * Aviso de que algo salió bien.
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; con saltos de línea, un renglón cada uno; por omisión «Listo» (common:toast.done)
+ * @param {import('sonner').ExternalToast} [options] las de sonner (duración, acción…), encima de TOAST_DEFAULT_OPTIONS
+ * @returns {string|number} el id del aviso (para cerrarlo con dismissToast)
+ */
+export declare function toastSuccess(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Aviso de error.
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; con saltos de línea, un renglón cada uno; por omisión el error genérico (common:toast.error)
+ * @param {import('sonner').ExternalToast} [options] las de sonner (duración, acción…), encima de TOAST_DEFAULT_OPTIONS
+ * @returns {string|number} el id del aviso (para cerrarlo con dismissToast)
+ */
+export declare function toastError(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Aviso de advertencia.
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; con saltos de línea, un renglón cada uno; por omisión la advertencia genérica (common:toast.warning)
+ * @param {import('sonner').ExternalToast} [options] las de sonner (duración, acción…), encima de TOAST_DEFAULT_OPTIONS
+ * @returns {string|number} el id del aviso (para cerrarlo con dismissToast)
+ */
+export declare function toastWarn(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Aviso informativo.
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; con saltos de línea, un renglón cada uno; por omisión el aviso genérico (common:toast.info)
+ * @param {import('sonner').ExternalToast} [options] las de sonner (duración, acción…), encima de TOAST_DEFAULT_OPTIONS
+ * @returns {string|number} el id del aviso (para cerrarlo con dismissToast)
+ */
+export declare function toastInfo(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Aviso sin tipo (sin ícono ni color).
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; con saltos de línea, un renglón cada uno
+ * @param {import('sonner').ExternalToast} [options] las de sonner (duración, acción…), encima de TOAST_DEFAULT_OPTIONS
+ * @returns {string|number} el id del aviso (para cerrarlo con dismissToast)
+ */
+export declare function toastDefault(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Aviso que NO se cierra solo. Regresa el id para cerrarlo al terminar.
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; por omisión «Trabajando…» (common:toast.working)
+ * @param {import('sonner').ExternalToast} [options]
+ * @returns {string|number} el id del aviso (para dismissToast)
+ */
+export declare function toastLoading(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Envuelve una promesa: cargando → listo | error, solo.
+ *
+ * @template T
+ * @param {Promise<T>} promise
+ * @param {object} messages ya traducidos
+ * @param {import('react').ReactNode} messages.loading
+ * @param {import('react').ReactNode | ((data: T) => import('react').ReactNode)} messages.success
+ * @param {import('react').ReactNode | ((failure: unknown) => import('react').ReactNode)} messages.error
+ * @param {import('sonner').ExternalToast} [options]
+ */
+export declare function toastPromise<T>(promise: Promise<T>, { loading, success, error }: {
+    loading: import('react').ReactNode;
+    success: import('react').ReactNode | ((data: T) => import('react').ReactNode);
+    error: import('react').ReactNode | ((failure: unknown) => import('react').ReactNode);
+}, options?: import('sonner').ExternalToast): {
+    unwrap: () => Promise<T>;
+} | (string & {
+    unwrap: () => Promise<T>;
+}) | (number & {
+    unwrap: () => Promise<T>;
+});
+/**
+ * Cierra un aviso (el id que regresan las funciones de arriba); sin id, todos.
+ *
+ * @param {string|number} [toastId]
+ */
+export declare function dismissToast(toastId?: string | number): string | number;
+/**
+ * {email: ['Requerido', 'Inválido']} → "Requerido\nInválido".
+ *
+ * @param {Record<string, string[]|string>|null|undefined} errorsByField
+ * @param {{dedup?: boolean}} [options]
+ * @returns {string}
+ */
+export declare function errorsObjectToMessage(errorsByField: Record<string, string[] | string> | null | undefined, { dedup }?: {
+    dedup?: boolean;
+}): string;
+/**
+ * Aviso de error a partir de un ApiError: usa el detail traducido y, si es un 422, enumera los mensajes por campo.
+ *
+ * @param {Error & {problem?: object}} error
+ * @param {object} [options] opciones de sonner
+ */
+export declare function toastProblem(error: Error & {
+    problem?: object;
+}, options?: object): string | number;

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

@@ -0,0 +1,33 @@
+/**
+ * @param {object} options
+ * @param {(input: {subject: any, details: any}) => Promise<unknown>|void} options.run lo que se hace al confirmar (subject: lo que
+ *     se le pasó a open)
+ * @param {(output: any, subject: any) => void} [options.onDone] output: lo que regresó run
+ * @returns {{
+ *   subject: object|null, isOpen: boolean, isRunning: boolean, error: Error|null,
+ *   open: (subject: any) => void, confirm: (details?: any) => void, cancel: () => void,
+ *   dialogProps: {open: boolean, isPending: boolean, errorMessage: string|null, onConfirm: (details?: object) => void, onClose: () => void},
+ * }}
+ */
+export declare function useConfirmAction({ run, onDone }: {
+    run: (input: {
+        subject: any;
+        details: any;
+    }) => Promise<unknown> | void;
+    onDone?: (output: any, subject: any) => void;
+}): {
+    subject: object | null;
+    isOpen: boolean;
+    isRunning: boolean;
+    error: Error | null;
+    open: (subject: any) => void;
+    confirm: (details?: any) => void;
+    cancel: () => void;
+    dialogProps: {
+        open: boolean;
+        isPending: boolean;
+        errorMessage: string | null;
+        onConfirm: (details?: object) => void;
+        onClose: () => void;
+    };
+};

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

@@ -0,0 +1,59 @@
+/**
+ * @param {object} props
+ * @param {File|File[]|null} [props.value]
+ * @param {(value: File|File[]|null) => void} props.onChange
+ * @param {string|string[]} [props.accept]
+ * @param {number|string} [props.maxSize] por archivo
+ * @param {boolean} [props.multiple]
+ * @param {number} [props.maxFiles]
+ * @param {number|string} [props.maxTotalSize]
+ * @param {string} [props.name] nombre del campo; por omisión uno propio por zona (dos zonas no se pisan)
+ * @param {string} [props.hint]
+ * @param {string} [props.buttonLabel]
+ * @param {boolean} [props.disabled]
+ * @param {boolean} [props.busy]
+ * @param {boolean|{title?: string, text?: string}} [props.busyModal]
+ * @param {boolean} [props.autoReject]
+ * @param {((file: File) => Promise<true|string>)|null} [props.validate]
+ * @param {object|null} [props.server] createPondServer(...) o {process} propio
+ * @param {boolean} [props.instantUpload]
+ * @param {{current: object|null}|null} [props.apiRef]
+ * @param {(progress: {done: number, total: number}) => void} [props.onProcessProgress]
+ * @param {(file: File|null, reason: string, message?: string) => void} [props.onReject] reason de FILE_REJECTION
+ * @param {import('react').ReactNode} [props.actions]
+ * @param {import('react').ReactNode} [props.children]
+ * @param {object} [props.sx]
+ */
+export default function FileDropzone({ value, onChange, accept, maxSize, multiple, maxFiles, maxTotalSize, name, hint, buttonLabel, disabled, busy, busyModal, autoReject, validate, server, instantUpload, apiRef, onProcessProgress, onReject, actions, children, sx, }: {
+    value?: File | File[] | null;
+    onChange: (value: File | File[] | null) => void;
+    accept?: string | string[];
+    maxSize?: number | string;
+    multiple?: boolean;
+    maxFiles?: number;
+    maxTotalSize?: number | string;
+    name?: string;
+    hint?: string;
+    buttonLabel?: string;
+    disabled?: boolean;
+    busy?: boolean;
+    busyModal?: boolean | {
+        title?: string;
+        text?: string;
+    };
+    autoReject?: boolean;
+    validate?: ((file: File) => Promise<true | string>) | null;
+    server?: object | null;
+    instantUpload?: boolean;
+    apiRef?: {
+        current: object | null;
+    } | null;
+    onProcessProgress?: (progress: {
+        done: number;
+        total: number;
+    }) => void;
+    onReject?: (file: File | null, reason: string, message?: string) => void;
+    actions?: import('react').ReactNode;
+    children?: import('react').ReactNode;
+    sx?: object;
+}): import("react").JSX.Element;

package/dist/types/filepond/pondServer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {object} options
+ * @param {string} options.url a dónde va cada archivo
+ * @param {string} [options.fieldName] el campo del archivo en el FormData; por omisión el name de la zona
+ * @param {Record<string, string>} [options.headers] p. ej. Authorization
+ * @param {boolean} [options.withCredentials] manda las cookies a otro dominio
+ * @returns {{process: (...args: any[]) => any, revert: (...args: any[]) => any}} lo que recibe la prop server de FileDropzone
+ */
+export declare function createPondServer({ url, fieldName, headers, withCredentials }: {
+    url: string;
+    fieldName?: string;
+    headers?: Record<string, string>;
+    withCredentials?: boolean;
+}): {
+    process: (...args: any[]) => any;
+    revert: (...args: any[]) => any;
+};

package/dist/types/filepond.d.ts

@@ -0,0 +1,3 @@
+export { default as FileDropzone } from './filepond/FileDropzone.js';
+export { createPondServer } from './filepond/pondServer.js';
+export { FILE_ACCEPT_PRESETS, FILE_REJECTION } from './upload/fileRules.js';

package/dist/types/files.d.ts

@@ -0,0 +1,29 @@
+/** Tipo de contenido de un Excel (XLSX): el mismo que manda el servidor (IngestionDictionary::XLSX_CONTENT_TYPE). */
+export declare const XLSX_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+/**
+ * Nombre de archivo del header Content-Disposition. Prefiere filename*=UTF-8'' (acentos) sobre filename=.
+ *
+ * @param {string|null|undefined} contentDisposition
+ * @param {string} fallbackFileName si el header no trae nombre
+ */
+export declare function fileNameFromContentDisposition(contentDisposition: string | null | undefined, fallbackFileName: string): string;
+/**
+ * Dispara la descarga de un Blob con el nombre dado.
+ *
+ * @param {Blob} blob
+ * @param {string} fileName
+ */
+export declare function saveBlob(blob: Blob, fileName: string): void;
+/**
+ * ¿Llegó completo el zip (un XLSX)? Sí, si termina con su registro de cierre.
+ *
+ * Por qué hace falta: el servidor manda los Excel por partes y con 200 desde el primer pedazo. Si algo falla a media
+ * escritura (p. ej. llegan más renglones de los que se contaron), ya no puede cambiar la respuesta a un error: el archivo
+ * llega cortado y Excel no lo abre. Esta revisión es lo que evita guardarlo como si estuviera bien.
+ *
+ * OJO: supone un zip sin comentario, como los que escribe el servidor (zipstream sin comentario).
+ *
+ * @param {Blob} blob el archivo descargado
+ * @returns {Promise<boolean>}
+ */
+export declare function isCompleteZip(blob: Blob): Promise<boolean>;

package/dist/types/formatting.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Número con separador de miles: 321,540.
+ *
+ * @param {number|string|null|undefined} value
+ * @param {string} [fallback] lo que se pinta si no hay dato
+ */
+export declare function formatNumber(value: number | string | null | undefined, fallback?: string): any;
+/**
+ * Una lista en una frase, con su «y» antes de la última parte: «resumen, motivos de rechazo y descargas».
+ *
+ * @param {string[]} items las partes de la lista, ya traducidas
+ * @returns {string} la frase; '' si la lista viene vacía
+ */
+export declare function formatList(items: string[]): string;
+/**
+ * Monto en la moneda del proveedor con dos decimales: $2,567,951.00. Recibe el texto que manda el API (numeric de la base) o un número;
+ * solo pinta, nunca suma (las sumas las hace el backend al centavo).
+ *
+ * @param {number|string|null|undefined} value
+ * @param {string} [fallback] lo que se pinta si no hay dato
+ */
+export declare function formatCurrency(value: number | string | null | undefined, fallback?: string): any;
+/**
+ * Tamaño de un archivo en la unidad que se lee mejor: 950 B, 12.4 kB, 60.1 MB, 2.3 GB.
+ *
+ * @param {number|null|undefined} bytes
+ * @param {string} [fallback] lo que se pinta si no hay dato
+ */
+export declare function formatFileSize(bytes: number | null | undefined, fallback?: string): any;
+/**
+ * Porcentaje a partir de una proporción o de un número ya en porcentaje.
+ *
+ * @param {number|null|undefined} value 99.58 (con isRatio false) o 0.9958 (con isRatio true)
+ * @param {{fractionDigits?: number, isRatio?: boolean, fallback?: string}} [options]
+ */
+export declare function formatPercent(value: number | null | undefined, { fractionDigits, isRatio, fallback }?: {
+    fractionDigits?: number;
+    isRatio?: boolean;
+    fallback?: string;
+}): any;
+/**
+ * Fecha y hora de un instante ISO en la zona del negocio.
+ *
+ * @param {string|null|undefined} value instante ISO con desfase
+ * @param {{fallback?: string}} [options]
+ */
+export declare function formatDateTime(value: string | null | undefined, { fallback }?: {
+    fallback?: string;
+}): any;
+/**
+ * Solo la fecha. Acepta un instante ISO (se pasa a la zona del negocio) o una fecha de calendario "2026-08-16"
+ * (se pinta tal cual, sin moverla de día).
+ *
+ * @param {string|null|undefined} value
+ * @param {{fallback?: string}} [options]
+ */
+export declare function formatDate(value: string | null | undefined, { fallback }?: {
+    fallback?: string;
+}): any;
+/**
+ * Solo la hora (24 h) de un instante ISO en la zona del negocio: "07:00".
+ *
+ * Existe aparte de formatDateTime porque las pantallas escriben "16 ago 2026 · 07:00" con punto medio, y Intl une
+ * fecha y hora con coma: se arma formatDate + formatTime.
+ *
+ * @param {string|null|undefined} value instante ISO con desfase
+ * @param {{fallback?: string}} [options]
+ */
+export declare function formatTime(value: string | null | undefined, { fallback }?: {
+    fallback?: string;
+}): any;
+/**
+ * Nombre de un mes de calendario: "agosto 2026" (long) o "ago 2026" (short).
+ *
+ * OJO: no se usa Intl con {month, year} juntos porque en español sale "agosto de 2026" y las pantallas dicen
+ * "agosto 2026"; se pide solo el mes y se pega el año.
+ *
+ * @param {number} year
+ * @param {number} month 1 a 12
+ * @param {{style?: 'long'|'short', capitalize?: boolean}} [options] capitalize: "Agosto 2026" (fila de mes)
+ */
+export declare function formatMonthName(year: number, month: number, { style, capitalize }?: {
+    style?: 'long' | 'short';
+    capitalize?: boolean;
+}): string;
+/**
+ * Nombre corto de un mes sin año: "ene", "feb" (rótulos de columnas de calendario y rejillas por periodo).
+ *
+ * @param {number} month 1 a 12
+ * @returns {string}
+ */
+export declare function formatMonthShortName(month: number): string;
+/**
+ * Nombre corto de un día de la semana: "lun", "mié" (renglones del calendario de actividad).
+ *
+ * @param {number} isoWeekday 1 = lunes ... 7 = domingo
+ * @returns {string}
+ */
+export declare function formatWeekdayShortName(isoWeekday: number): string;
+/**
+ * Día del mes de una fecha de calendario ("2026-08-16" → 16), sin moverla de zona.
+ *
+ * @param {string|null|undefined} value
+ * @returns {number|null}
+ */
+export declare function dayOfPlainDate(value: string | null | undefined): number | null;

package/dist/types/forms/FormCatalogField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('../inputs/CatalogInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de CatalogInput (options, formatLabel, loading…), sin value / onChange / onBlur / error
+ */
+export default function FormCatalogField({ name, ...catalogInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('../inputs/CatalogInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/forms/FormColorField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('../inputs/ColorInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de ColorInput (checkContrast…), sin value / onChange / onBlur / error
+ */
+export default function FormColorField({ name, ...colorInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('../inputs/ColorInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/forms/FormNumberField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('../inputs/NumberInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de NumberInput (decimals, prefix, suffix, allowNegative…), sin value / onChange / onBlur / error
+ */
+export default function FormNumberField({ name, ...numberInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('../inputs/NumberInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/forms/FormProblemAlert.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{sx?: object}} props
+ */
+export default function FormProblemAlert({ sx }: {
+    sx?: object;
+}): import("react").JSX.Element | null;

package/dist/types/forms/FormSelectField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('../inputs/SelectInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de SelectInput, sin value / onChange / onBlur / error
+ */
+export default function FormSelectField({ name, ...selectInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('../inputs/SelectInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/forms/FormServerProblem.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {{error: (Error & {problem?: object})|null}} props el error del contexto de la máquina (null = sin error)
+ */
+export default function FormServerProblem({ error }: {
+    error: (Error & {
+        problem?: object;
+    }) | null;
+}): null;

package/dist/types/forms/FormTextField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('../inputs/TextInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de TextInput, sin value / onChange / onBlur / error
+ */
+export default function FormTextField({ name, ...textInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('../inputs/TextInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/forms/FormWizard.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @param {object} props
+ * @param {Object[]} props.steps en orden
+ * @param {string} props.steps[].key
+ * @param {string} props.steps[].label ya traducido
+ * @param {string[]} [props.steps[].fields] los campos del paso (los que revisa «Siguiente»)
+ * @param {boolean} [props.steps[].optional] se puede omitir
+ * @param {import('react').ReactNode} props.steps[].content los campos del paso
+ * @param {string} props.submitLabel ya traducido: el botón del último paso
+ */
+export default function FormWizard({ steps, submitLabel }: {
+    steps: {
+        key: string;
+        label: string;
+        fields?: string[];
+        optional?: boolean;
+        content: import('react').ReactNode;
+    }[];
+    submitLabel: string;
+}): import("react").JSX.Element;

package/dist/types/forms/SubmitButton.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {{children: import('react').ReactNode, disabled?: boolean, isPending?: boolean} & Omit<import('@mui/material/Button').ButtonProps, 'type'|'children'>} props
+ *     lo demás va al Button de MUI (sx, size, fullWidth…)
+ */
+export default function SubmitButton({ children, disabled, isPending, ...buttonProps }: {
+    children: import('react').ReactNode;
+    disabled?: boolean;
+    isPending?: boolean;
+} & Omit<import('@mui/material/Button').ButtonProps, 'type' | 'children'>): import("react").JSX.Element;

package/dist/types/forms/applyServerProblem.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {unknown} error normalmente un ApiError (trae problem y message ya traducidos)
+ * @param {{setFieldError: Function, setStatus: Function, values: object}} formikHelpers
+ */
+export declare function applyServerProblem(error: unknown, { setFieldError, setStatus, values }: {
+    setFieldError: Function;
+    setStatus: Function;
+    values: object;
+}): void;

package/dist/types/forms/auth/ChangePasswordForm.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {object} props
+ * @param {(values: {currentPassword?: string, newPassword: string}) => Promise<unknown>} props.onSubmit cambia la
+ *     contraseña; si el servidor dice que no (la actual no es), truena con su problema
+ * @param {boolean} [props.requireCurrentPassword] por omisión sí; sin ella para la pantalla del enlace del correo
+ * @param {object} [props.policy] las reglas de la nueva; por omisión DEFAULT_PASSWORD_POLICY
+ */
+export default function ChangePasswordForm({ onSubmit, requireCurrentPassword, policy }: {
+    onSubmit: (values: {
+        currentPassword?: string;
+        newPassword: string;
+    }) => Promise<unknown>;
+    requireCurrentPassword?: boolean;
+    policy?: object;
+}): import("react").JSX.Element;

package/dist/types/forms/auth/ForgotPasswordForm.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {object} props
+ * @param {(values: {email: string}) => Promise<unknown>} props.onSubmit pide el enlace; si el servidor falla, truena con su
+ *     problema
+ * @param {string} [props.signInPath] la liga para regresar a iniciar sesión
+ */
+export default function ForgotPasswordForm({ onSubmit, signInPath }: {
+    onSubmit: (values: {
+        email: string;
+    }) => Promise<unknown>;
+    signInPath?: string;
+}): import("react").JSX.Element;

package/dist/types/forms/auth/SignInForm.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {object} props
+ * @param {(values: {email: string, password: string, remember: boolean}) => Promise<unknown>} props.onSubmit entra; si
+ *     el servidor dice que no, truena con su problema
+ * @param {string} [props.forgotPasswordPath] sin ella no sale la liga de «¿Olvidó su contraseña?»
+ * @param {boolean} [props.showRememberMe] por omisión sí
+ * @param {string} [props.initialEmail]
+ */
+export default function SignInForm({ onSubmit, forgotPasswordPath, showRememberMe, initialEmail }: {
+    onSubmit: (values: {
+        email: string;
+        password: string;
+        remember: boolean;
+    }) => Promise<unknown>;
+    forgotPasswordPath?: string;
+    showRememberMe?: boolean;
+    initialEmail?: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,19 @@
+export { default as FormCatalogField } from './FormCatalogField.js';
+export { default as FormColorField } from './FormColorField.js';
+export { default as FormNumberField } from './FormNumberField.js';
+export { default as FormProblemAlert } from './FormProblemAlert.js';
+export { default as FormSelectField } from './FormSelectField.js';
+export { default as FormServerProblem } from './FormServerProblem.js';
+export { default as FormTextField } from './FormTextField.js';
+export { default as FormWizard } from './FormWizard.js';
+export { default as ChangePasswordForm } from './auth/ChangePasswordForm.js';
+export { default as ForgotPasswordForm } from './auth/ForgotPasswordForm.js';
+export { default as SignInForm } from './auth/SignInForm.js';
+export { SECOND_STEP_METHOD, default as SecondStepForm } from './security/SecondStepForm.js';
+export { default as TwoStepVerificationCard } from './security/TwoStepVerificationCard.js';
+export { RECOVERY_CODE_PATTERN, TOTP_CODE_PATTERN, normalizeRecoveryCode, normalizeTotpCode, } from './security/securityRules.js';
+export { default as SubmitButton } from './SubmitButton.js';
+export { applyServerProblem } from './applyServerProblem.js';
+export { formLevelMessageOf, splitServerFieldErrors } from './serverProblemFields.js';
+export { useFormikField } from './useFormikField.js';
+export { Yup, buildYupLocale, translateValidationMessage } from './validation.js';

package/dist/types/forms/security/SecondStepForm.d.ts

@@ -0,0 +1,28 @@
+/** Las formas de confirmar el segundo paso, como las manda el servidor. */
+export declare const SECOND_STEP_METHOD: Readonly<{
+    passkey: "passkey";
+    totp: "totp";
+    recoveryCode: "recoveryCode";
+}>;
+/**
+ * @param {object} props
+ * @param {string[]} props.methods los que tiene la cuenta (SECOND_STEP_METHOD), como los mandó el servidor
+ * @param {boolean} [props.canUsePasskeys] passkeysSupported() de /passkeys
+ * @param {() => Promise<unknown>} [props.onUsePasskey] firma con la llave y termina de entrar; truena si no se pudo
+ * @param {(input: {method: string, code: string}) => Promise<unknown>} props.onSubmitCode manda el código ya limpio y
+ *     termina de entrar; truena con el ApiError si no
+ * @param {(message: string|null) => void} props.onCancel regresa a escribir la contraseña (con el motivo, si lo hay)
+ * @param {import('react').ReactNode} [props.footer] abajo del botón, dentro del formulario: puede llenar el código con
+ *     useFormikContext (p. ej. el atajo de los ejemplos)
+ */
+export default function SecondStepForm({ methods, canUsePasskeys, onUsePasskey, onSubmitCode, onCancel, footer }: {
+    methods: string[];
+    canUsePasskeys?: boolean;
+    onUsePasskey?: () => Promise<unknown>;
+    onSubmitCode: (input: {
+        method: string;
+        code: string;
+    }) => Promise<unknown>;
+    onCancel: (message: string | null) => void;
+    footer?: import('react').ReactNode;
+}): import("react").JSX.Element;