@stackcraftmx/calcita 0.0.0-stage → 0.25.0

package/dist/types/account/demo/createDemoAccountConnector.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @param {object} [options]
+ * @param {{id: string, name: string, email: string, subtitle?: string, phone?: string}} [options.user] la persona de la
+ *     demostración; por omisión una inventada
+ * @param {string[]} [options.roles]
+ * @param {string[]} [options.abilities]
+ * @param {string[]} [options.labels] sus perfiles, ya traducidos (chips en Mi perfil)
+ * @param {string} [options.storageKey] dónde se recuerda la sesión en este navegador (con el nombre de la app)
+ * @param {(otpauthUrl: string) => Promise<string>} [options.toQrImageUrl] el QR de la clave (p. ej. QRCode.toDataURL de
+ *     la librería qrcode); sin él, la persona escribe la clave a mano en su app
+ * @param {string} [options.issuer] el nombre que enseña la app autenticadora
+ * @param {number} [options.delayMilliseconds] lo que tarda cada respuesta
+ * @returns {import('../accountConnector.js').AccountConnector}
+ */
+export declare function createDemoAccountConnector({ user, roles, abilities, labels, storageKey, toQrImageUrl, issuer, delayMilliseconds, }?: {
+    user?: {
+        id: string;
+        name: string;
+        email: string;
+        subtitle?: string;
+        phone?: string;
+    };
+    roles?: string[];
+    abilities?: string[];
+    labels?: string[];
+    storageKey?: string;
+    toQrImageUrl?: (otpauthUrl: string) => Promise<string>;
+    issuer?: string;
+    delayMilliseconds?: number;
+}): import('../accountConnector.js').AccountConnector;

package/dist/types/account/demo/totp.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Bytes → base32 (la clave como la escribe la persona en su app).
+ *
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export declare function base32Of(bytes: Uint8Array): string;
+/**
+ * Base32 → bytes (sin espacios ni relleno).
+ *
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+export declare function bytesOfBase32(text: string): Uint8Array;
+/** Una clave nueva al azar, en base32. */
+export declare function newTotpSecret(): string;
+/**
+ * El código que enseña la app en ese momento.
+ *
+ * @param {string} secret la clave en base32
+ * @param {number} [timeMilliseconds] por omisión, ahora
+ * @param {number} [digits]
+ * @returns {Promise<string>}
+ */
+export declare function totpCodeAt(secret: string, timeMilliseconds?: number, digits?: number): Promise<string>;
+/**
+ * ¿El código es el de ahora (o el de un paso antes o después)?
+ *
+ * @param {string} secret
+ * @param {string} code los 6 dígitos
+ * @param {number} [timeMilliseconds]
+ * @returns {Promise<boolean>}
+ */
+export declare function isValidTotpCode(secret: string, code: string, timeMilliseconds?: number): Promise<boolean>;
+/**
+ * La dirección otpauth:// que va en el QR: la app la lee y guarda la cuenta con su clave.
+ *
+ * @param {{secret: string, account: string, issuer: string}} details
+ * @returns {string}
+ */
+export declare function otpauthUrlOf({ secret, account, issuer }: {
+    secret: string;
+    account: string;
+    issuer: string;
+}): string;

package/dist/types/account/restAccountConnector.d.ts

