@nocios/crudify-components 2.0.61 → 2.0.88

package/dist/index.d.ts

@@ -1,17 +1,71 @@
 import { CrudifyInstance } from '@nocios/crudify-sdk';
 export * from '@nocios/crudify-sdk';
 export { CrudifyInstance } from '@nocios/crudify-sdk';
-import { g as CrudifyLoginConfig, E as EvaluatedPasswordRule, l as PasswordRule } from './CrudiaMarkdownField-CkiBwG-U.js';
-export { B as BoxScreenType, C as CrudiaAutoGenerate, a as CrudiaAutoGenerateProps, b as CrudiaFileField, m as CrudiaFileFieldDeletionHandlers, c as CrudiaFileFieldProps, d as CrudiaMarkdownField, e as CrudiaMarkdownFieldProps, f as CrudifyLogin, h as CrudifyLoginProps, i as CrudifyLoginTranslations, D as DEFAULT_PASSWORD_RULES, L as LoginComponent, n as POLICY_ACTIONS, o as PREFERRED_POLICY_ORDER, p as PasswordRuleType, P as Policies, j as PolicyAction, S as SessionStatus, U as UserLoginData, k as UserProfileDisplay } from './CrudiaMarkdownField-CkiBwG-U.js';
-import React, { ReactNode } from 'react';
-export { A as ApiError, f as CrudifyApiResponse, a as CrudifyEnvironment, g as CrudifyOperationOptions, h as CrudifyRequestOptions, i as CrudifyTransactionResponse, F as ForgotPasswordRequest, J as JwtPayload, L as LoginRequest, j as LoginResponse, k as ResetPasswordRequest, b as ResolvedTenantConfig, T as TenantConfig, c as TenantConfigOptions, l as TransactionInput, m as TransactionOperation, n as TransactionResponseData, U as UserProfile, V as ValidateCodeRequest, o as ValidationError, d as resolveTenantConfig, e as useTenantConfig } from './tenantConfig-CYnS9TPV.js';
-export { F as FileItem, a as FileStatus, L as LoginResult, N as NotificationOptions, S as SessionConfig, b as SessionDebugInfo, c as SessionManager, d as SessionProvider, e as SessionProviderProps, f as SessionState, g as StorageType, T as TokenData, h as TokenStorage, U as UseAuthReturn, i as UseDataReturn, j as UseFileUploadOptions, k as UseFileUploadReturn, l as UseSessionOptions, m as UseUserDataOptions, n as UseUserDataReturn, o as UserData, u as useAuth, p as useCrudifyWithNotifications, q as useData, r as useFileUpload, s as useSession, t as useSessionContext, v as useUserData, w as useUserProfile } from './index-DEDnmsdO.js';
+import React, { ReactNode, RefObject } from 'react';
+import { PasswordRule, FrontendEnvironment, AdminApiResponse, ModuleDefinition, ModuleCreateInput, ModuleEditInput, ModuleVersionItem, AdminActionFilters, ActionDefinition, ActionCreateInput, ActionEditInput, ActionVersionItem, UpdateActionsProfilesInput, UpdateActionsProfilesResponse, CalculatePermissionsInput, CalculatePermissionsResponse } from '@nocios/frontend-types';
+export { CrudifyOperationOptions, CrudifyRequestOptions, CrudifyResponse, CrudifyTransactionResponse, FrontendEnvironment, PasswordRule, PasswordRuleType, TenantConfig, TransactionInput, TransactionOperation, TransactionResponseData } from '@nocios/frontend-types';
+import { PolicyAction } from './public-policies.js';
+export { POLICY_ACTIONS, PREFERRED_POLICY_ORDER } from './public-policies.js';
+export { A as ApiError, F as ForgotPasswordRequest, J as JwtPayload, L as LoginRequest, a as LoginResponse, R as ResetPasswordRequest, U as UserProfile, V as ValidateCodeRequest, b as ValidationError } from './api-jcCTCqPD.js';
+import { A as AutoGenerateConfig } from './index-rHtWMls-.js';
+export { F as FileItem, a as FileStatus, G as GlobalNotificationProvider, b as GlobalNotificationProviderProps, L as LoginResult, N as Notification, c as NotificationOptions, d as NotificationSeverity, S as SessionConfig, e as SessionDebugInfo, f as SessionManager, g as SessionProvider, h as SessionProviderProps, i as SessionState, j as StorageType, T as TokenData, k as TokenStorage, U as UseAuthReturn, l as UseAutoGenerateOptions, m as UseAutoGenerateReturn, n as UseDataReturn, o as UseFileUploadOptions, p as UseFileUploadReturn, q as UseSessionOptions, r as UseUserDataOptions, s as UseUserDataReturn, t as UserData, u as useAuth, v as useAutoGenerate, w as useCrudifyWithNotifications, x as useData, y as useFileUpload, z as useGlobalNotification, B as useSession, C as useSessionContext, D as useUserData, E as useUserProfile } from './index-rHtWMls-.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ThemeOptions } from '@mui/material';
-export { A as AutoGenerateConfig, G as GlobalNotificationProvider, a as GlobalNotificationProviderProps, N as Notification, b as NotificationSeverity, U as UseAutoGenerateOptions, c as UseAutoGenerateReturn, d as useAutoGenerate, u as useGlobalNotification } from './GlobalNotificationProvider-CdwdNv_8.js';
-export { E as ERROR_CODES, a as ERROR_SEVERITY_MAP, b as ErrorCode, c as ErrorSeverity, d as ErrorTranslationConfig, P as ParsedError, e as createErrorTranslator, f as decodeJwtSafely, g as getCurrentUserEmail, h as getErrorMessage, i as handleCrudifyError, j as isTokenExpired, p as parseApiError, k as parseJavaScriptError, l as parseTransactionError, s as secureLocalStorage, m as secureSessionStorage, t as translateError, n as translateErrorCode, o as translateErrorCodes } from './errorTranslation-CF-5JClP.js';
-import { ApiResponse, IModule, ModuleCreateInput, ModuleEditInput, ActionListFilters, IAction, ActionCreateInput, ActionEditInput, UpdateActionsProfilesInput, UpdateActionsProfilesResponse, CalculatePermissionsInput, CalculatePermissionsResponse } from '@nocios/crudify-admin-sdk';
-export { ActionCreateInput, ActionEditInput, ActionListFilters, ApiResponse, IAction, IModule, ModuleCreateInput, ModuleEditInput, UpdateActionsProfilesInput, UpdateActionsProfilesResponse } from '@nocios/crudify-admin-sdk';
+import { LogContext } from '@nocios/frontend-types/shared';
+export { LogContext, LogLevel } from '@nocios/frontend-types/shared';
+export { C as CrudifyEnvironment, E as ERROR_CODES, a as ERROR_SEVERITY_MAP, b as ErrorCode, c as ErrorSeverity, d as ErrorTranslationConfig, P as ParsedError, R as ResolvedTenantConfig, T as TenantConfigOptions, e as createErrorTranslator, f as decodeJwtSafely, g as getCurrentUserEmail, h as getErrorMessage, i as handleCrudifyError, j as isTokenExpired, p as parseApiError, k as parseJavaScriptError, l as parseTransactionError, r as resolveTenantConfig, s as secureLocalStorage, m as secureSessionStorage, t as translateError, n as translateErrorCode, o as translateErrorCodes, u as useTenantConfig } from './errorTranslation-BdqG-dXD.js';
+
+/**
+ * Password validation types and constants
+ * Used for password requirements validation in forms
+ */
+
+interface EvaluatedPasswordRule {
+    message: string;
+    valid: boolean;
+    enforce: boolean;
+}
+/**
+ * Default password rules used as fallback when no custom rules are provided.
+ * Messages are translation keys that should be translated at runtime.
+ */
+declare const DEFAULT_PASSWORD_RULES: PasswordRule[];
+
+type BoxScreenType = 'login' | 'signUp' | 'forgotPassword' | 'resetPassword' | 'checkCode';
+interface CrudifyLoginConfig {
+    publicApiKey?: string | null;
+    env?: FrontendEnvironment;
+    appName?: string;
+    logo?: string;
+    loginActions?: string[];
+}
+interface CrudifyLoginTranslations {
+    [key: string]: string | CrudifyLoginTranslations;
+}
+interface UserLoginData {
+    token: string;
+    username?: string;
+    email?: string;
+    userId?: string;
+    profile?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface CrudifyLoginProps {
+    onScreenChange?: (screen: BoxScreenType, params?: Record<string, string>) => void;
+    onExternalNavigate?: (path: string) => void;
+    onLoginSuccess?: (userData: UserLoginData, redirectUrl?: string) => void;
+    onError?: (error: string) => void;
+    initialScreen?: BoxScreenType;
+    redirectUrl?: string;
+    autoReadFromCookies?: boolean;
+    translations?: CrudifyLoginTranslations;
+    translationsUrl?: string;
+    language?: string;
+    /** Custom password rules for reset password form. Falls back to default rules if not provided. */
+    passwordRules?: PasswordRule[];
+}
+
+declare const CrudifyLogin: React.FC<CrudifyLoginProps>;
 
 interface CrudifyContextValue {
     crudify: typeof CrudifyInstance | null;
@@ -30,12 +84,41 @@ interface CrudifyProviderProps {
 declare const CrudifyProvider: React.FC<CrudifyProviderProps>;
 declare const useCrudify: () => CrudifyContextValue;
 
+interface UserProfileDisplayProps {
+    showExtendedData?: boolean;
+    showProfileCard?: boolean;
+    autoRefresh?: boolean;
+}
+declare const UserProfileDisplay: React.FC<UserProfileDisplayProps>;
+
+type Policy = {
+    id: string;
+    action: PolicyAction;
+    fields?: {
+        allow: string[];
+        owner_allow: string[];
+        deny: string[];
+    };
+    permission?: string;
+};
+type FieldErrorMap = string | ({
+    _error?: string;
+} & Record<string, string | undefined>);
+interface PoliciesProps {
+    policies: Policy[];
+    onChange: (next: Policy[]) => void;
+    availableFields: string[];
+    errors?: FieldErrorMap;
+    isSubmitting?: boolean;
+}
+declare const Policies: React.FC<PoliciesProps>;
+
 /**
- * Tipos de mensajes que se pueden enviar entre tabs
+ * Types of messages that can be sent between tabs
  */
 type CrossTabMessageType = 'SESSION_STARTED' | 'SESSION_ENDED' | 'TOKEN_REFRESHED' | 'SESSION_PING' | 'SESSION_PONG';
 /**
- * Estructura del mensaje cross-tab
+ * Cross-tab message structure
  */
 interface CrossTabMessage {
     type: CrossTabMessageType;
@@ -44,79 +127,79 @@ interface CrossTabMessage {
     payload?: Record<string, unknown>;
 }
 /**
- * Tipo de callback para suscriptores
+ * Callback type for subscribers
  */
 type CrossTabListener = (message: CrossTabMessage) => void;
 /**
- * Manager singleton para sincronización cross-tab
+ * Singleton manager for cross-tab synchronization
  */
 declare class CrossTabSyncManager {
     private static instance;
     private broadcastChannel;
     private readonly CHANNEL_NAME;
-    private tabId;
-    private listeners;
+    private readonly tabId;
+    private readonly listeners;
     private isInitialized;
     /**
-     * Constructor privado - usar getInstance()
+     * Private constructor - use getInstance()
      */
     private constructor();
     /**
-     * Genera un ID único para esta pestaña
+     * Generate a unique ID for this tab
      */
     private static generateTabId;
     /**
-     * Obtener la instancia singleton
+     * Get the singleton instance
      */
     static getInstance(): CrossTabSyncManager;
     /**
-     * Resetear la instancia (útil para tests)
+     * Reset the instance (useful for tests)
      */
     static resetInstance(): void;
     /**
-     * Inicializar el canal de comunicación
+     * Initialize the communication channel
      */
     private initialize;
     /**
-     * Destruir el manager y limpiar recursos
+     * Destroy the manager and clean up resources
      */
     destroy(): void;
     /**
-     * Obtener el ID de esta pestaña
+     * Get the ID of this tab
      */
     getTabId(): string;
     /**
-     * Suscribirse a mensajes de otras pestañas
-     * @returns Función para desuscribirse
+     * Subscribe to messages from other tabs
+     * @returns Unsubscribe function
      */
     subscribe(listener: CrossTabListener): () => void;
     /**
-     * Notificar que se inició sesión en esta pestaña
+     * Notify that a session was started in this tab
      */
     notifyLogin(): void;
     /**
-     * Notificar que se cerró sesión en esta pestaña
+     * Notify that the session was ended in this tab
      */
     notifyLogout(): void;
     /**
-     * Notificar que se refrescaron los tokens
+     * Notify that tokens were refreshed
      */
     notifyTokenRefreshed(): void;
     /**
-     * Enviar un ping para verificar otras pestañas activas
+     * Send a ping to check for other active tabs
      */
     ping(): void;
     /**
-     * Enviar mensaje a todas las demás pestañas
+     * Send message to all other tabs
      */
     private broadcast;
     /**
-     * Procesar mensaje recibido de otra pestaña
+     * Process message received from another tab
      */
     private handleMessage;
 }
 /**
- * Instancia singleton exportada para uso directo
+ * Exported singleton instance for direct use
  */
 declare const crossTabSync: CrossTabSyncManager;
 
@@ -126,9 +209,9 @@ type CrudifyThemeProviderProps = {
     disableCssBaseline?: boolean;
 };
 /**
- * Provider de tema para aplicaciones Crudify
- * Lee automáticamente el theme desde window.__TENANT_CONFIG__ (inyectado por Lambda@Edge)
- * y aplica el tema a Material-UI
+ * Theme provider for Crudify applications
+ * Automatically reads the theme from window.__TENANT_CONFIG__ (injected by Lambda@Edge)
+ * and applies it to Material-UI
  *
  * @example
  * ```tsx
@@ -137,7 +220,7 @@ type CrudifyThemeProviderProps = {
  * </CrudifyThemeProvider>
  * ```
  *
- * @example Con tema por defecto personalizado
+ * @example With custom default theme
  * ```tsx
  * <CrudifyThemeProvider defaultTheme={{ palette: { mode: 'dark' } }}>
  *   <App />
@@ -146,6 +229,253 @@ type CrudifyThemeProviderProps = {
  */
 declare function CrudifyThemeProvider({ children, defaultTheme, disableCssBaseline, }: Readonly<CrudifyThemeProviderProps>): react_jsx_runtime.JSX.Element;
 
+declare function LoginComponent(): react_jsx_runtime.JSX.Element;
+/**
+ * Simple session status component to display anywhere
+ */
+declare function SessionStatus(): react_jsx_runtime.JSX.Element;
+
+interface CrudiaAutoGenerateProps {
+    config: AutoGenerateConfig;
+    value?: string;
+    onChange?: (value: string) => void;
+    label?: string;
+    error?: boolean;
+    helperText?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    name?: string;
+    containerRef?: React.RefObject<HTMLDivElement | null>;
+}
+/**
+ * Component for auto-generated fields (sequential codes)
+ *
+ * Features:
+ * - Auto-fetches the code on mount
+ * - Automatic duplicate error detection
+ * - "Regenerate" button in endAdornment when there is a duplicate error
+ * - Loading and error states
+ * - Read-only by default
+ * - Integration with useAutoGenerate hook
+ *
+ * Duplicate Error Handling Flow:
+ * 1. User opens form -> Code is generated automatically (e.g.: PROD-0013671)
+ * 2. User fills the form and submits
+ * 3. Backend returns "duplicate key" or "unique constraint" error
+ * 4. Parent form passes error={true} and helperText="Code already exists"
+ * 5. Component detects duplicate keywords and shows regenerate button
+ * 6. User clicks regenerate button -> New code is generated
+ * 7. onChange is called with new code -> Parent form clears the error
+ * 8. Regenerate button disappears (because there is no longer an error)
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <CrudiaAutoGenerate
+ *   config={{ prefix: "PROD-", padding: 7 }}
+ *   onChange={(code) => setFormData({ ...formData, barCode: code })}
+ *   label="Código de Barras"
+ * />
+ *
+ * // With duplicate error handling from the form
+ * <CrudiaAutoGenerate
+ *   config={{ prefix: "PROD-", padding: 7 }}
+ *   onChange={(code) => {
+ *     setFormData({ ...formData, barCode: code });
+ *     // Clear error when the code changes
+ *     setFormErrors({ ...formErrors, barCode: null });
+ *   }}
+ *   label="Código de Barras"
+ *   error={!!formErrors.barCode}
+ *   helperText={formErrors.barCode}
+ * />
+ * ```
+ */
+declare const CrudiaAutoGenerate: React.FC<CrudiaAutoGenerateProps>;
+
+/**
+ * Types and interfaces for CrudiaFileField component
+ */
+
+/**
+ * Deletion handlers exposed by the component
+ */
+interface CrudiaFileFieldDeletionHandlers {
+    /** Execute all pending deletions (call this on form success callback) */
+    commitDeletions: () => Promise<{
+        success: boolean;
+        errors: string[];
+    }>;
+    /** Cancel all pending deletions and restore files */
+    restorePendingDeletions: () => void;
+    /** Whether there are files pending deletion */
+    hasPendingDeletions: boolean;
+    /** Mark the field as submitted (triggers validation errors display) */
+    markAsSubmitted: () => void;
+    /** Whether the field is valid */
+    isValid: boolean;
+    /** Whether files are currently being uploaded */
+    isUploading: boolean;
+    /** Wait for all uploads to complete - returns completed file paths */
+    waitForUploads: () => Promise<string[]>;
+    /** Get completed file paths synchronously (may be stale if uploads just finished) */
+    getCompletedFilePaths: () => string[];
+}
+/**
+ * Props del componente CrudiaFileField
+ */
+interface CrudiaFileFieldProps {
+    /** Label del campo */
+    label?: string;
+    /** Tipos MIME permitidos (ej: ["image/png", "image/jpeg"]) */
+    accept?: string[];
+    /** Tamaño máximo por archivo en bytes */
+    maxFileSize?: number;
+    /** Permitir múltiples archivos */
+    multiple?: boolean;
+    /** Número máximo de archivos (solo si multiple=true) */
+    maxFiles?: number;
+    /** Número mínimo de archivos requeridos */
+    minFiles?: number;
+    /** Campo requerido */
+    required?: boolean;
+    /** Campo deshabilitado */
+    disabled?: boolean;
+    /** Error externo */
+    error?: boolean;
+    /** Texto de ayuda o error */
+    helperText?: string;
+    /**
+     * Callback cuando cambian los filePaths de archivos completados
+     * Los filePaths son rutas relativas con visibility (public/... o private/...)
+     */
+    onChange?: (filePaths: string[]) => void;
+    /** Callback cuando se valida el campo */
+    onValidation?: (isValid: boolean, error: string | null) => void;
+    /** Archivos existentes (para edición) - usar filePath (ruta relativa con visibility) */
+    initialFiles?: Array<{
+        filePath: string;
+        name: string;
+        size?: number;
+        contentType?: string;
+    }>;
+    /** Texto placeholder para drag zone */
+    placeholder?: string;
+    /** Mostrar lista de archivos */
+    showFileList?: boolean;
+    /**
+     * Visibilidad de los archivos subidos
+     * @default "private"
+     */
+    visibility?: 'public' | 'private';
+    /**
+     * Mostrar preview de imágenes
+     * @default true para imágenes
+     */
+    showPreview?: boolean;
+    /**
+     * URL base para prefijar al path del archivo
+     * El valor guardado será baseUrl + path
+     * También se usa para previsualizar/descargar archivos públicos en modo readonly
+     */
+    baseUrl: string;
+    /**
+     * Callback called when deletion handlers are ready
+     * Use this to get access to commitDeletions and restorePendingDeletions functions
+     */
+    onDeletionHandlersReady?: (handlers: CrudiaFileFieldDeletionHandlers) => void;
+    /**
+     * Form mode: 'create' or 'edit' - affects delete behavior
+     * - create: delete shows confirmation and deletes immediately from server
+     * - edit: existing files use pendingDeletion, new files delete immediately
+     * @default "create"
+     */
+    mode?: 'create' | 'edit';
+    /** HTML name attribute for the hidden file input */
+    name?: string;
+    /** Ref para el contenedor (usado para scroll en errores) */
+    containerRef?: RefObject<HTMLDivElement | null>;
+}
+
+/**
+ * File field component with:
+ * - Drag & drop
+ * - File preview
+ * - Progress bar during upload
+ * - Delete files (soft delete)
+ * - Type and size validation
+ * - Single/multiple support
+ */
+
+/**
+ * Main file field component
+ *
+ * @example
+ * ```tsx
+ * // Basic usage - single file
+ * <CrudiaFileField
+ *   label="Document"
+ *   accept={["application/pdf"]}
+ *   onChange={(filePaths) => setFormData({ ...formData, document: filePaths[0] })}
+ * />
+ *
+ * // Multiple files with limits
+ * <CrudiaFileField
+ *   label="Images"
+ *   accept={["image/png", "image/jpeg"]}
+ *   multiple
+ *   maxFiles={5}
+ *   minFiles={1}
+ *   maxFileSize={5 * 1024 * 1024}
+ *   onChange={(filePaths) => setFormData({ ...formData, images: filePaths })}
+ * />
+ *
+ * // With initial files (edit mode)
+ * <CrudiaFileField
+ *   label="Attachments"
+ *   multiple
+ *   initialFiles={existingFiles}
+ *   onChange={handleFilesChange}
+ * />
+ * ```
+ */
+declare const CrudiaFileField: React.FC<CrudiaFileFieldProps>;
+
+/**
+ * Markdown field component with rich text editing using MDXEditor
+ * - WYSIWYG markdown editing
+ * - Toolbar with formatting options
+ * - Saves content as markdown string
+ */
+
+interface CrudiaMarkdownFieldProps {
+    /** Field label */
+    label?: string;
+    /** Current value (markdown string) */
+    value?: string;
+    /** Callback when content changes */
+    onChange?: (value: string) => void;
+    /** Required field */
+    required?: boolean;
+    /** Disabled/readonly field */
+    disabled?: boolean;
+    /** External error state */
+    error?: boolean;
+    /** Helper or error text */
+    helperText?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Minimum editor height in pixels */
+    minHeight?: number;
+    /** Maximum editor height in pixels (scrolls after) */
+    maxHeight?: number;
+    /** HTML name attribute for hidden input (for form semantics) */
+    name?: string;
+    /** Ref para el contenedor (usado para scroll en errores) */
+    containerRef?: React.RefObject<HTMLDivElement | null>;
+}
+declare const CrudiaMarkdownField: React.FC<CrudiaMarkdownFieldProps>;
+
 interface PasswordRequirementsProps {
     requirements: Array<{
         message: string;
@@ -174,93 +504,15 @@ declare function evaluatePasswordRules(password: string, rules: PasswordRule[]):
  */
 declare function allPasswordRulesPassed(evaluated: EvaluatedPasswordRule[]): boolean;
 
-/**
- * Unified Logger for Crudify Projects
- *
- * Environment-based logging:
- * - dev/stg: All logs (error, warn, info, debug)
- * - prod: Only errors (default)
- *
- * AUTO-DETECTION (v2.0.0 - No longer uses cookies):
- * The logger will automatically detect the environment from:
- * 1. Explicit setEnvironment() call (highest priority)
- * 2. window.__TENANT_CONFIG__.environment (production with Lambda@Edge)
- * 3. window.__CRUDIFY_ENV__ global variable (legacy/fallback)
- * 4. Default to "prod" for safety
- *
- * Usage:
- *   import { logger } from './logger';
- *
- *   // Option 1: Explicit configuration (recommended for apps)
- *   logger.setEnvironment('dev'); // or 'stg', 'prod'
- *
- *   // Option 2: Auto-detection (reads from window.__TENANT_CONFIG__)
- *   // Just use the logger - it will auto-detect
- *
- *   logger.error('Something failed', { userId: '123' });
- *   logger.warn('Deprecated feature used');
- *   logger.info('User logged in', { email: 'user@example.com' });
- *   logger.debug('Processing request', { payload: data });
- */
-type LogLevel = 'error' | 'warn' | 'info' | 'debug';
-interface LogContext {
-    [key: string]: unknown;
-}
 declare class Logger {
-    private explicitEnv;
-    private prefix;
+    private readonly core;
     constructor();
-    /**
-     * Get current effective environment
-     * Priority: explicit setEnvironment() > auto-detection
-     */
-    private getEffectiveEnv;
-    /**
-     * Sanitize sensitive data from strings
-     */
-    private sanitize;
-    /**
-     * Sanitize context object
-     */
-    private sanitizeContext;
-    /**
-     * Check if a log level should be displayed based on environment
-     * - dev/stg: show all logs
-     * - prod: show only errors (unless CRUDIFY_DEBUG_MODE is enabled)
-     */
-    private shouldLog;
-    /**
-     * Format and output log entry
-     */
-    private log;
-    /**
-     * Log an error - Always logged in all environments
-     */
     error(message: string, context?: LogContext | Error): void;
-    /**
-     * Log a warning - Only in dev/stg
-     */
     warn(message: string, context?: LogContext): void;
-    /**
-     * Log info - Only in dev/stg
-     */
     info(message: string, context?: LogContext): void;
-    /**
-     * Log debug information - Only in dev/stg
-     */
     debug(message: string, context?: LogContext): void;
-    /**
-     * Get current effective environment
-     */
     getEnvironment(): string;
-    /**
-     * Manually set environment (useful for libraries that receive env from parent app)
-     * This takes priority over auto-detection
-     */
     setEnvironment(env: string): void;
-    /**
-     * Check if environment was explicitly set or auto-detected
-     */
     isExplicitlyConfigured(): boolean;
 }
 declare const logger: Logger;
@@ -268,24 +520,24 @@ declare const logger: Logger;
 interface ProtectedRouteProps {
     children: ReactNode;
     /**
-     * Componente a mostrar mientras se valida la sesión
+     * Component to display while the session is being validated
      * @default <SessionLoadingScreen stage="validating-session" />
      */
     loadingComponent?: ReactNode;
     /**
-     * Ruta a la que redirigir si no está autenticado
+     * Path to redirect to if not authenticated
      * @default "/login"
      */
     loginPath?: string;
 }
 /**
- * Componente para proteger rutas que requieren autenticación
+ * Component to protect routes that require authentication
  *
- * Características:
- * - Valida sesión de forma estricta (isAuthenticated + tokens válidos)
- * - Guarda URL actual para redirect post-login
- * - Previene open redirect attacks
- * - Limpia storage corrupto automáticamente
+ * Features:
+ * - Strictly validates the session (isAuthenticated + valid tokens)
+ * - Saves the current URL for post-login redirect
+ * - Prevents open redirect attacks
+ * - Automatically cleans up corrupted storage
  *
  * @example
  * ```tsx
@@ -304,32 +556,32 @@ declare function ProtectedRoute({ children, loadingComponent, loginPath }: Reado
 interface AuthRouteProps {
     children: ReactNode;
     /**
-     * Ruta a la que redirigir si ya está autenticado
-     * Si hay parámetro ?redirect= en la URL, se usará ese en su lugar
+     * Path to redirect to if already authenticated
+     * If a ?redirect= parameter exists in the URL, it will be used instead
      * @default "/"
      */
     redirectTo?: string;
     /**
-     * Componente a mostrar mientras se valida la sesión
+     * Component to display while the session is being validated
      * @default <SessionLoadingScreen stage="validating-session" />
      */
     loadingComponent?: ReactNode;
     /**
-     * Tiempo máximo de espera (ms) para la inicialización antes de mostrar el form
+     * Maximum wait time (ms) for initialization before showing the form
      * @default 3000
      */
     initTimeout?: number;
 }
 /**
- * Componente para proteger rutas de autenticación (login, register, etc.)
- * Redirige a home si el usuario ya está autenticado
+ * Component to protect authentication routes (login, register, etc.)
+ * Redirects to home if the user is already authenticated
  *
- * Características:
- * - Si usuario autenticado → redirige a home (o ?redirect= si existe)
- * - Si no autenticado → muestra el componente (login, etc.)
- * - Pre-check: Si hay tokens en localStorage, espera inicialización antes de mostrar form
- * - Timeout: Si la inicialización tarda mucho, muestra el form de todos modos
- * - Valida parámetro redirect para prevenir open redirect
+ * Features:
+ * - If user is authenticated -> redirects to home (or ?redirect= if present)
+ * - If not authenticated -> renders the component (login, etc.)
+ * - Pre-check: If tokens exist in localStorage, waits for initialization before showing the form
+ * - Timeout: If initialization takes too long, shows the form anyway
+ * - Validates the redirect parameter to prevent open redirect attacks
  *
  * @example
  * ```tsx
@@ -346,40 +598,40 @@ interface AuthRouteProps {
 declare function AuthRoute({ children, redirectTo, loadingComponent, initTimeout, }: Readonly<AuthRouteProps>): react_jsx_runtime.JSX.Element;
 
 /**
- * Comportamiento de GuestRoute cuando el usuario está autenticado
+ * GuestRoute behavior when the user is authenticated
  */
 type GuestRouteBehavior = 'redirect-if-authenticated' | 'allow-all';
 interface GuestRouteProps {
     children: ReactNode;
     /**
-     * Comportamiento cuando el usuario está autenticado
-     * - 'redirect-if-authenticated': Redirige al usuario a redirectTo (default)
-     * - 'allow-all': Permite acceso tanto a usuarios autenticados como no autenticados
+     * Behavior when the user is authenticated
+     * - 'redirect-if-authenticated': Redirects the user to redirectTo (default)
+     * - 'allow-all': Allows access to both authenticated and unauthenticated users
      * @default 'redirect-if-authenticated'
      */
     behavior?: GuestRouteBehavior;
     /**
-     * Ruta a la que redirigir si está autenticado y behavior es 'redirect-if-authenticated'
+     * Path to redirect to if authenticated and behavior is 'redirect-if-authenticated'
      * @default "/"
      */
     redirectTo?: string;
     /**
-     * Componente a mostrar mientras se valida la sesión
+     * Component to display while the session is being validated
      * @default <SessionLoadingScreen stage="validating-session" />
      */
     loadingComponent?: ReactNode;
 }
 /**
- * Componente para rutas de invitados con comportamiento configurable
+ * Component for guest routes with configurable behavior
  *
- * Casos de uso:
- * - Login page: behavior='redirect-if-authenticated' → redirige si ya está logueado
- * - Forgot password: behavior='allow-all' → permite acceso aunque esté logueado
- * - Reset password: behavior='allow-all' → permite acceso aunque esté logueado
+ * Use cases:
+ * - Login page: behavior='redirect-if-authenticated' -> redirects if already logged in
+ * - Forgot password: behavior='allow-all' -> allows access even if logged in
+ * - Reset password: behavior='allow-all' -> allows access even if logged in
  *
  * @example
  * ```tsx
- * // Login - redirige si ya está autenticado
+ * // Login - redirects if already authenticated
  * <Route
  *   path="/login"
  *   element={
@@ -389,7 +641,7 @@ interface GuestRouteProps {
  *   }
  * />
  *
- * // Forgot password - permite acceso aunque esté autenticado
+ * // Forgot password - allows access even if authenticated
  * <Route
  *   path="/login/forgotPassword"
  *   element={
@@ -434,81 +686,81 @@ interface SessionLoadingScreenProps {
  * />
  * ```
  */
-declare function SessionLoadingScreen({ stage, message }: SessionLoadingScreenProps): react_jsx_runtime.JSX.Element;
+declare function SessionLoadingScreen({ stage, message }: Readonly<SessionLoadingScreenProps>): react_jsx_runtime.JSX.Element;
 
 /**
- * Utilidades de seguridad para validar redirecciones
- * Previene ataques de open redirect permitiendo rutas dinámicas
+ * Security utilities for validating redirects
+ * Prevents open redirect attacks while allowing dynamic paths
  */
 /**
- * Valida que una ruta de redirección sea segura (solo rutas internas)
- * Permite rutas dinámicas pero bloquea ataques de open redirect
+ * Validates that a redirect path is safe (internal paths only)
+ * Allows dynamic paths but blocks open redirect attacks
  *
- * @param path - La ruta a validar
- * @param defaultPath - Ruta por defecto si la validación falla
- * @returns Ruta validada y segura
+ * @param path - The path to validate
+ * @param defaultPath - Default path if validation fails
+ * @returns Validated and safe path
  */
 declare const validateInternalRedirect: (path: string, defaultPath?: string) => string;
 /**
- * Valida que una URL de redirección sea segura
- * Soporta tanto rutas relativas internas como URLs absolutas de dominios confiables
+ * Validates that a redirect URL is safe
+ * Supports both internal relative paths and absolute URLs from trusted domains
  *
- * Casos de uso:
- * - Rutas relativas: /dashboard, /admin/users
- * - URLs absolutas confiables: https://files.nocios.link/subscriber/private/file.png
+ * Use cases:
+ * - Relative paths: /dashboard, /admin/users
+ * - Trusted absolute URLs: https://files.nocios.link/subscriber/private/file.png
  *
- * @param url - La URL o ruta a validar
- * @param defaultPath - Ruta por defecto si la validación falla
- * @returns URL o ruta validada y segura
+ * @param url - The URL or path to validate
+ * @param defaultPath - Default path if validation fails
+ * @returns Validated and safe URL or path
  */
 declare const validateTrustedRedirect: (url: string, defaultPath?: string) => string;
 /**
- * Extrae y valida parámetro redirect de URL search params
+ * Extracts and validates the redirect parameter from URL search params
  *
- * @param searchParams - URLSearchParams o string de query params
- * @param defaultPath - Ruta por defecto
- * @returns Ruta validada
+ * @param searchParams - URLSearchParams or query params string
+ * @param defaultPath - Default path
+ * @returns Validated path
  */
 declare const extractSafeRedirectFromUrl: (searchParams: URLSearchParams | string, defaultPath?: string) => string;
 
 /**
- * Verifica si hay tokens encriptados en localStorage
- * Hace un check rápido sin desencriptar
+ * Checks if there are encrypted tokens in localStorage
+ * Performs a quick check without decrypting
  *
- * @returns true si parece haber tokens guardados en formato v2
+ * @returns true if there appear to be tokens stored in v2 format
  */
 declare function hasStoredTokens(): boolean;
 /**
- * Verifica si existe el hash de la clave de encriptación
- * Si existe, indica que TokenStorage puede desencriptar los tokens
+ * Checks if the encryption key hash exists
+ * If it exists, it indicates that TokenStorage can decrypt the tokens
  *
- * @returns true si hay un hash de clave válido guardado
+ * @returns true if there is a valid key hash stored
  */
 declare function hasEncryptionKeyHash(): boolean;
 /**
- * Determina si debemos esperar a la inicialización de la sesión
- * antes de mostrar el formulario de login
+ * Determines if we should wait for session initialization
+ * before showing the login form
  *
- * Retorna true si:
- * - Hay tokens encriptados guardados
- * - Hay un hash de clave de encriptación (para poder desencriptarlos)
+ * Returns true if:
+ * - There are encrypted tokens stored
+ * - There is an encryption key hash (to be able to decrypt them)
  *
- * Esto indica alta probabilidad de sesión válida, por lo que
- * deberíamos mostrar loading mientras se inicializa SessionManager
+ * This indicates a high probability of a valid session, so
+ * we should show loading while SessionManager initializes
  *
- * @returns true si probablemente hay una sesión válida
+ * @returns true if there is likely a valid session
  */
 declare function shouldWaitForInitialization(): boolean;
 /**
- * Verifica si los tokens parecen estar corruptos o incompletos
- * Útil para decidir si limpiar el storage
+ * Checks if the tokens appear to be corrupted or incomplete
+ * Useful for deciding whether to clear the storage
  *
- * @returns true si hay datos pero parecen corruptos
+ * @returns true if there is data but it appears corrupted
  */
 declare function hasCorruptedTokens(): boolean;
 /**
- * Limpia tokens que parecen corruptos
- * Solo debe llamarse si hasCorruptedTokens() retorna true
+ * Clears tokens that appear corrupted
+ * Should only be called if hasCorruptedTokens() returns true
  */
 declare function clearCorruptedTokens(): void;
 
@@ -525,7 +777,7 @@ interface InitializationState {
 interface InitializationRequest {
     priority: InitializationPriority;
     publicApiKey: string;
-    env: 'dev' | 'stg' | 'api' | 'prod';
+    env: FrontendEnvironment;
     enableLogging?: boolean;
     requestedBy: string;
 }
@@ -567,7 +819,7 @@ declare class CrudifyInitializationManager {
     private state;
     private initializationPromise;
     private highPriorityInitializerPresent;
-    private waitingForHighPriority;
+    private readonly waitingForHighPriority;
     private readonly HIGH_PRIORITY_WAIT_TIMEOUT;
     private constructor();
     /**
@@ -595,6 +847,32 @@ declare class CrudifyInitializationManager {
      * @throws Error if initialization fails
      */
     initialize(request: InitializationRequest): Promise<void>;
+    /**
+     * Warn if a caller tries to initialize with a different API key than already configured
+     */
+    private warnIfKeyMismatch;
+    /**
+     * Log a debug message if logging is enabled
+     */
+    private logDebug;
+    /**
+     * Check if a LOW priority request should defer to a HIGH priority initializer
+     */
+    private shouldDeferToHighPriority;
+    /**
+     * Defer to HIGH priority initializer, waiting with timeout.
+     * Returns true if initialization was completed by HIGH priority (caller should return).
+     * Returns false if caller should proceed with its own initialization.
+     */
+    private deferToHighPriority;
+    /**
+     * If a HIGH priority request arrives while LOW priority is initializing, override it
+     */
+    private overrideLowPriorityIfNeeded;
+    /**
+     * Execute the actual SDK initialization and update state accordingly
+     */
+    private executeInitialization;
     /**
      * Wait for HIGH priority initializer with timeout
      */
@@ -654,7 +932,7 @@ declare const crudifyInitManager: CrudifyInitializationManager;
 
 interface CrudifyInitializerConfig {
     publicApiKey?: string;
-    env?: 'dev' | 'stg' | 'api' | 'prod';
+    env?: FrontendEnvironment;
     enableLogging?: boolean;
 }
 interface CrudifyInitializerContextValue {
@@ -754,7 +1032,7 @@ interface I18nInstance {
 interface TranslationsProviderProps {
     children: React.ReactNode;
     apiKey?: string;
-    crudifyEnv?: 'dev' | 'stg' | 'api' | 'prod';
+    crudifyEnv?: FrontendEnvironment;
     featureKeys?: string[];
     language?: string;
     devTranslations?: Record<string, string>;
@@ -840,7 +1118,7 @@ declare const useTranslations: () => TranslationsContextValue;
 
 interface FetchTranslationsOptions {
     apiKey: string;
-    crudifyEnv?: 'dev' | 'stg' | 'api' | 'prod';
+    crudifyEnv?: FrontendEnvironment;
     featureKeys?: string[];
     urlTranslations?: Record<string, string>;
 }
@@ -876,6 +1154,19 @@ declare class TranslationService {
      * Thread-safe: multiple calls will wait for the same initialization
      */
     private ensureCrudifyInitialized;
+    /**
+     * Try to return valid (non-expired) cached translations.
+     * Returns null if cache is missing or expired.
+     */
+    private tryValidCache;
+    /**
+     * Return expired cache or critical bundle as fallback.
+     */
+    private getFallbackTranslations;
+    /**
+     * Process a successful API response: update cache and merge with URL translations.
+     */
+    private processApiResponse;
     /**
      * Fetch translations with cache strategy
      * 1. Try cache (if valid and not changed)
@@ -954,11 +1245,12 @@ declare const translationService: TranslationService;
  */
 declare const CRITICAL_TRANSLATIONS: {
     readonly es: {
-        readonly 'base.actions.create': "Nuevo";
+        readonly 'base.actions.create': "Crear";
         readonly 'base.actions.delete': "Eliminar";
         readonly 'base.actions.read': "Ver";
         readonly 'base.actions.refresh': "Refrescar";
         readonly 'base.actions.update': "Editar";
+        readonly 'base.actions.logout': "Cerrar sesión";
         readonly 'base.btn.back': "Volver";
         readonly 'base.btn.cancel': "Cancelar";
         readonly 'base.btn.hidePassword': "Ocultar contraseña";
@@ -967,6 +1259,7 @@ declare const CRITICAL_TRANSLATIONS: {
         readonly 'base.fields.actions': "Acciones";
         readonly 'base.fields.confirmPassword': "Confirmar contraseña";
         readonly 'base.fields.createdAt': "Creado el";
+        readonly 'base.fields._id': "ID";
         readonly 'base.fields.email': "Correo electrónico";
         readonly 'base.fields.lastName': "Apellido";
         readonly 'base.fields.name': "Nombre";
@@ -1001,7 +1294,7 @@ declare const CRITICAL_TRANSLATIONS: {
         readonly 'base.loading.starting': "Iniciando aplicación...";
         readonly 'base.loading.themeSetup': "Generando tema...";
         readonly 'base.loading.validatingSession': "Validando sesión...";
-        readonly 'base.titles.create': "Nuevo {{moduleName}}";
+        readonly 'base.titles.create': "Crear {{moduleName}}";
         readonly 'base.titles.read': "Ver {{moduleName}}";
         readonly 'base.titles.update': "Editar {{moduleName}}";
         readonly 'base.success.transaction': "La operación se ha completado con éxito.";
@@ -1131,6 +1424,7 @@ declare const CRITICAL_TRANSLATIONS: {
         readonly 'base.actions.read': "View";
         readonly 'base.actions.refresh': "Refresh";
         readonly 'base.actions.update': "Edit";
+        readonly 'base.actions.logout': "Logout";
         readonly 'base.btn.back': "Back";
         readonly 'base.btn.cancel': "Cancel";
         readonly 'base.btn.hidePassword': "Hide password";
@@ -1139,6 +1433,7 @@ declare const CRITICAL_TRANSLATIONS: {
         readonly 'base.fields.actions': "Actions";
         readonly 'base.fields.confirmPassword': "Confirm password";
         readonly 'base.fields.createdAt': "Created at";
+        readonly 'base.fields._id': "ID";
         readonly 'base.fields.email': "Email";
         readonly 'base.fields.lastName': "Last name";
         readonly 'base.fields.name': "Name";
@@ -1315,25 +1610,25 @@ declare const getCriticalTranslations: (language: string) => Record<string, stri
  * Automatically injects JWT token in each request and handles token refresh on 401 errors.
  */
 declare const crudifyAdmin: {
-    listModules: () => Promise<ApiResponse<IModule[]>>;
-    getModule: (moduleKey: string) => Promise<ApiResponse<IModule>>;
-    createModule: (moduleData: ModuleCreateInput) => Promise<ApiResponse<IModule>>;
-    editModule: (moduleKey: string, moduleData: ModuleEditInput) => Promise<ApiResponse<IModule>>;
-    deleteModule: (moduleKey: string) => Promise<ApiResponse>;
-    activateModule: (moduleKey: string) => Promise<ApiResponse<IModule>>;
-    deactivateModule: (moduleKey: string) => Promise<ApiResponse<IModule>>;
-    getModuleVersions: (moduleKey: string) => Promise<ApiResponse<any[]>>;
-    listActions: (filters?: ActionListFilters) => Promise<ApiResponse<IAction[]>>;
-    getAction: (actionKey: string) => Promise<ApiResponse<IAction>>;
-    createAction: (actionData: ActionCreateInput) => Promise<ApiResponse<IAction>>;
-    editAction: (actionKey: string, actionData: ActionEditInput) => Promise<ApiResponse<IAction>>;
-    deleteAction: (actionKey: string) => Promise<ApiResponse>;
-    activateAction: (actionKey: string) => Promise<ApiResponse<IAction>>;
-    deactivateAction: (actionKey: string) => Promise<ApiResponse<IAction>>;
-    getActionVersions: (actionKey: string) => Promise<ApiResponse<any[]>>;
-    getActionsByProfile: (profileId: string) => Promise<ApiResponse<IAction[]>>;
-    updateActionsProfiles: (data: UpdateActionsProfilesInput) => Promise<ApiResponse<UpdateActionsProfilesResponse>>;
-    calculatePermissions: (data: CalculatePermissionsInput) => Promise<ApiResponse<CalculatePermissionsResponse>>;
+    listModules: () => Promise<AdminApiResponse<ModuleDefinition[]>>;
+    getModule: (moduleKey: string) => Promise<AdminApiResponse<ModuleDefinition>>;
+    createModule: (moduleData: ModuleCreateInput) => Promise<AdminApiResponse<ModuleDefinition>>;
+    editModule: (moduleKey: string, moduleData: ModuleEditInput) => Promise<AdminApiResponse<ModuleDefinition>>;
+    deleteModule: (moduleKey: string) => Promise<AdminApiResponse>;
+    activateModule: (moduleKey: string) => Promise<AdminApiResponse<ModuleDefinition>>;
+    deactivateModule: (moduleKey: string) => Promise<AdminApiResponse<ModuleDefinition>>;
+    getModuleVersions: (moduleKey: string) => Promise<AdminApiResponse<ModuleVersionItem[]>>;
+    listActions: (filters?: AdminActionFilters) => Promise<AdminApiResponse<ActionDefinition[]>>;
+    getAction: (actionKey: string) => Promise<AdminApiResponse<ActionDefinition>>;
+    createAction: (actionData: ActionCreateInput) => Promise<AdminApiResponse<ActionDefinition>>;
+    editAction: (actionKey: string, actionData: ActionEditInput) => Promise<AdminApiResponse<ActionDefinition>>;
+    deleteAction: (actionKey: string) => Promise<AdminApiResponse>;
+    activateAction: (actionKey: string) => Promise<AdminApiResponse<ActionDefinition>>;
+    deactivateAction: (actionKey: string) => Promise<AdminApiResponse<ActionDefinition>>;
+    getActionVersions: (actionKey: string) => Promise<AdminApiResponse<ActionVersionItem[]>>;
+    getActionsByProfile: (profileId: string) => Promise<AdminApiResponse<ActionDefinition[]>>;
+    updateActionsProfiles: (data: UpdateActionsProfilesInput) => Promise<AdminApiResponse<UpdateActionsProfilesResponse>>;
+    calculatePermissions: (data: CalculatePermissionsInput) => Promise<AdminApiResponse<CalculatePermissionsResponse>>;
 };
 
-export { AuthRoute, type AuthRouteProps, CRITICAL_TRANSLATIONS, type CriticalTranslationKey, type CrossTabListener, type CrossTabMessage, type CrossTabMessageType, CrossTabSyncManager, CrudifyInitializationManager, CrudifyInitializer, type CrudifyInitializerConfig, type CrudifyInitializerProps, CrudifyLoginConfig, CrudifyProvider, CrudifyThemeProvider, type CrudifyThemeProviderProps, EvaluatedPasswordRule, type FetchTranslationsOptions, GuestRoute, type GuestRouteBehavior, type GuestRouteProps, type InitializationPriority, type InitializationRequest, type InitializationStatus, type LogContext, type LogLevel, PasswordRequirements, type PasswordRequirementsProps, PasswordRule, ProtectedRoute, type ProtectedRouteProps, SessionLoadingScreen, type SessionLoadingScreenProps, type SupportedLanguage, type TranslationResponse, TranslationService, type TranslationsContextValue, TranslationsProvider, type TranslationsProviderProps, allPasswordRulesPassed, clearCorruptedTokens, crossTabSync, crudifyAdmin, crudifyInitManager, evaluatePasswordRules, extractSafeRedirectFromUrl, getCriticalLanguages, getCriticalTranslations, hasCorruptedTokens, hasEncryptionKeyHash, hasStoredTokens, logger, shouldWaitForInitialization, translationService, useCrudify, useCrudifyInitializer, useTranslations, validateInternalRedirect, validateTrustedRedirect };
+export { AuthRoute, type AuthRouteProps, AutoGenerateConfig, type BoxScreenType, CRITICAL_TRANSLATIONS, type CriticalTranslationKey, type CrossTabListener, type CrossTabMessage, type CrossTabMessageType, CrossTabSyncManager, CrudiaAutoGenerate, type CrudiaAutoGenerateProps, CrudiaFileField, type CrudiaFileFieldDeletionHandlers, type CrudiaFileFieldProps, CrudiaMarkdownField, type CrudiaMarkdownFieldProps, CrudifyInitializationManager, CrudifyInitializer, type CrudifyInitializerConfig, type CrudifyInitializerProps, CrudifyLogin, type CrudifyLoginConfig, type CrudifyLoginProps, type CrudifyLoginTranslations, CrudifyProvider, CrudifyThemeProvider, type CrudifyThemeProviderProps, DEFAULT_PASSWORD_RULES, type EvaluatedPasswordRule, type FetchTranslationsOptions, GuestRoute, type GuestRouteBehavior, type GuestRouteProps, type InitializationPriority, type InitializationRequest, type InitializationStatus, LoginComponent, PasswordRequirements, type PasswordRequirementsProps, Policies, PolicyAction, ProtectedRoute, type ProtectedRouteProps, SessionLoadingScreen, type SessionLoadingScreenProps, SessionStatus, type SupportedLanguage, type TranslationResponse, TranslationService, type TranslationsContextValue, TranslationsProvider, type TranslationsProviderProps, type UserLoginData, UserProfileDisplay, allPasswordRulesPassed, clearCorruptedTokens, crossTabSync, crudifyAdmin, crudifyInitManager, evaluatePasswordRules, extractSafeRedirectFromUrl, getCriticalLanguages, getCriticalTranslations, hasCorruptedTokens, hasEncryptionKeyHash, hasStoredTokens, logger, shouldWaitForInitialization, translationService, useCrudify, useCrudifyInitializer, useTranslations, validateInternalRedirect, validateTrustedRedirect };