@stackcraftmx/calcita 0.0.0-stage → 0.25.0

package/dist/types/DataTable/useTableState.d.ts

@@ -0,0 +1,93 @@
+export declare const FILTER_KINDS: Readonly<{
+    text: "text";
+    multiSelect: "multiSelect";
+}>;
+/**
+ * ¿El filtro está puesto? Un texto vacío o una lista vacía no cuentan.
+ *
+ * @param {string|undefined} kind uno de FILTER_KINDS
+ * @param {unknown} value valor del filtro
+ * @returns {boolean}
+ */
+export declare function isFilterActive(kind: string | undefined, value: unknown): boolean;
+/**
+ * "year:desc" → [{column: 'year', direction: 'desc'}].
+ *
+ * @param {string} sortValue valor de la URL
+ * @returns {Array<{column: string, direction: 'asc'|'desc'}>}
+ */
+export declare function parseSortValue(sortValue: string): Array<{
+    column: string;
+    direction: 'asc' | 'desc';
+}>;
+/**
+ * [{column: 'year', direction: 'desc'}] → "year:desc" ('' sin orden).
+ *
+ * @param {Array<{column: string, direction: 'asc'|'desc'}>} sortOrders
+ * @returns {string}
+ */
+export declare function serializeSortOrders(sortOrders: Array<{
+    column: string;
+    direction: 'asc' | 'desc';
+}>): string;
+/**
+ * Filtros con los que arranca una tabla cuando cambia el CONJUNTO que muestra (otro producto, otra pestaña).
+ *
+ * Por qué existe: los filtros, el orden y la página pertenecen al conjunto que se estaba viendo. Si al cambiar de
+ * producto se conservan, la tabla nueva sale filtrada por un estado o un formato que la persona eligió para el otro
+ * producto y parece que "no hay datos". Todo vuelve a su default salvo lo que el cambio fija (p. ej. el producto).
+ *
+ * @param {Record<string, unknown>} filterDefaults campo → valor sin filtro
+ * @param {Record<string, unknown>} values lo que fija el cambio de conjunto ({product: 'SHOES'})
+ * @returns {Record<string, unknown>} todos los filtros en su default más los valores fijados
+ */
+export declare function filtersForDatasetSwitch(filterDefaults: Record<string, unknown>, values: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Estado de una tabla de servidor.
+ *
+ * OJO: filterDefaults y filterKinds se pasan como constantes de módulo (fuera del componente). Un objeto nuevo en
+ * cada render arma parsers nuevos en cada render.
+ *
+ * @param {object} options
+ * @param {string} [options.prefix] con prefijo, en la URL; sin él, en memoria
+ * @param {Record<string, unknown>} [options.filterDefaults] campo → valor sin filtro ('' o [])
+ * @param {Record<string, string>} [options.filterKinds] campo → FILTER_KINDS
+ * @param {number} [options.defaultPageSize]
+ */
+export declare function useTableState({ prefix, filterDefaults, filterKinds, defaultPageSize }: {
+    prefix?: string;
+    filterDefaults?: Record<string, unknown>;
+    filterKinds?: Record<string, string>;
+    defaultPageSize?: number;
+}): {
+    filters: {
+        [k: string]: any;
+    };
+    sortOrders: {
+        column: string;
+        direction: 'asc' | 'desc';
+    }[];
+    page: any;
+    pageSize: any;
+    setFilter: (field: any, value: any) => Promise<URLSearchParams>;
+    setFilters: (values: any) => Promise<URLSearchParams>;
+    clearFilter: (field: any) => Promise<URLSearchParams>;
+    clearAll: () => Promise<URLSearchParams>;
+    setSort: (orders: any) => Promise<URLSearchParams>;
+    switchDataset: (values: any) => Promise<URLSearchParams>;
+    setPage: (page: any) => Promise<URLSearchParams>;
+    setPageSize: (pageSize: any) => Promise<URLSearchParams>;
+} | {
+    filters: any;
+    sortOrders: never[];
+    page: number;
+    pageSize: any;
+    setFilter: (field: any, value: any) => void;
+    setFilters: (values: any) => void;
+    clearFilter: (field: any) => void;
+    clearAll: () => void;
+    setSort: (orders: any) => void;
+    switchDataset: (values: any) => void;
+    setPage: import("react").Dispatch<import("react").SetStateAction<number>>;
+    setPageSize: (nextPageSize: any) => void;
+};

package/dist/types/access/Can.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {object} props
+ * @param {object} props.access la regla (accessRules.js)
+ * @param {import('react').ReactNode} props.children
+ * @param {import('react').ReactNode} [props.fallback] lo que se pinta si no puede; por omisión nada
+ */
+export default function Can({ access, children, fallback }: {
+    access: object;
+    children: import('react').ReactNode;
+    fallback?: import('react').ReactNode;
+}): import("react").ReactNode;

package/dist/types/access/PermissionMatrix.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @param {object} props
+ * @param {Array<{key: string, label: string, permissions: Array<{key: string, label: string, description?: string}>}>} props.groups
+ * @param {string[]} props.value los permisos del perfil
+ * @param {(value: string[]) => void} [props.onChange] sin ella, o con readOnly, solo se ven
+ * @param {boolean} [props.readOnly] un perfil que no se puede cambiar (el de administración)
+ * @param {object} [props.texts] los textos que cambian, con la forma de `access` en los textos del paquete
+ */
+export default function PermissionMatrix({ groups, value, onChange, readOnly, texts }: {
+    groups: Array<{
+        key: string;
+        label: string;
+        permissions: Array<{
+            key: string;
+            label: string;
+            description?: string;
+        }>;
+    }>;
+    value: string[];
+    onChange?: (value: string[]) => void;
+    readOnly?: boolean;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/access/RequireAccess.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {object} props
+ * @param {object} [props.access] la regla (accessRules.js); sin ella se ve
+ * @param {import('react').ReactNode} props.children
+ * @param {import('react').ReactNode} [props.fallback] lo que se ve sin permiso; por omisión la página de 403
+ */
+export default function RequireAccess({ access, children, fallback }: {
+    access?: object;
+    children: import('react').ReactNode;
+    fallback?: import('react').ReactNode;
+}): 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/access/accessRules.d.ts

@@ -0,0 +1,24 @@
+/**
+ * El canAccess de un proyecto que no usa permisos: sin access lo ve cualquiera; con access, nadie (falla cerrado, para
+ * que una regla escrita y sin conectar se note en lugar de abrir todo).
+ *
+ * @param {object|undefined|null} access
+ * @returns {boolean}
+ */
+export declare function allowOnlyUnrestricted(access: object | undefined | null): boolean;
+/**
+ * Arma el canAccess(access) del proyecto con sus permisos, sus roles y sus políticas.
+ *
+ * @param {object} [options]
+ * @param {string[]} [options.abilities] los permisos de la sesión (p. ej. los `abilities` que manda el backend)
+ * @param {string[]} [options.roles] los roles de la sesión
+ * @param {Record<string, (context: any) => boolean>} [options.policies] las políticas con nombre (ABAC); reciben el context
+ * @param {object} [options.context] lo que reciben las políticas y los check (la persona, su organización…)
+ * @returns {(access: object|undefined|null) => boolean}
+ */
+export declare function createAccessChecker({ abilities, roles, policies, context }?: {
+    abilities?: string[];
+    roles?: string[];
+    policies?: Record<string, (context: any) => boolean>;
+    context?: object;
+}): (access: object | undefined | null) => boolean;

package/dist/types/access/permissionGroups.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Los grupos de permisos que declaran los módulos en su menu.js (`export const permissions`), uno por módulo y en el orden
+ * del menú, con el nombre de su entrada del menú como título del grupo.
+ *
+ * @param {Record<string, any>|any[]} menuModules lo que regresa import.meta.glob(..., {eager: true}) o una lista
+ * @param {(key: string, values?: object) => string} t el traductor (para las llaves labelKey y descriptionKey)
+ * @returns {Array<{key: string, label: string, permissions: Array<{key: string, label: string, description?: string}>}>}
+ */
+export declare function composePermissionGroups(menuModules: Record<string, any> | any[], t: (key: string, values?: object) => string): Array<{
+    key: string;
+    label: string;
+    permissions: Array<{
+        key: string;
+        label: string;
+        description?: string;
+    }>;
+}>;
+/**
+ * Cuántos permisos del grupo están dados.
+ *
+ * @param {{permissions: Array<{key: string}>}} group
+ * @param {string[]} granted los permisos del perfil
+ * @returns {{grantedCount: number, total: number, isAll: boolean, isSome: boolean}}
+ */
+export declare function groupStateOf(group: {
+    permissions: Array<{
+        key: string;
+    }>;
+}, granted: string[]): {
+    grantedCount: number;
+    total: number;
+    isAll: boolean;
+    isSome: boolean;
+};
+/**
+ * Prende o apaga un permiso. Lo demás se queda en su orden; uno nuevo va al final.
+ *
+ * @param {string[]} granted
+ * @param {string} permissionKey
+ * @param {boolean} shouldGrant
+ * @returns {string[]} la lista nueva (no cambia la de entrada)
+ */
+export declare function withPermission(granted: string[], permissionKey: string, shouldGrant: boolean): string[];
+/**
+ * Prende o apaga todos los permisos de un grupo. Los que ya estaban se quedan en su lugar; los que faltan van al final.
+ *
+ * @param {string[]} granted
+ * @param {{permissions: Array<{key: string}>}} group
+ * @param {boolean} shouldGrant
+ * @returns {string[]}
+ */
+export declare function withPermissionGroup(granted: string[], group: {
+    permissions: Array<{
+        key: string;
+    }>;
+}, shouldGrant: boolean): string[];

package/dist/types/access/useCan.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {object|undefined|null} access la regla (accessRules.js); sin ella, sí
+ * @returns {boolean}
+ */
+export declare function useCan(access: object | undefined | null): boolean;
+/**
+ * La regla del proyecto, para preguntar por varias cosas a la vez (p. ej. armar el menú).
+ *
+ * @returns {(access: object|undefined|null) => boolean}
+ */
+export declare function useAccessChecker(): (access: object | undefined | null) => boolean;

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

@@ -0,0 +1,27 @@
+/**
+ * @param {object} props
+ * @param {import('./accountConnector.js').AccountConnector} props.connector las llamadas al backend
+ * @param {unknown} [props.refreshKey] al cambiar, la sesión se vuelve a leer (p. ej. el idioma, si el backend manda los
+ *     nombres de los perfiles traducidos)
+ * @param {import('./accountConnector.js').AccountSession|null} [props.initialSession] la sesión que ya se conoce
+ *     (p. ej. la que leyó el servidor al pintar): se usa sin esperar la primera respuesta
+ * @param {(canAccess: (access: object|null|undefined) => boolean) => import('react').ReactNode} props.children recibe la
+ *     regla de permisos de la sesión
+ */
+export default function AccountProvider({ connector, refreshKey, initialSession, children }: {
+    connector: import('./accountConnector.js').AccountConnector;
+    refreshKey?: unknown;
+    initialSession?: import('./accountConnector.js').AccountSession | null;
+    children: (canAccess: (access: object | null | undefined) => boolean) => import('react').ReactNode;
+}): import("react").JSX.Element;
+/**
+ * La cuenta: {session, refreshSession, signOut, connector}. session es null si nadie está dentro.
+ *
+ * @returns {{session: import('./accountConnector.js').AccountSession|null, refreshSession: () => Promise<void>, signOut: () => Promise<void>, connector: import('./accountConnector.js').AccountConnector}}
+ */
+export declare function useAccount(): {
+    session: import('./accountConnector.js').AccountSession | null;
+    refreshSession: () => Promise<void>;
+    signOut: () => Promise<void>;
+    connector: import('./accountConnector.js').AccountConnector;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * @param {object} props
+ * @param {boolean} [props.showPasswordChange] por omisión sí
+ * @param {object} [props.texts] los textos que cambian, con la forma de `account` en los textos del paquete
+ */
+export default function AccountSecuritySection({ showPasswordChange, texts }: {
+    showPasswordChange?: boolean;
+    texts?: object;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,6 @@
+/**
+ * @param {{loadCode: () => Promise<string|null>}} props
+ */
+export default function DemoTotpCodeButton({ loadCode }: {
+    loadCode: () => Promise<string | null>;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,17 @@
+/**
+ * @param {object} props
+ * @param {string} [props.signInPath] la liga para regresar a entrar
+ * @param {import('react').ReactNode} [props.logo]
+ * @param {string} [props.brandName]
+ * @param {boolean} [props.showLanguageToggle]
+ * @param {boolean} [props.showColorSchemeToggle]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `auth` en los textos del paquete
+ */
+export default function ForgotPasswordScreen({ signInPath, logo, brandName, showLanguageToggle, showColorSchemeToggle, texts }: {
+    signInPath?: string;
+    logo?: import('react').ReactNode;
+    brandName?: string;
+    showLanguageToggle?: boolean;
+    showColorSchemeToggle?: boolean;
+    texts?: object;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,43 @@
+/** Las pestañas, en el orden en que se pintan. */
+export declare const PROFILE_TAB: Readonly<{
+    data: "data";
+    security: "security";
+    preferences: "preferences";
+}>;
+export type AccountUser = import('./accountConnector.js').AccountUser;
+/** @typedef {import('./accountConnector.js').AccountUser} AccountUser */
+/**
+ * @param {object} props
+ * @param {boolean} [props.showColorScheme] el ajuste de claro u oscuro en Preferencias; sin modo oscuro, false
+ * @param {{initialValues?: (user: AccountUser & Record<string, any>) => Record<string, any>, rules?: Record<string, any>, fields: import('react').ReactNode}} [props.extraFields]
+ *     campos propios en «Sus datos», debajo del teléfono: sus valores de inicio salen del usuario de la sesión (lo que su
+ *     conector ponga en session.user), sus reglas de yup y sus campos (FormTextField, FormSelectField… de /forms). Al guardar
+ *     viajan a connector.updateProfile junto con name y phone
+ * @param {Array<{key: string, label: string, content: import('react').ReactNode}>} [props.extraTabs] pestañas propias,
+ *     después de las de la casa; label ya traducido
+ * @param {Array<'data'|'security'|'preferences'>} [props.hiddenTabs] pestañas de la casa que no se ven (PROFILE_TAB)
+ * @param {(tab: string) => void} [props.onTabChange] cada que se cambia de pestaña
+ * @param {(saved: {values: Record<string, any>, response: unknown}) => void} [props.onProfileSaved] después de guardar «Sus datos»
+ * @param {object} [props.texts] los textos que cambian, con la forma de `account` en los textos del paquete:
+ *     {profile: {tabs: {data: 'Mis datos'}}}
+ */
+export default function ProfileScreen({ showColorScheme, extraFields, extraTabs, hiddenTabs, onTabChange, onProfileSaved, texts, }: {
+    showColorScheme?: boolean;
+    extraFields?: {
+        initialValues?: (user: AccountUser & Record<string, any>) => Record<string, any>;
+        rules?: Record<string, any>;
+        fields: import('react').ReactNode;
+    };
+    extraTabs?: Array<{
+        key: string;
+        label: string;
+        content: import('react').ReactNode;
+    }>;
+    hiddenTabs?: Array<'data' | 'security' | 'preferences'>;
+    onTabChange?: (tab: string) => void;
+    onProfileSaved?: (saved: {
+        values: Record<string, any>;
+        response: unknown;
+    }) => void;
+    texts?: object;
+}): import("react").JSX.Element | null;

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

@@ -0,0 +1,21 @@
+/**
+ * @param {object} props
+ * @param {string} props.signInPath a dónde ir al terminar
+ * @param {string} [props.forgotPasswordPath] para pedir otro enlace si este no sirve
+ * @param {string} [props.tokenParam] cómo se llama la clave en la dirección; por omisión 'token'
+ * @param {import('react').ReactNode} [props.logo]
+ * @param {string} [props.brandName]
+ * @param {boolean} [props.showLanguageToggle]
+ * @param {boolean} [props.showColorSchemeToggle]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `account` en los textos del paquete
+ */
+export default function ResetPasswordScreen({ signInPath, forgotPasswordPath, tokenParam, logo, brandName, showLanguageToggle, showColorSchemeToggle, texts, }: {
+    signInPath: string;
+    forgotPasswordPath?: string;
+    tokenParam?: string;
+    logo?: import('react').ReactNode;
+    brandName?: string;
+    showLanguageToggle?: boolean;
+    showColorSchemeToggle?: boolean;
+    texts?: object;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,27 @@
+/**
+ * @param {object} props
+ * @param {string} [props.homePath] a dónde ir si no se quería abrir otra pantalla; por omisión '/'
+ * @param {string} [props.forgotPasswordPath] sin ella no sale «¿Olvidó su contraseña?»
+ * @param {import('react').ReactNode} [props.logo]
+ * @param {string} [props.brandName] por omisión el appName de ToolkitProvider
+ * @param {import('react').ReactNode | ((helpers: {signIn: (credentials: {email: string, password: string, remember?: boolean}) => Promise<void>}) => import('react').ReactNode)} [props.footer]
+ * @param {boolean} [props.showLanguageToggle] por omisión sí
+ * @param {boolean} [props.showColorSchemeToggle] por omisión sí
+ * @param {object} [props.texts] los textos que cambian, con la forma de `auth` en los textos del paquete
+ */
+export default function SignInScreen({ homePath, forgotPasswordPath, logo, brandName, footer, showLanguageToggle, showColorSchemeToggle, texts }: {
+    homePath?: string;
+    forgotPasswordPath?: string;
+    logo?: import('react').ReactNode;
+    brandName?: string;
+    footer?: import('react').ReactNode | ((helpers: {
+        signIn: (credentials: {
+            email: string;
+            password: string;
+            remember?: boolean;
+        }) => Promise<void>;
+    }) => import('react').ReactNode);
+    showLanguageToggle?: boolean;
+    showColorSchemeToggle?: boolean;
+    texts?: object;
+}): import("react").JSX.Element | null;

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

@@ -0,0 +1,268 @@
+export type AccountUser = {
+    id: string;
+    name: string;
+    email: string;
+    /**
+     * el renglón bajo el nombre (puesto · sucursal)
+     */
+    subtitle?: string;
+    phone?: string;
+    avatarUrl?: string;
+};
+export type AccountSession = {
+    user: AccountUser;
+    roles?: string[];
+    abilities?: string[];
+    /**
+     * sus perfiles o etiquetas, ya traducidos (salen como chips en Mi perfil)
+     */
+    labels?: string[];
+};
+export type AccountSecurity = {
+    isEnabled: boolean;
+    enabledAt?: string | null;
+    passkeys: Array<{
+        id: string;
+        name: string;
+        createdAt: string;
+        lastUsedAt?: string | null;
+    }>;
+    totp: {
+        isEnabled: boolean;
+        enabledAt?: string | null;
+    };
+    recoveryCodesRemaining: number;
+};
+export type AccountSecurityChange = {
+    security: AccountSecurity;
+    recoveryCodes?: string[];
+};
+export type AccountDeviceSession = {
+    id: string;
+    browser?: string | null;
+    platform?: string | null;
+    isMobile?: boolean;
+    /**
+     * instante ISO
+     */
+    startedAt: string;
+    /**
+     * a medias (187.190.x.x), nunca la IP completa
+     */
+    network?: string | null;
+    isCurrent?: boolean;
+};
+export type AccountEvent = {
+    id: string;
+    /**
+     * uno de ACCOUNT_EVENT_KIND
+     */
+    kind: string;
+    /**
+     * instante ISO
+     */
+    occurredAt: string;
+    device?: string | null;
+    network?: string | null;
+};
+export type AccountConnector = {
+    /**
+     * quién está dentro; null si nadie
+     */
+    loadSession: () => Promise<AccountSession | null>;
+    /**
+     *     con verificación en dos pasos regresa los métodos del segundo paso (SECOND_STEP_METHOD); sin ella, secondStep null
+     *     y ya está dentro
+     */
+    signIn: (credentials: {
+        email: string;
+        password: string;
+        remember: boolean;
+    }) => Promise<{
+        secondStep: {
+            methods: string[];
+        } | null;
+    }>;
+    /**
+     * el código de la app (totp) o uno
+     * de recuperación (recoveryCode)
+     */
+    signInSecondStep: (input: {
+        method: string;
+        code: string;
+    }) => Promise<void>;
+    /**
+     * las opciones de WebAuthn para firmar (JSON del servidor)
+     */
+    secondStepPasskeyOptions: () => Promise<object>;
+    /**
+     * la firma del navegador (JSON de WebAuthn)
+     */
+    signInWithPasskey: (credential: any) => Promise<void>;
+    signOut: () => Promise<void>;
+    /**
+     * contesta igual exista o no el correo
+     */
+    requestPasswordReset: (input: {
+        email: string;
+    }) => Promise<void>;
+    /**
+     * desde el enlace del correo
+     */
+    resetPassword: (input: {
+        token: string;
+        newPassword: string;
+    }) => Promise<void>;
+    /**
+     * name, phone y
+     * los campos propios de ProfileScreen (extraFields)
+     */
+    updateProfile: (input: {
+        name: string;
+        phone: string;
+    } & Record<string, any>) => Promise<{
+        message?: string;
+    } | void>;
+    changePassword: (input: {
+        currentPassword?: string;
+        newPassword: string;
+    }) => Promise<void>;
+    loadSecurity: () => Promise<AccountSecurity>;
+    /**
+     * una clave nueva (todavía sin activar)
+     */
+    startTotp: () => Promise<{
+        secret: string;
+        qrImageUrl?: string | null;
+    }>;
+    confirmTotp: (code: string) => Promise<AccountSecurityChange>;
+    disableTotp: (password: string) => Promise<AccountSecurityChange>;
+    /**
+     * las opciones de WebAuthn para crear una llave
+     */
+    passkeyRegistrationOptions: () => Promise<object>;
+    savePasskey: (input: {
+        name: string;
+        credential: any;
+    }) => Promise<AccountSecurityChange>;
+    removePasskey: (input: {
+        passkeyId: string;
+        password: string;
+    }) => Promise<AccountSecurityChange>;
+    regenerateRecoveryCodes: (password: string) => Promise<AccountSecurityChange>;
+    listSessions: () => Promise<AccountDeviceSession[]>;
+    /**
+     * cuántas cerró
+     */
+    closeOtherSessions: () => Promise<number>;
+    /**
+     * de lo más nuevo a lo más viejo
+     */
+    listActivity: () => Promise<AccountEvent[]>;
+    /**
+     * SOLO en la demostración: el código que enseñaría la app ahorita
+     * (con él sale el botón «Usar el código de ejemplo»)
+     */
+    demoTotpCode?: () => Promise<string | null>;
+};
+/**
+ * Quien está dentro, como lo pintan la barra y Mi perfil.
+ *
+ * @typedef {object} AccountUser
+ * @property {string} id
+ * @property {string} name
+ * @property {string} email
+ * @property {string} [subtitle] el renglón bajo el nombre (puesto · sucursal)
+ * @property {string} [phone]
+ * @property {string} [avatarUrl]
+ */
+/**
+ * La sesión: quién está dentro y sus permisos (los lee createAccessChecker).
+ *
+ * @typedef {object} AccountSession
+ * @property {AccountUser} user
+ * @property {string[]} [roles]
+ * @property {string[]} [abilities]
+ * @property {string[]} [labels] sus perfiles o etiquetas, ya traducidos (salen como chips en Mi perfil)
+ */
+/**
+ * El estado de la verificación en dos pasos (el que pinta TwoStepVerificationCard).
+ *
+ * @typedef {object} AccountSecurity
+ * @property {boolean} isEnabled
+ * @property {string|null} [enabledAt]
+ * @property {Array<{id: string, name: string, createdAt: string, lastUsedAt?: string|null}>} passkeys
+ * @property {{isEnabled: boolean, enabledAt?: string|null}} totp
+ * @property {number} recoveryCodesRemaining
+ */
+/**
+ * Lo que regresa un cambio de seguridad: el estado nuevo y, si se generaron, los códigos de recuperación (se enseñan una
+ * sola vez).
+ *
+ * @typedef {object} AccountSecurityChange
+ * @property {AccountSecurity} security
+ * @property {string[]} [recoveryCodes]
+ */
+/**
+ * Un equipo donde la cuenta está abierta.
+ *
+ * @typedef {object} AccountDeviceSession
+ * @property {string} id
+ * @property {string|null} [browser]
+ * @property {string|null} [platform]
+ * @property {boolean} [isMobile]
+ * @property {string} startedAt instante ISO
+ * @property {string|null} [network] a medias (187.190.x.x), nunca la IP completa
+ * @property {boolean} [isCurrent]
+ */
+/**
+ * Un renglón de la bitácora de la cuenta.
+ *
+ * @typedef {object} AccountEvent
+ * @property {string} id
+ * @property {string} kind uno de ACCOUNT_EVENT_KIND
+ * @property {string} occurredAt instante ISO
+ * @property {string|null} [device]
+ * @property {string|null} [network]
+ */
+/**
+ * El conector completo.
+ *
+ * @typedef {object} AccountConnector
+ * @property {() => Promise<AccountSession|null>} loadSession quién está dentro; null si nadie
+ * @property {(credentials: {email: string, password: string, remember: boolean}) => Promise<{secondStep: {methods: string[]}|null}>} signIn
+ *     con verificación en dos pasos regresa los métodos del segundo paso (SECOND_STEP_METHOD); sin ella, secondStep null
+ *     y ya está dentro
+ * @property {(input: {method: string, code: string}) => Promise<void>} signInSecondStep el código de la app (totp) o uno
+ *     de recuperación (recoveryCode)
+ * @property {() => Promise<object>} secondStepPasskeyOptions las opciones de WebAuthn para firmar (JSON del servidor)
+ * @property {(credential: any) => Promise<void>} signInWithPasskey la firma del navegador (JSON de WebAuthn)
+ * @property {() => Promise<void>} signOut
+ * @property {(input: {email: string}) => Promise<void>} requestPasswordReset contesta igual exista o no el correo
+ * @property {(input: {token: string, newPassword: string}) => Promise<void>} resetPassword desde el enlace del correo
+ * @property {(input: {name: string, phone: string} & Record<string, any>) => Promise<{message?: string}|void>} updateProfile name, phone y
+ *     los campos propios de ProfileScreen (extraFields)
+ * @property {(input: {currentPassword?: string, newPassword: string}) => Promise<void>} changePassword
+ * @property {() => Promise<AccountSecurity>} loadSecurity
+ * @property {() => Promise<{secret: string, qrImageUrl?: string|null}>} startTotp una clave nueva (todavía sin activar)
+ * @property {(code: string) => Promise<AccountSecurityChange>} confirmTotp
+ * @property {(password: string) => Promise<AccountSecurityChange>} disableTotp
+ * @property {() => Promise<object>} passkeyRegistrationOptions las opciones de WebAuthn para crear una llave
+ * @property {(input: {name: string, credential: any}) => Promise<AccountSecurityChange>} savePasskey
+ * @property {(input: {passkeyId: string, password: string}) => Promise<AccountSecurityChange>} removePasskey
+ * @property {(password: string) => Promise<AccountSecurityChange>} regenerateRecoveryCodes
+ * @property {() => Promise<AccountDeviceSession[]>} listSessions
+ * @property {() => Promise<number>} closeOtherSessions cuántas cerró
+ * @property {() => Promise<AccountEvent[]>} listActivity de lo más nuevo a lo más viejo
+ * @property {() => Promise<string|null>} [demoTotpCode] SOLO en la demostración: el código que enseñaría la app ahorita
+ *     (con él sale el botón «Usar el código de ejemplo»)
+ */
+/** Las funciones que todo conector trae (demoTotpCode es opcional: solo la demostración). */
+export declare const ACCOUNT_CONNECTOR_FUNCTIONS: readonly string[];
+/**
+ * Las funciones que le faltan al conector (un error de quien lo escribió: se avisa al arrancar, no al picar un botón).
+ *
+ * @param {object|null|undefined} connector
+ * @returns {string[]}
+ */
+export declare function missingConnectorFunctionsOf(connector: object | null | undefined): string[];