@@ -0,0 +1,49 @@
+/** Las rutas del contrato; se pegan a la baseUrl del cliente (/api + /auth/session). */
+export declare const ACCOUNT_REST_PATHS: Readonly<{
+    session: "/auth/session";
+    signIn: "/auth/sign-in";
+    secondStep: "/auth/second-step";
+    secondStepPasskeyOptions: "/auth/second-step/passkey-options";
+    secondStepPasskey: "/auth/second-step/passkey";
+    signOut: "/auth/sign-out";
+    forgotPassword: "/auth/forgot-password";
+    resetPassword: "/auth/reset-password";
+    profile: "/account";
+    password: "/account/password";
+    security: "/account/security";
+    totp: "/account/security/totp";
+    totpConfirm: "/account/security/totp/confirm";
+    passkeyRegistrationOptions: "/account/security/passkeys/registration-options";
+    passkeys: "/account/security/passkeys";
+    recoveryCodes: "/account/security/recovery-codes";
+    sessions: "/account/sessions";
+    closeOtherSessions: "/account/sessions/close-others";
+    activity: "/account/activity";
+}>;
+/**
+ * El estado de la verificación, del contrato a camelCase.
+ *
+ * @param {object} response
+ * @returns {import('./accountConnector.js').AccountSecurity}
+ */
+export declare function securityFromResponse(response: object): import('./accountConnector.js').AccountSecurity;
+/**
+ * Lo que regresa un cambio de seguridad: {security, recovery_codes?} → {security, recoveryCodes?}.
+ *
+ * @param {object} response
+ * @returns {import('./accountConnector.js').AccountSecurityChange}
+ */
+export declare function securityChangeFromResponse(response: object): import('./accountConnector.js').AccountSecurityChange;
+/**
+ * @param {{get: Function, post: Function, put: Function, delete: Function}} apiClient el de createApiClient
+ * @param {{paths?: Partial<Record<keyof typeof ACCOUNT_REST_PATHS, string>>}} [options] las rutas que se llaman distinto
+ * @returns {import('./accountConnector.js').AccountConnector}
+ */
+export declare function createRestAccountConnector(apiClient: {
+    get: Function;
+    post: Function;
+    put: Function;
+    delete: Function;
+}, { paths }?: {
+    paths?: Partial<Record<keyof typeof ACCOUNT_REST_PATHS, string>>;
+}): import('./accountConnector.js').AccountConnector;

package/dist/types/account-demo.d.ts

@@ -0,0 +1,2 @@
+export { createDemoAccountConnector } from './account/demo/createDemoAccountConnector.js';
+export { base32Of, bytesOfBase32, isValidTotpCode, newTotpSecret, otpauthUrlOf, totpCodeAt } from './account/demo/totp.js';

package/dist/types/account.d.ts

@@ -0,0 +1,16 @@
+export { ACCOUNT_CONNECTOR_FUNCTIONS, missingConnectorFunctionsOf } from './account/accountConnector.js';
+export { ACCOUNT_REST_PATHS, createRestAccountConnector, securityChangeFromResponse, securityFromResponse } from './account/restAccountConnector.js';
+export { default as AccountProvider, useAccount } from './account/AccountProvider.js';
+export { default as AccountSecuritySection } from './account/AccountSecuritySection.js';
+export { default as ForgotPasswordScreen } from './account/ForgotPasswordScreen.js';
+export { PROFILE_TAB, default as ProfileScreen } from './account/ProfileScreen.js';
+export { default as ResetPasswordScreen } from './account/ResetPasswordScreen.js';
+export { default as SignInScreen } from './account/SignInScreen.js';
+export type AccountConnector = import('./account/accountConnector.js').AccountConnector;
+export type AccountSession = import('./account/accountConnector.js').AccountSession;
+export type AccountUser = import('./account/accountConnector.js').AccountUser;
+export type AccountSecurity = import('./account/accountConnector.js').AccountSecurity;
+/** @typedef {import('./account/accountConnector.js').AccountConnector} AccountConnector */
+/** @typedef {import('./account/accountConnector.js').AccountSession} AccountSession */
+/** @typedef {import('./account/accountConnector.js').AccountUser} AccountUser */
+/** @typedef {import('./account/accountConnector.js').AccountSecurity} AccountSecurity */

package/dist/types/adapters/i18next.d.ts

@@ -0,0 +1,11 @@
+/**
+ * El traductor de ToolkitProvider sobre una instancia de i18next: si la llave existe en el proyecto regresa su texto;
+ * si no, undefined, y el paquete usa el suyo.
+ *
+ * @param {{exists: Function, t: Function}} i18n la instancia de i18next del proyecto
+ * @returns {(namespace: string, key: string, values?: object) => string|undefined}
+ */
+export declare function translateWithI18next(i18n: {
+    exists: Function;
+    t: Function;
+}): (namespace: string, key: string, values?: object) => string | undefined;

