@stackcraftmx/calcita 0.0.0-stage → 0.23.0

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

@@ -0,0 +1,93 @@
+export type GridColumnProps = {
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    align?: 'left' | 'center' | 'right';
+    headerAlign?: 'left' | 'center' | 'right';
+    valueFormatter?: (value: any, row: any) => string;
+    valueGetter?: (value: any, row: any) => any;
+    renderCell?: (params: any) => import('react').ReactNode;
+} & Record<string, any>;
+/**
+ * Las props de columna del DataGrid que más se usan, con su tipo, y cualquier otra suya (Record). OJO: tipo propio y no
+ * GridColDef del DataGrid: apuntar a sus tipos hace que un proyecto estricto (skipLibCheck: false) revise los internos del
+ * DataGrid, que no compilan con TypeScript 7.
+ *
+ * @typedef {{width?: number, minWidth?: number, maxWidth?: number, flex?: number, align?: 'left'|'center'|'right', headerAlign?: 'left'|'center'|'right', valueFormatter?: (value: any, row: any) => string, valueGetter?: (value: any, row: any) => any, renderCell?: (params: any) => import('react').ReactNode} & Record<string, any>} GridColumnProps
+ */
+/**
+ * Columna de texto con orden y filtro "contiene" en el servidor.
+ *
+ * @param {{field: string, label: string, sort?: boolean, filter?: boolean} & GridColumnProps} columnDeclaration
+ *     label ya traducido; lo demás son props de columna del DataGrid (width, flex, valueFormatter, renderCell…)
+ */
+export declare function textColumn({ field, label, sort, filter, ...gridColumnProps }: {
+    field: string;
+    label: string;
+    sort?: boolean;
+    filter?: boolean;
+} & GridColumnProps): {
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    align?: 'left' | 'center' | 'right';
+    headerAlign?: 'left' | 'center' | 'right';
+    valueFormatter?: (value: any, row: any) => string;
+    valueGetter?: (value: any, row: any) => any;
+    renderCell?: (params: any) => import('react').ReactNode;
+    field: string;
+    headerName: string;
+    sortable: boolean;
+    filterable: boolean;
+    renderHeader: () => import("react").JSX.Element;
+};
+/**
+ * Columna con filtro de opciones alimentado por las FACETAS del servidor.
+ *
+ * @param {{field: string, label: string, facetKey?: string, renderOption?: (value: string) => import('react').ReactNode, sort?: boolean} & GridColumnProps} columnDeclaration
+ */
+export declare function facetColumn({ field, label, facetKey, renderOption, sort, ...gridColumnProps }: {
+    field: string;
+    label: string;
+    facetKey?: string;
+    renderOption?: (value: string) => import('react').ReactNode;
+    sort?: boolean;
+} & GridColumnProps): {
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    align?: 'left' | 'center' | 'right';
+    headerAlign?: 'left' | 'center' | 'right';
+    valueFormatter?: (value: any, row: any) => string;
+    valueGetter?: (value: any, row: any) => any;
+    renderCell?: (params: any) => import('react').ReactNode;
+    field: string;
+    headerName: string;
+    sortable: boolean;
+    filterable: boolean;
+    renderHeader: () => import("react").JSX.Element;
+};
+/**
+ * Columna de acción al final de la fila: un icono que abre el detalle (la ruta propia del renglón). Un icono y no la
+ * fila entera a propósito: la fila como botón se dispara al seleccionar texto y no se ve que se puede abrir.
+ *
+ * @param {{onOpen: (row: any) => void, ariaLabelOf?: (row: any) => string}} declaration ariaLabelOf ya traducido
+ */
+export declare function detailColumn({ onOpen, ariaLabelOf }: {
+    onOpen: (row: any) => void;
+    ariaLabelOf?: (row: any) => string;
+}): {
+    field: string;
+    headerName: string;
+    sortable: boolean;
+    filterable: boolean;
+    disableColumnMenu: boolean;
+    width: number;
+    align: string;
+    renderCell: ({ row }: {
+        row: any;
+    }) => import("react").JSX.Element;
+};

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

@@ -0,0 +1,13 @@
+export declare const TableFilterContext: import("react").Context<null>;
+/**
+ * @returns {{filters: object, setFilter: Function, clearFilter: Function, sortOrders: Array, toggleSort: Function, clearSort: Function, facets: object}}
+ */
+export declare function useTableFilter(): {
+    filters: object;
+    setFilter: Function;
+    clearFilter: Function;
+    sortOrders: any[];
+    toggleSort: Function;
+    clearSort: Function;
+    facets: object;
+};

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

@@ -0,0 +1,13 @@
+export { default as AuditTrailDialog } from './AuditTrailDialog.js';
+export { default as AuditTrailTable } from './AuditTrailTable.js';
+export { default as EmptyState } from './EmptyState.js';
+export { default as FilterChips } from './FilterChips.js';
+export { default as GoToPage } from './GoToPage.js';
+export { default as ServerTable } from './ServerTable.js';
+export { buildChipConfig } from './buildChipConfig.js';
+export { detailColumn, facetColumn, textColumn } from './columns.js';
+export { TableFilterContext, useTableFilter } from './filterContext.js';
+export { toServerTableParams } from './serverTableParams.js';
+export { buildTableActors, tableMachine } from './tableMachine.js';
+export { useDebouncedFilter } from './useDebouncedFilter.js';
+export { FILTER_KINDS, isFilterActive, useTableState } from './useTableState.js';

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

