@stackcraftmx/calcita 0.0.0-stage → 0.25.0

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

@@ -0,0 +1,15 @@
+/**
+ * @param {object} props
+ * @param {string} props.label el nombre de la acción, ya traducido: «Agregar sucursal»
+ * @param {import('react').ReactNode} [props.icon] el ícono (<AddRoundedIcon />); sin él, se ve su texto
+ * @param {(event: object) => void} [props.onClick]
+ * @param {boolean} [props.disabled]
+ * @param {'inherit'|'primary'|'secondary'|'success'|'error'|'info'|'warning'} [props.color] por omisión primary
+ */
+export default function BarActionButton({ label, icon, onClick, disabled, color, ...buttonProps }: {
+    label: string;
+    icon?: import('react').ReactNode;
+    onClick?: (event: object) => void;
+    disabled?: boolean;
+    color?: 'inherit' | 'primary' | 'secondary' | 'success' | 'error' | 'info' | 'warning';
+}): import("react").JSX.Element;

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

@@ -0,0 +1,23 @@
+/**
+ * @param {object} props
+ * @param {import('react').ReactNode} props.children los botones de este grupo (normalmente BarActionButton)
+ * @param {string} [props.label] el nombre del grupo (lector de pantalla): «Acciones de pedidos»
+ * @param {number} [props.order] en qué lugar va entre los grupos de la pantalla (CSS order; por omisión el de aparición)
+ * @param {object|Function|Array} [props.sx] estilos propios de la cápsula de arriba o de la flotante del teléfono (o del
+ *     grupo, en la franja)
+ * @param {object|Function|Array} [props.inlineSx] estilos de la cápsula cuando se queda en la pantalla
+ * @param {boolean} [props.bare] sin cápsula alrededor: lo de adentro ya es una (un buscador)
+ * @param {boolean} [props.exclusive] en el teléfono, mientras se ve, es lo único del renglón flotante (con los demás grupos
+ *     exclusivos): los otros se esconden, como el modo de edición del iPhone deja solo lo de lo elegido. Lo usa SelectionActions
+ * @param {object} [props.texts] los textos que cambian, con la forma de `layout` en los textos del paquete
+ */
+export default function BarActions({ children, label, order, sx, inlineSx, bare, exclusive, texts }: {
+    children: import('react').ReactNode;
+    label?: string;
+    order?: number;
+    sx?: object | Function | any[];
+    inlineSx?: object | Function | any[];
+    bare?: boolean;
+    exclusive?: boolean;
+    texts?: object;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,20 @@
+export declare const BAR_CAPSULE_HEIGHT_PIXELS = 48;
+/**
+ * Los botones de adentro de un solo color y sin relleno, borde ni sombra (la regla de la barra con vidrio). La usan también
+ * la franja (BarActions) y lo que se ponga junto a la barra.
+ *
+ * @param {string} color el del texto de la barra ('inherit' en la franja)
+ * @returns {object} estilos para el sx del contenedor
+ */
+export declare function monochromeButtonsSxOf(color: string): object;
+/**
+ * Lo demás va al div de la cápsula: aria-label (el nombre del grupo para quien usa lector de pantalla), id, onClick…
+ * role va por omisión en 'group' (lo que se agrupa se anuncia junto).
+ *
+ * @param {Omit<import('react').HTMLAttributes<HTMLDivElement>, 'children'> & {children: import('react').ReactNode, sx?: object|Function|Array<any>}} props
+ *     children: los botones del grupo; sx: estilos propios, encima de los de la cápsula
+ */
+export default function BarCapsule({ children, sx, role, ...rest }: Omit<import('react').HTMLAttributes<HTMLDivElement>, 'children'> & {
+    children: import('react').ReactNode;
+    sx?: object | Function | Array<any>;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,24 @@
+/**
+ * @param {object} props
+ * @param {string} props.value lo escrito
+ * @param {(value: string) => void} props.onChange recibe el texto, no el evento
+ * @param {string} props.placeholder ya traducido: qué se busca («Buscar por título o etiqueta»); también es su nombre para el
+ *     lector de pantalla
+ * @param {boolean} [props.inBar] en la barra de la app (por omisión) o dentro de la pantalla
+ * @param {boolean} [props.collapsible] en la barra, sin usar se encoge a la lupa; por omisión sí (false: siempre abierta)
+ * @param {number} [props.order] en qué lugar va entre las cápsulas de la barra (por omisión la primera)
+ * @param {() => void} [props.onFocus]
+ * @param {() => void} [props.onBlur]
+ * @param {import('react').Ref<HTMLInputElement>} [props.inputRef] la caja, para enfocarla desde afuera (un atajo «/»)
+ */
+export default function BarSearch({ value, onChange, placeholder, inBar, collapsible, order, onFocus, onBlur, inputRef }: {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder: string;
+    inBar?: boolean;
+    collapsible?: boolean;
+    order?: number;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    inputRef?: import('react').Ref<HTMLInputElement>;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,27 @@
+/**
+ * @param {object} props
+ * @param {import('react').ReactNode} [props.headerActions]
+ * @param {boolean} props.showFontSizeToggle
+ * @param {boolean} props.showLanguageToggle
+ * @param {boolean} props.showColorSchemeToggle
+ * @param {object|null} props.user
+ * @param {string} [props.profilePath]
+ * @param {object[]} [props.accountMenuItems]
+ * @param {import('react').ReactNode} [props.accountSettings] los ajustes del proyecto, en el menú de la cuenta (SettingSection)
+ * @param {boolean} [props.vertical] en columna, para el menú lateral encogido
+ * @param {() => void} [props.onSignOut]
+ * @param {boolean} [props.isSigningOut]
+ */
+export default function HeaderTools({ headerActions, showFontSizeToggle, showLanguageToggle, showColorSchemeToggle, user, profilePath, accountMenuItems, onSignOut, isSigningOut, accountSettings, vertical, }: {
+    headerActions?: import('react').ReactNode;
+    showFontSizeToggle: boolean;
+    showLanguageToggle: boolean;
+    showColorSchemeToggle: boolean;
+    user: object | null;
+    profilePath?: string;
+    accountMenuItems?: object[];
+    accountSettings?: import('react').ReactNode;
+    vertical?: boolean;
+    onSignOut?: () => void;
+    isSigningOut?: boolean;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,20 @@
+/**
+ * @param {object} props
+ * @param {object[]} props.menuItems lo que regresa composeMenu
+ * @param {object|null} props.activeItem la entrada de la pantalla abierta
+ * @param {Record<string, number>} [props.menuBadges] los conteos del servidor por badgeKey
+ * @param {import('react').ReactNode} [props.account] la cuenta (o el engrane), en su círculo junto a la barra
+ * @param {import('react').ReactNode} [props.moreFooter] lo que va al final de la hoja de «Más» (la tarjeta del menú lateral)
+ * @param {boolean} [props.minimizeOnScroll] se encoge al leer hacia abajo; por omisión sí
+ * @param {(keys: string[]|null) => void} [props.onPinnedTabsChange] la persona eligió sus pestañas (null: regresó a las de
+ *     omisión)
+ */
+export default function MobileTabBar({ menuItems, activeItem, menuBadges, account, moreFooter, minimizeOnScroll, onPinnedTabsChange }: {
+    menuItems: object[];
+    activeItem: object | null;
+    menuBadges?: Record<string, number>;
+    account?: import('react').ReactNode;
+    moreFooter?: import('react').ReactNode;
+    minimizeOnScroll?: boolean;
+    onPinnedTabsChange?: (keys: string[] | null) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,13 @@
+/**
+ * @param {object} props
+ * @param {boolean} [props.showFontSize]
+ * @param {boolean} [props.showLanguage]
+ * @param {boolean} [props.showColorScheme]
+ * @param {import('react').ReactNode} [props.extraSettings] los ajustes del proyecto, debajo de los del paquete
+ */
+export default function SettingsMenu({ showFontSize, showLanguage, showColorScheme, extraSettings }: {
+    showFontSize?: boolean;
+    showLanguage?: boolean;
+    showColorScheme?: boolean;
+    extraSettings?: import('react').ReactNode;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,31 @@
+/**
+ * @param {object} props
+ * @param {import('react').ReactNode} [props.logo] el logo chico (28 px), el que se queda con el menú encogido
+ * @param {string} props.brandName el nombre de la app
+ * @param {string} [props.brandCaption] el renglón chico debajo del nombre («Panel de administración»)
+ * @param {string} props.homePath
+ * @param {object[]} props.menuItems lo que regresa composeMenu
+ * @param {object|null} props.activeItem
+ * @param {boolean} props.collapsed
+ * @param {import('react').ReactNode} [props.footer]
+ * @param {boolean} [props.showBrand] el logo y el nombre arriba; por omisión sí (en escritorio van en la barra)
+ * @param {() => void} [props.onNavigate]
+ * @param {Record<string, number>} [props.menuBadges] los conteos del servidor por badgeKey
+ * @param {import('react').ReactNode} [props.railTop] arriba del menú encogido que hace de barra: la ☰ y el logo
+ * @param {import('react').ReactNode} [props.railBottom] abajo de ese menú: los ajustes y la cuenta
+ */
+export default function SideMenu({ logo, brandName, brandCaption, homePath, menuItems, activeItem, collapsed, footer, showBrand, onNavigate, railTop, railBottom, menuBadges, }: {
+    logo?: import('react').ReactNode;
+    brandName: string;
+    brandCaption?: string;
+    homePath: string;
+    menuItems: object[];
+    activeItem: object | null;
+    collapsed: boolean;
+    footer?: import('react').ReactNode;
+    showBrand?: boolean;
+    onNavigate?: () => void;
+    menuBadges?: Record<string, number>;
+    railTop?: import('react').ReactNode;
+    railBottom?: import('react').ReactNode;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,17 @@
+/**
+ * @param {object} props
+ * @param {object} props.menuItem una entrada de composeMenu
+ * @param {object|null} props.activeItem la entrada de la pantalla abierta
+ * @param {boolean} props.collapsed el menú está encogido (solo íconos)
+ * @param {() => void} [props.onNavigate] al elegir una pantalla (el cajón del teléfono se cierra)
+ * @param {Record<string, number>} [props.menuBadges] los conteos del servidor por badgeKey (menuBadgeOf)
+ * @param {number} [props.depth]
+ */
+export default function SideMenuEntry({ menuItem, activeItem, collapsed, onNavigate, menuBadges, depth }: {
+    menuItem: object;
+    activeItem: object | null;
+    collapsed: boolean;
+    onNavigate?: () => void;
+    menuBadges?: Record<string, number>;
+    depth?: number;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,24 @@
+/** Hacia dónde sale el menú: a la derecha del botón (menú lateral) o arriba de él (pestañas del teléfono). */
+export declare const SUBMENU_PLACEMENT: Readonly<{
+    side: "side";
+    above: "above";
+}>;
+/**
+ * @param {object} props
+ * @param {Element|null} props.anchorElement el botón del que cuelga (null = cerrado)
+ * @param {() => void} props.onClose
+ * @param {object} props.menuItem la entrada con sus hijas (children)
+ * @param {object|null} props.activeItem la entrada de la pantalla abierta
+ * @param {Record<string, number>} [props.menuBadges] los conteos del servidor por badgeKey
+ * @param {() => void} [props.onNavigate] al elegir una hija
+ * @param {'side'|'above'} [props.placement] SUBMENU_PLACEMENT; por omisión a la derecha
+ */
+export default function SubmenuActionsMenu({ anchorElement, onClose, menuItem, activeItem, menuBadges, onNavigate, placement }: {
+    anchorElement: Element | null;
+    onClose: () => void;
+    menuItem: object;
+    activeItem: object | null;
+    menuBadges?: Record<string, number>;
+    onNavigate?: () => void;
+    placement?: 'side' | 'above';
+}): import("react").JSX.Element;

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

@@ -0,0 +1,13 @@
+/**
+ * @param {object} props
+ * @param {object[]} props.menuItems todo el menú (lo que regresa composeMenu)
+ * @param {string[]} props.pinnedKeys las que van hoy en la barra (menuItemKeyOf)
+ * @param {(keys: string[]) => void} props.onDone con las elegidas, en el orden del menú
+ * @param {() => void} props.onReset regresar a las del proyecto
+ */
+export default function TabBarEditor({ menuItems, pinnedKeys, onDone, onReset }: {
+    menuItems: object[];
+    pinnedKeys: string[];
+    onDone: (keys: string[]) => void;
+    onReset: () => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,7 @@
+/**
+ * @param {{menuItems: object[], activeItem: object|null}} props
+ */
+export default function TopMenu({ menuItems, activeItem }: {
+    menuItems: object[];
+    activeItem: object | null;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,9 @@
+export declare const AppMenuContext: import("react").Context<{
+    menuItems: never[];
+}>;
+/**
+ * @returns {{menuItems: object[]}} lo que AppLayout recibió de composeMenu
+ */
+export declare function useAppMenu(): {
+    menuItems: object[];
+};

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

@@ -0,0 +1,35 @@
+/** Dónde quedó un botón de acción: en una cápsula, en el menú «⋯» o suelto. */
+export declare const BAR_ACTIONS_PLACEMENT: Readonly<{
+    capsule: "capsule";
+    menu: "menu";
+    inline: "inline";
+}>;
+export declare const BarActionsSlotContext: import("react").Context<{
+    slot: null;
+    phoneSlot: null;
+    usesCapsules: boolean;
+}>;
+export declare const BarActionsPlacementContext: import("react").Context<"inline">;
+export declare const BarActionsMenuCloseContext: import("react").Context<() => void>;
+/**
+ * @returns {{slot: Element|null, phoneSlot: Element|null, usesCapsules: boolean}} slot: el lugar de la barra en escritorio;
+ *     phoneSlot: el renglón flotante del teléfono; usesCapsules: la barra va en cápsulas
+ */
+export declare function useBarActionsSlot(): {
+    slot: Element | null;
+    phoneSlot: Element | null;
+    usesCapsules: boolean;
+};
+/**
+ * Dónde quedó lo que está adentro de BarActions (BAR_ACTIONS_PLACEMENT). Fuera de BarActions, 'inline'.
+ *
+ * @returns {string}
+ */
+export declare function useBarActionsPlacement(): string;
+/**
+ * En el menú «⋯» del teléfono, la función que lo cierra (para algo propio que haga su acción y deba cerrarlo); fuera de él
+ * no hace nada.
+ *
+ * @returns {() => void}
+ */
+export declare function useCloseBarActionsMenu(): () => void;

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

@@ -0,0 +1,9 @@
+/**
+ * @param {Element|null} anchorElement el botón que abre el menú
+ * @returns {{anchorOrigin: object, transformOrigin: object, gapSx: object}} para el <Menu> de MUI (gapSx va en el sx del papel)
+ */
+export declare function barMenuPlacementOf(anchorElement: Element | null): {
+    anchorOrigin: object;
+    transformOrigin: object;
+    gapSx: object;
+};

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

@@ -0,0 +1,55 @@
+/**
+ * El nombre de una entrada del menú.
+ *
+ * @param {{label?: string, labelKey?: string}} menuItem
+ * @param {(key: string) => string} t el traductor de la pantalla
+ * @returns {string}
+ */
+export declare function menuItemLabelOf(menuItem: {
+    label?: string;
+    labelKey?: string;
+}, t: (key: string) => string): string;
+/**
+ * Para qué sirve una entrada (para las tarjetas de un inicio).
+ *
+ * @param {{description?: string, descriptionKey?: string}} menuItem
+ * @param {(key: string) => string} t
+ * @returns {string|undefined}
+ */
+export declare function menuItemDescriptionOf(menuItem: {
+    description?: string;
+    descriptionKey?: string;
+}, t: (key: string) => string): string | undefined;
+/**
+ * El título de la sección del menú lateral donde va la entrada («Operación», «Administración»).
+ *
+ * @param {{section?: string, sectionKey?: string}} menuItem
+ * @param {(key: string) => string} t
+ * @returns {string|undefined}
+ */
+export declare function menuItemSectionOf(menuItem: {
+    section?: string;
+    sectionKey?: string;
+}, t: (key: string) => string): string | undefined;
+/**
+ * Las entradas juntas por sección: las secciones salen en el orden en que aparece su primera entrada, y adentro cada
+ * entrada en su orden. Las entradas sin sección forman su propio bloque sin título.
+ *
+ * Por qué por título y no por vecindad: con vecindad, dos módulos de la misma sección con un `order` de otra en medio
+ * partían la sección en dos («Interfaz» salía dos veces). Así cada módulo dice su sección sin coordinar números.
+ *
+ * @param {object[]} menuItems lo que regresa composeMenu
+ * @param {(key: string) => string} t
+ * @returns {Array<{title: string|undefined, menuItems: object[]}>}
+ */
+export declare function menuSectionsOf(menuItems: object[], t: (key: string) => string): Array<{
+    title: string | undefined;
+    menuItems: object[];
+}>;
+/**
+ * Las iniciales para el avatar: «Ana María López» → «AM», «Usuario de Ejemplo» → «UE». Sin nombre, «?».
+ *
+ * @param {string|null|undefined} fullName
+ * @returns {string}
+ */
+export declare function initialsOf(fullName: string | null | undefined): string;

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,46 @@
+/** 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;
+}>;
+export declare const FLOATING_BOTTOM_SPACE_CSS_VARIABLE = "--calcita-floating-bottom-space";
+/**
+ * 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,13 @@
+/**
+ * @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]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `auth` en los textos del paquete
+ */
+export default function PasswordChecklist({ password, policy, id, texts }: {
+    password: string;
+    policy?: object;
+    id?: string;
+    texts?: object;
+}): 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,63 @@
+/** 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
+ * @param {(range: {start: string, end: string, view: string}) => void} [props.onDatesChange] cada que cambia lo que se ve (al
+ *     abrir, al ir al anterior o siguiente, al cambiar de vista): para pedir al backend solo las citas de ese rango
+ * @param {(view: string) => void} [props.onViewChange] al cambiar de vista (CALENDAR_VIEW)
+ * @param {(event: any) => import('react').ReactNode} [props.renderEvent] lo de adentro de cada cita (recibe la cita de events
+ *     tal cual, con sus campos propios)
+ * @param {object} [props.fullCalendarProps] lo demás de FullCalendar (businessHours, hiddenDays, slotMinTime, locale…); lo
+ *     que el calendario controla (las citas, la barra, los eventos de arriba) no se reemplaza desde aquí
+ * @param {object} [props.texts] los textos que cambian, con la forma de `calendar` en los textos del paquete
+ */
+export default function EventCalendar({ events, initialView, views, onEventClick, onDateSelect, onEventChange, height, ariaLabel, onDatesChange, onViewChange, renderEvent, fullCalendarProps, texts, }: {
+    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;
+    onDatesChange?: (range: {
+        start: string;
+        end: string;
+        view: string;
+    }) => void;
+    onViewChange?: (view: string) => void;
+    renderEvent?: (event: any) => import('react').ReactNode;
+    fullCalendarProps?: object;
+    texts?: object;
+}): import("react").JSX.Element;