package/dist/types/adapters/nextNavigation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * navigate(to) del framework con el router de Next.
+ *
+ * @returns {(to: string|number, options?: {replace?: boolean}) => void}
+ */
+declare function useNextNavigate(): (to: string | number, options?: {
+    replace?: boolean;
+}) => void;
+/**
+ * {pathname, search, key} de la página abierta.
+ *
+ * @returns {{pathname: string, search: string, key: string}}
+ */
+declare function useNextLocation(): {
+    pathname: string;
+    search: string;
+    key: string;
+};
+/**
+ * next/link con la prop `to` del framework.
+ *
+ * @param {{to?: string, href?: string}} props
+ */
+declare function NextToLink({ to, href, ...linkProps }: {
+    to?: string;
+    href?: string;
+}): import("react").JSX.Element;
+export declare const nextNavigation: Readonly<{
+    useNavigate: typeof useNextNavigate;
+    useLocation: typeof useNextLocation;
+    Link: typeof NextToLink;
+}>;
+export {};

package/dist/types/adapters/reactRouter.d.ts

@@ -0,0 +1,6 @@
+import { useLocation, useNavigate } from 'react-router';
+export declare const reactRouterNavigation: Readonly<{
+    useNavigate: typeof useNavigate;
+    useLocation: typeof useLocation;
+    Link: import("react").ForwardRefExoticComponent<import("react-router").LinkProps & import("react").RefAttributes<HTMLAnchorElement>>;
+}>;

package/dist/types/adapters/reactRouterRoutes.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Un grupo de rutas sin camino propio que pide permiso antes de pintar a sus hijas.
+ *
+ * @param {object|undefined} access la regla (accessRules.js); sin ella, el grupo es de todos
+ * @param {object[]} routes las rutas del módulo
+ * @param {{fallback?: import('react').ReactNode}} [options] fallback: lo que ve quien no tiene permiso; por omisión la página
+ *     de «sin permiso» de la casa (con ErrorPage y sus props se arma una propia: un botón para pedir acceso)
+ * @returns {object} la ruta de react-router
+ */
+export declare function withAccess(access: object | undefined, routes: object[], { fallback }?: {
+    fallback?: import('react').ReactNode;
+}): object;
+/**
+ * ¿Se está descargando la pantalla siguiente?
+ *
+ * @returns {boolean}
+ */
+export declare function useIsNavigating(): boolean;
+/**
+ * Las rutas con la recuperación de archivos viejos (staleChunks.js): cada `lazy`, también la de las hijas, recarga la
+ * página UNA vez si el archivo de su pantalla ya no existe porque se publicó otra versión. Lo demás de la ruta no cambia.
+ *
+ * @param {object[]} routes
+ * @returns {object[]}
+ */
+export declare function withChunkRecovery(routes: object[]): object[];
+/**
+ * La pantalla de error de una ruta (la que el router enseña cuando la pantalla truena o no se pudo descargar): una ruta
+ * que no existe es «Esta página no existe»; un archivo de otra versión, «Hay una versión nueva»; lo demás, «Algo falló de
+ * nuestro lado». Las dos últimas con su botón para recargar.
+ *
+ *   createBrowserRouter([{path: '/', element: <App />, ErrorBoundary: RouteErrorScreen, children: [...]}])
+ *
+ * Con props (como errorElement) se extiende igual que ErrorPage, y onError recibe lo que tronó (para Sentry o su aviso):
+ *   {errorElement: <RouteErrorScreen onError={(error) => reportError(error)} extraActions={<SupportButton />} />}
+ *
+ * @param {object} [props] las de ErrorPage (extraActions, actions, children, icon, homePath, onGoHome, texts) y:
+ * @param {(error: unknown, kind: string) => void} [props.onError] cada error que llega aquí, con su tipo (ERROR_PAGE_KIND)
+ */
+export declare function RouteErrorScreen({ onError, ...errorPageProps }?: {
+    onError?: (error: unknown, kind: string) => void;
+}): import("react").JSX.Element;

package/dist/types/api/ApiError.d.ts