@@ -0,0 +1,16 @@
+/**
+ * @param {{filters?: object, sortOrders?: Array<{column: string, direction: 'asc'|'desc'}>, page: number, pageSize: number}} tableRequest
+ * @param {{parameterNames?: Record<string, string>}} [options] campo de la tabla → nombre del parámetro en el API
+ * @returns {Record<string, unknown>} params para getInfo
+ */
+export declare function toServerTableParams({ filters, sortOrders, page, pageSize }: {
+    filters?: object;
+    sortOrders?: Array<{
+        column: string;
+        direction: 'asc' | 'desc';
+    }>;
+    page: number;
+    pageSize: number;
+}, { parameterNames }?: {
+    parameterNames?: Record<string, string>;
+}): Record<string, unknown>;

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

@@ -0,0 +1,41 @@
+/**
+ * ¿El error es una cancelación (axios o fetch)? Cancelar una consulta que ya no interesa no es un error que mostrar.
+ *
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+export declare function isCancellation(error: unknown): boolean;
+export declare const tableMachine: 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: "fetchPage";
+    logic: import("xstate").PromiseActorLogic<never, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+}, never, {
+    type: "isCancellation";
+    params: unknown;
+} | {
+    type: "isStaleResponse";
+    params: unknown;
+}, never, {}, string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    states?: {} | undefined;
+    id?: string | undefined;
+}, import("xstate").MetaObject>;
+/**
+ * El actor fetchPage a partir de la función de la pantalla.
+ *
+ * @param {(params: {filters: object, sortOrders: Array, page: number, pageSize: number}, signal: AbortSignal) => Promise<{rows: Array, total: number, facets?: object, capped?: boolean}>} fetchPage
+ */
+export declare function buildTableActors(fetchPage: (params: {
+    filters: object;
+    sortOrders: any[];
+    page: number;
+    pageSize: number;
+}, signal: AbortSignal) => Promise<{
+    rows: any[];
+    total: number;
+    facets?: object;
+    capped?: boolean;
+}>): {
+    fetchPage: import("xstate").PromiseActorLogic<any, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+};

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

@@ -0,0 +1,8 @@
+export declare const DEFAULT_DEBOUNCE_MILLISECONDS = 350;
+/**
+ * @param {string|undefined} value valor confirmado (el de la URL)
+ * @param {(value: string) => void} commit se llama con el valor ya rebotado
+ * @param {number} [delayMilliseconds]
+ * @returns {[string, (value: string) => void]} borrador que pinta la caja y su setter
+ */
+export declare function useDebouncedFilter(value: string | undefined, commit: (value: string) => void, delayMilliseconds?: number): [string, (value: string) => void];

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,21 @@
+/**
+ * @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)
+ */
+export default function PermissionMatrix({ groups, value, onChange, readOnly }: {
+    groups: Array<{
+        key: string;
+        label: string;
+        permissions: Array<{
+            key: string;
+            label: string;
+            description?: string;
+        }>;
+    }>;
+    value: string[];
+    onChange?: (value: string[]) => void;
+    readOnly?: boolean;
+}): 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,7 @@
+/**
+ * @param {object} props
+ * @param {boolean} [props.showPasswordChange] por omisión sí
+ */
+export default function AccountSecuritySection({ showPasswordChange }: {
+    showPasswordChange?: boolean;
+}): 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,15 @@
+/**
+ * @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]
+ */
+export default function ForgotPasswordScreen({ signInPath, logo, brandName, showLanguageToggle, showColorSchemeToggle }: {
+    signInPath?: string;
+    logo?: import('react').ReactNode;
+    brandName?: string;
+    showLanguageToggle?: boolean;
+    showColorSchemeToggle?: boolean;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,13 @@
+/** Las pestañas, en el orden en que se pintan. */
+export declare const PROFILE_TAB: Readonly<{
+    data: "data";
+    security: "security";
+    preferences: "preferences";
+}>;
+/**
+ * @param {object} props
+ * @param {boolean} [props.showColorScheme] el ajuste de claro u oscuro en Preferencias; sin modo oscuro, false
+ */
+export default function ProfileScreen({ showColorScheme }: {
+    showColorScheme?: boolean;
+}): import("react").JSX.Element | null;

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

@@ -0,0 +1,19 @@
+/**
+ * @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]
+ */
+export default function ResetPasswordScreen({ signInPath, forgotPasswordPath, tokenParam, logo, brandName, showLanguageToggle, showColorSchemeToggle, }: {
+    signInPath: string;
+    forgotPasswordPath?: string;
+    tokenParam?: string;
+    logo?: import('react').ReactNode;
+    brandName?: string;
+    showLanguageToggle?: boolean;
+    showColorSchemeToggle?: boolean;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,25 @@
+/**
+ * @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í
+ */
+export default function SignInScreen({ homePath, forgotPasswordPath, logo, brandName, footer, showLanguageToggle, showColorSchemeToggle }: {
+    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;
+}): import("react").JSX.Element | null;