@@ -0,0 +1,42 @@
+/** Los status que la pantalla suele tratar distinto, con su nombre. */
+export declare const API_ERROR_STATUS: Readonly<{
+    offline: 0;
+    unauthenticated: 401;
+    forbidden: 403;
+    notFound: 404;
+    conflict: 409;
+    gone: 410;
+    validation: 422;
+    tooManyRequests: 429;
+}>;
+export declare class ApiError extends Error {
+    status: number;
+    problem: object;
+    code: any;
+    title: string;
+    requestId: any;
+    retryAfterSeconds: number | null;
+    /**
+     * @param {object} details
+     * @param {number} details.status el status HTTP; 0 si no hubo respuesta
+     * @param {object|null} [details.problem] el cuerpo RFC 9457 del servidor ({title, detail, code, errors, request_id})
+     * @param {boolean} [details.translatedByServer] false si la respuesta llegó en otro idioma que el pedido
+     * @param {number|null} [details.retryAfterSeconds] 429: los segundos del header Retry-After
+     */
+    constructor({ status, problem, translatedByServer, retryAfterSeconds }: {
+        status: number;
+        problem?: object | null;
+        translatedByServer?: boolean;
+        retryAfterSeconds?: number | null;
+    });
+    /** No hubo respuesta del servidor (red caída, servidor apagado, se acabó el tiempo). */
+    get isOffline(): boolean;
+    /** Sin sesión, o se venció mientras se usaba la app. */
+    get isUnauthenticated(): boolean;
+    /** El registro no está en el estado que la acción necesita. */
+    get isConflict(): boolean;
+    /** La liga venció, ya se usó o no existe. */
+    get isGone(): boolean;
+    /** Errores de un formulario: los mensajes por campo van en problem.errors (fieldErrorsOf). */
+    get isValidation(): boolean;
+}

package/dist/types/api/createApiClient.d.ts

@@ -0,0 +1,174 @@
+import { ApiError } from './ApiError.js';
+/** Cómo se lee una respuesta que salió bien. */
+export declare const API_RESPONSE_PARSE: Readonly<{
+    json: "json";
+    blob: "blob";
+    response: "response";
+}>;
+/**
+ * La dirección completa: la base del cliente más el camino, con los parámetros. Un camino que ya trae http(s) va tal cual.
+ * Los parámetros vacíos (undefined, null) no viajan; una lista viaja repetida (estado=a&estado=b).
+ *
+ * @param {string} baseUrl
+ * @param {string} path
+ * @param {Record<string, unknown>} [params]
+ * @returns {string}
+ */
+export declare function apiUrlOf(baseUrl: string, path: string, params?: Record<string, unknown>): string;
+/**
+ * Retry-After en segundos: el estándar admite segundos o una fecha HTTP.
+ *
+ * @param {string|null} retryAfterHeader
+ * @returns {number|null}
+ */
+export declare function retryAfterSecondsOf(retryAfterHeader: string | null): number | null;
+export type ApiRequestOptions = {
+    /**
+     * objeto → JSON; FormData, Blob o URLSearchParams tal cual
+     */
+    body?: unknown;
+    /**
+     * los de la dirección (?page=2)
+     */
+    params?: Record<string, unknown>;
+    /**
+     * para cancelar
+     */
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+    /**
+     * cómo se lee la respuesta (API_RESPONSE_PARSE); por omisión JSON
+     */
+    parse?: 'json' | 'blob' | 'response';
+    /**
+     * un 401 que se espera (¿hay sesión?, el login)
+     */
+    skipUnauthenticatedHandler?: boolean;
+    /**
+     * el de esta petición
+     */
+    timeoutMilliseconds?: number;
+};
+export type ApiDownloadOptions = {
+    params?: Record<string, unknown>;
+    signal?: AbortSignal;
+    onDownloadProgress?: (progress: {
+        loaded: number;
+        total: number | null;
+    }) => void;
+    /**
+     * si el servidor no manda el nombre
+     */
+    fallbackFileName?: string;
+    /**
+     * por omisión sin límite
+     */
+    timeoutMilliseconds?: number;
+};
+export type ApiClient = {
+    request: (method: string, path: string, options?: ApiRequestOptions) => Promise<any>;
+    get: (path: string, options?: ApiRequestOptions) => Promise<any>;
+    post: (path: string, body?: unknown, options?: ApiRequestOptions) => Promise<any>;
+    put: (path: string, body?: unknown, options?: ApiRequestOptions) => Promise<any>;
+    patch: (path: string, body?: unknown, options?: ApiRequestOptions) => Promise<any>;
+    delete: (path: string, options?: ApiRequestOptions) => Promise<any>;
+    download: (path: string, options?: ApiDownloadOptions) => Promise<{
+        blob: Blob;
+        fileName: string;
+    }>;
+};
+/**
+ * Lo que acepta cada petición.
+ *
+ * @typedef {object} ApiRequestOptions
+ * @property {unknown} [body] objeto → JSON; FormData, Blob o URLSearchParams tal cual
+ * @property {Record<string, unknown>} [params] los de la dirección (?page=2)
+ * @property {AbortSignal} [signal] para cancelar
+ * @property {Record<string, string>} [headers]
+ * @property {'json'|'blob'|'response'} [parse] cómo se lee la respuesta (API_RESPONSE_PARSE); por omisión JSON
+ * @property {boolean} [skipUnauthenticatedHandler] un 401 que se espera (¿hay sesión?, el login)
+ * @property {number} [timeoutMilliseconds] el de esta petición
+ */
+/**
+ * Lo que acepta una descarga.
+ *
+ * @typedef {object} ApiDownloadOptions
+ * @property {Record<string, unknown>} [params]
+ * @property {AbortSignal} [signal]
+ * @property {(progress: {loaded: number, total: number|null}) => void} [onDownloadProgress]
+ * @property {string} [fallbackFileName] si el servidor no manda el nombre
+ * @property {number} [timeoutMilliseconds] por omisión sin límite
+ */
+/**
+ * El cliente del proyecto: cada método regresa el JSON de la respuesta (null si vino vacía) o truena con un ApiError.
+ *
+ * @typedef {object} ApiClient
+ * @property {(method: string, path: string, options?: ApiRequestOptions) => Promise<any>} request
+ * @property {(path: string, options?: ApiRequestOptions) => Promise<any>} get
+ * @property {(path: string, body?: unknown, options?: ApiRequestOptions) => Promise<any>} post
+ * @property {(path: string, body?: unknown, options?: ApiRequestOptions) => Promise<any>} put
+ * @property {(path: string, body?: unknown, options?: ApiRequestOptions) => Promise<any>} patch
+ * @property {(path: string, options?: ApiRequestOptions) => Promise<any>} delete
+ * @property {(path: string, options?: ApiDownloadOptions) => Promise<{blob: Blob, fileName: string}>} download
+ */
+/**
+ * Arma el cliente del proyecto.
+ *
+ * @param {object} [options]
+ * @param {string} [options.baseUrl] lo que va antes de cada camino, p. ej. '/api/v1'
+ * @param {RequestCredentials} [options.credentials] 'same-origin' (por omisión, la cookie de sesión del mismo dominio) o
+ *     'include' (un API en otro dominio con cookies)
+ * @param {() => string|null|undefined} [options.getToken] con él cada petición lleva Authorization: Bearer; sin token, va
+ *     sin el header (el servidor responde 401)
+ * @param {Record<string, string>} [options.headers] los que van en todas las peticiones
+ * @param {string|null} [options.publishedBuildHeader] el header con la compilación publicada; null para no leerlo
+ * @param {{cookieName?: string, headerName?: string, refreshPath?: string}|null} [options.csrf] Laravel Sanctum:
+ *     {refreshPath: '/auth/csrf-token'}; por omisión la cookie XSRF-TOKEN y el header X-XSRF-TOKEN
+ * @param {number} [options.timeoutMilliseconds] el tiempo máximo de una consulta (0 = sin límite); por omisión 60 s
+ * @param {(error: ApiError) => void} [options.onUnauthenticated] qué hacer con un 401 (normalmente ir a iniciar sesión)
+ * @param {(request: {method: string, url: string}) => void} [options.onRequest] cada petición, al salir
+ * @param {(response: {method: string, url: string, status: number, durationMilliseconds: number}) => void} [options.onResponse]
+ *     cada respuesta, buena o mala, al llegar
+ * @param {(error: ApiError, request: {method: string, url: string}) => void} [options.onError] cada error (sin red, 4xx, 5xx,
+ *     una respuesta que no es JSON), en un solo lugar: Sentry, un aviso propio. Cancelar no es error
+ * @param {(body: any, response: Response) => object|null} [options.toProblem] el error de un backend que no contesta en
+ *     RFC 9457, a esa forma: (body) => ({title: body.message, errors: body.errors}). Por omisión el cuerpo tal cual
+ * @param {(body: any, request: {method: string, url: string}) => any} [options.mapResponse] la respuesta buena de un backend
+ *     que la envuelve: (body) => body.data. Por omisión tal cual
+ * @param {typeof fetch} [options.fetch] para un servidor de mentira o para las pruebas; por omisión el del navegador
+ * @returns {ApiClient}
+ */
+export declare function createApiClient({ baseUrl, credentials, getToken, headers: commonHeaders, publishedBuildHeader, csrf, timeoutMilliseconds: defaultTimeoutMilliseconds, onUnauthenticated, onRequest, onResponse, onError, toProblem, mapResponse, fetch: fetchImplementation, }?: {
+    baseUrl?: string;
+    credentials?: RequestCredentials;
+    getToken?: () => string | null | undefined;
+    headers?: Record<string, string>;
+    publishedBuildHeader?: string | null;
+    csrf?: {
+        cookieName?: string;
+        headerName?: string;
+        refreshPath?: string;
+    } | null;
+    timeoutMilliseconds?: number;
+    onUnauthenticated?: (error: ApiError) => void;
+    onRequest?: (request: {
+        method: string;
+        url: string;
+    }) => void;
+    onResponse?: (response: {
+        method: string;
+        url: string;
+        status: number;
+        durationMilliseconds: number;
+    }) => void;
+    onError?: (error: ApiError, request: {
+        method: string;
+        url: string;
+    }) => void;
+    toProblem?: (body: any, response: Response) => object | null;
+    mapResponse?: (body: any, request: {
+        method: string;
+        url: string;
+    }) => any;
+    fetch?: typeof fetch;
+}): ApiClient;

package/dist/types/api/staleChunks.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ¿El error es un archivo de pantalla que ya no existe (se publicó otra versión), y no otra cosa?
+ *
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+export declare function isStaleChunkError(error: unknown): boolean;
+/**
+ * Lo que va en el .catch() de un import dinámico: si el archivo es de una versión vieja, recarga una vez; si no, deja
+ * pasar el error tal cual para que lo vea quien corresponda.
+ *
+ * @param {unknown} error
+ * @returns {Promise<never>}
+ */
+export declare function recoverFromStaleChunk(error: unknown): Promise<never>;

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

@@ -0,0 +1,28 @@
+/**
+ * @param {object} props
+ * @param {{name: string, email?: string, subtitle?: string, avatarUrl?: string}} props.user
+ * @param {string} [props.profilePath] sin ella no sale «Mi perfil»
+ * @param {Array<{to?: string, onClick?: Function, label?: string, labelKey?: string, Icon?: import('react').ElementType}>} [props.accountMenuItems]
+ * @param {() => void} [props.onSignOut] sin él no sale «Salir»
+ * @param {boolean} [props.isSigningOut]
+ * @param {import('react').ReactNode} [props.settings] los ajustes de la app, entre los datos de la persona y sus ligas
+ */
+export default function AccountMenu({ user, profilePath, accountMenuItems, onSignOut, isSigningOut, settings }: {
+    user: {
+        name: string;
+        email?: string;
+        subtitle?: string;
+        avatarUrl?: string;
+    };
+    profilePath?: string;
+    accountMenuItems?: Array<{
+        to?: string;
+        onClick?: Function;
+        label?: string;
+        labelKey?: string;
+        Icon?: import('react').ElementType;
+    }>;
+    onSignOut?: () => void;
+    isSigningOut?: boolean;
+    settings?: import('react').ReactNode;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,76 @@
+/** Los dos estilos de barra. */
+export declare const MENU_POSITION: Readonly<{
+    side: "side";
+    top: "top";
+}>;
+/**
+ * @param {object} props
+ * @param {import('react').ReactNode} [props.logo] el logo chico (28 px), en la barra junto al nombre y en el cajón del teléfono
+ * @param {string} [props.brandName] el nombre de la app; por omisión el appName de ToolkitProvider
+ * @param {string} [props.brandCaption] el renglón chico debajo del nombre («Panel de administración»)
+ * @param {string} [props.homePath] por omisión '/'
+ * @param {object[]} [props.menuItems] lo que regresa composeMenu
+ * @param {'side'|'top'} [props.menuPosition] por omisión 'side' (MENU_POSITION)
+ * @param {{name: string, email?: string, subtitle?: string, avatarUrl?: string}|null} [props.user] quién está dentro
+ * @param {string} [props.profilePath] la ruta de Mi perfil
+ * @param {object[]} [props.accountMenuItems] renglones propios en el menú de la cuenta ({to | onClick, label | labelKey, Icon})
+ * @param {() => void} [props.onSignOut] sin él no sale «Salir» (una app sin sesión)
+ * @param {boolean} [props.isSigningOut]
+ * @param {import('react').ReactNode} [props.headerActions] botones propios en la barra, antes de la cuenta
+ * @param {Record<string, number>} [props.menuBadges] los conteos del servidor por badgeKey de cada entrada del menú
+ *     (useMenuBadges): lo pendiente de cada pantalla, como numerito
+ * @param {import('react').ReactNode} [props.accountSettings] ajustes propios del proyecto dentro del menú de la cuenta, debajo de
+ *     letra, idioma y claro u oscuro (con SettingSection, para que se vean igual)
+ * @param {import('react').ReactNode} [props.sidebarFooter] lo de abajo del menú lateral (una tarjeta de ayuda…)
+ * @param {boolean} [props.showFontSizeToggle] por omisión sí
+ * @param {boolean} [props.showLanguageToggle] por omisión sí
+ * @param {boolean} [props.showColorSchemeToggle] por omisión sí
+ * @param {import('react').ReactNode} [props.ribbons] avisos propios dentro de la barra
+ * @param {boolean} [props.isNavigating] la pantalla siguiente se está descargando (react-router: useIsNavigating)
+ * @param {boolean} [props.defaultCollapsed] el menú lateral empieza encogido (la persona lo cambia y se recuerda)
+ * @param {boolean} [props.minimizeTabBarOnScroll] en el teléfono con vidrio, la barra de pestañas se encoge al leer hacia
+ *     abajo y regresa al subir (como iOS 26); por omisión sí
+ * @param {number|string} [props.contentMaxWidth] por omisión 1400
+ * @param {(collapsed: boolean) => void} [props.onMenuCollapse] la persona encogió (true) o abrió (false) el menú lateral
+ * @param {(isOpen: boolean) => void} [props.onMobileMenuChange] se abrió o se cerró el menú del teléfono (el cajón)
+ * @param {(keys: string[]|null) => void} [props.onMobileTabsChange] la persona eligió sus pestañas del teléfono (las llaves
+ *     de menuItemKeyOf; null: regresó a las de omisión). Se recuerdan en el navegador; con esto el proyecto las puede guardar
+ *     en su servidor
+ * @param {object} [props.texts] los textos que cambian, con la forma de `layout` en los textos del paquete (para todo el marco)
+ * @param {import('react').ReactNode} props.children el contenido
+ */
+export declare const AppLayout: ({ logo, brandName, brandCaption, homePath, menuItems, menuPosition, user, profilePath, accountMenuItems, onSignOut, isSigningOut, headerActions, accountSettings, menuBadges, sidebarFooter, showFontSizeToggle, showLanguageToggle, showColorSchemeToggle, ribbons, isNavigating, defaultCollapsed, minimizeTabBarOnScroll, contentMaxWidth, onMenuCollapse, onMobileMenuChange, onMobileTabsChange, texts, children, }: {
+    logo?: import('react').ReactNode;
+    brandName?: string;
+    brandCaption?: string;
+    homePath?: string;
+    menuItems?: object[];
+    menuPosition?: 'side' | 'top';
+    user?: {
+        name: string;
+        email?: string;
+        subtitle?: string;
+        avatarUrl?: string;
+    } | null;
+    profilePath?: string;
+    accountMenuItems?: object[];
+    onSignOut?: () => void;
+    isSigningOut?: boolean;
+    headerActions?: import('react').ReactNode;
+    menuBadges?: Record<string, number>;
+    accountSettings?: import('react').ReactNode;
+    sidebarFooter?: import('react').ReactNode;
+    showFontSizeToggle?: boolean;
+    showLanguageToggle?: boolean;
+    showColorSchemeToggle?: boolean;
+    ribbons?: import('react').ReactNode;
+    isNavigating?: boolean;
+    defaultCollapsed?: boolean;
+    minimizeTabBarOnScroll?: boolean;
+    contentMaxWidth?: number | string;
+    onMenuCollapse?: (collapsed: boolean) => void;
+    onMobileMenuChange?: (isOpen: boolean) => void;
+    onMobileTabsChange?: (keys: string[] | null) => void;
+    texts?: object;
+    children: import('react').ReactNode;
+}) => import("react").JSX.Element;

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

@@ -0,0 +1,41 @@
+/**
+ * Un ajuste: su nombre y sus opciones a la vista. Es público: el proyecto agrega los suyos al menú de la cuenta con la
+ * misma forma (AppLayout accountSettings), como el vidrio en los ejemplos.
+ *
+ * @param {object} props
+ * @param {string} props.label ya traducido
+ * @param {string} props.value la opción elegida
+ * @param {Object[]} props.options
+ * @param {string} props.options[].value
+ * @param {string} props.options[].label ya traducido
+ * @param {import('react').ReactNode} [props.options[].icon]
+ * @param {(value: string) => void} props.onChange
+ */
+export declare function SettingSection({ label, value, options, onChange }: {
+    label: string;
+    value: string;
+    options: {
+        value: string;
+        label: string;
+        icon?: import('react').ReactNode;
+    }[];
+    onChange: (value: string) => void;
+}): import("react").JSX.Element;
+/**
+ * @param {object} props
+ * @param {boolean} [props.showFontSize] por omisión sí
+ * @param {boolean} [props.showLanguage] por omisión sí
+ * @param {boolean} [props.showColorScheme] por omisión sí
+ * @param {(level: string) => void} [props.onFontSizeChange] la persona eligió otro tamaño de letra (para guardarlo en su
+ *     servidor; el idioma ya sale por onLanguageChange de ToolkitProvider)
+ * @param {(mode: 'light'|'dark'|'system') => void} [props.onColorSchemeChange] la persona eligió otro modo
+ * @param {object} [props.texts] los textos que cambian, con la forma de `layout` en los textos del paquete
+ */
+export default function AppearanceSettings({ showFontSize, showLanguage, showColorScheme, onFontSizeChange, onColorSchemeChange, texts, }: {
+    showFontSize?: boolean;
+    showLanguage?: boolean;
+    showColorScheme?: boolean;
+    onFontSizeChange?: (level: string) => void;
+    onColorSchemeChange?: (mode: 'light' | 'dark' | 'system') => void;
+    texts?: object;
+}): import("react").JSX.Element[];

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

@@ -0,0 +1,21 @@
+/**
+ * @param {object} props
+ * @param {import('react').ReactNode} [props.logo] el logo chico (28 px)
+ * @param {string} [props.brandName] por omisión el appName de ToolkitProvider
+ * @param {string} props.title el título de la tarjeta y de la pestaña, ya traducido
+ * @param {import('react').ReactNode} [props.description] el renglón debajo del título
+ * @param {import('react').ReactNode} props.children el formulario
+ * @param {import('react').ReactNode} [props.footer] debajo de la tarjeta (los botones de prueba, el aviso de privacidad…)
+ * @param {boolean} [props.showLanguageToggle] por omisión sí
+ * @param {boolean} [props.showColorSchemeToggle] por omisión sí
+ */
+export declare const AuthLayout: ({ logo, brandName, title, description, children, footer, showLanguageToggle, showColorSchemeToggle }: {
+    logo?: import('react').ReactNode;
+    brandName?: string;
+    title: string;
+    description?: import('react').ReactNode;
+    children: import('react').ReactNode;
+    footer?: import('react').ReactNode;
+    showLanguageToggle?: boolean;
+    showColorSchemeToggle?: boolean;
+}) => import("react").JSX.Element;