@nocios/crudify-components 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1274 @@
+import crudify__default from '@nocios/crudify-sdk';
+export * from '@nocios/crudify-sdk';
+export { default as crudify } from '@nocios/crudify-sdk';
+import { d as CrudifyLoginConfig, l as PasswordRule, E as EvaluatedPasswordRule } from './CrudiaMarkdownField-C54-A_J3.mjs';
+export { B as BoxScreenType, a as CrudiaAutoGenerate, i as CrudiaAutoGenerateProps, b as CrudiaFileField, o as CrudiaFileFieldDeletionHandlers, j as CrudiaFileFieldProps, c as CrudiaMarkdownField, k as CrudiaMarkdownFieldProps, C as CrudifyLogin, e as CrudifyLoginProps, f as CrudifyLoginTranslations, D as DEFAULT_PASSWORD_RULES, L as LoginComponent, m as POLICY_ACTIONS, n as PREFERRED_POLICY_ORDER, p as PasswordRuleType, P as Policies, h as PolicyAction, S as SessionStatus, g as UserLoginData, U as UserProfileDisplay } from './CrudiaMarkdownField-C54-A_J3.mjs';
+import React, { ReactNode } from 'react';
+export { A as ApiError, C as CrudifyApiResponse, d as CrudifyOperationOptions, e as CrudifyRequestOptions, a as CrudifyTransactionResponse, F as ForgotPasswordRequest, J as JwtPayload, b as LoginRequest, L as LoginResponse, R as ResetPasswordRequest, g as TransactionInput, f as TransactionOperation, T as TransactionResponseData, U as UserProfile, V as ValidateCodeRequest, c as ValidationError } from './api-B4uXiHF0.mjs';
+export { F as FileItem, v as FileStatus, L as LoginResult, N as NotificationOptions, a as SessionConfig, g as SessionDebugInfo, S as SessionManager, e as SessionProvider, h as SessionProviderProps, d as SessionState, c as StorageType, b as TokenData, T as TokenStorage, n as UseAuthReturn, p as UseDataReturn, s as UseFileUploadOptions, t as UseFileUploadReturn, U as UseSessionOptions, k as UseUserDataOptions, j as UseUserDataReturn, l as UserData, m as useAuth, w as useCrudifyWithNotifications, o as useData, r as useFileUpload, u as useSession, f as useSessionContext, i as useUserData, q as useUserProfile } from './index-Y9tTsinC.mjs';
+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, d as UseAutoGenerateOptions, U as UseAutoGenerateReturn, c as useAutoGenerate, u as useGlobalNotification } from './GlobalNotificationProvider-Zq18OkpI.mjs';
+export { E as ERROR_CODES, j as ERROR_SEVERITY_MAP, n as ErrorCode, o as ErrorSeverity, q as ErrorTranslationConfig, P as ParsedError, m as createErrorTranslator, d as decodeJwtSafely, a as getCookie, g as getCurrentUserEmail, f as getErrorMessage, h as handleCrudifyError, i as isTokenExpired, p as parseApiError, e as parseJavaScriptError, c as parseTransactionError, b as secureLocalStorage, s as secureSessionStorage, l as translateError, t as translateErrorCode, k as translateErrorCodes } from './errorTranslation-qwwQTvCO.mjs';
+import { ApiResponse, IModule, ModuleCreateInput, ModuleEditInput, ActionListFilters, IAction, ActionCreateInput, ActionEditInput, UpdateActionsProfilesInput, UpdateActionsProfilesResponse, CalculatePermissionsInput, CalculatePermissionsResponse } from '@nocios/crudify-admin';
+export { ActionCreateInput, ActionEditInput, ActionListFilters, ApiResponse, IAction, IModule, ModuleCreateInput, ModuleEditInput, UpdateActionsProfilesInput, UpdateActionsProfilesResponse } from '@nocios/crudify-admin';
+
+interface CrudifyContextValue {
+    crudify: typeof crudify__default | null;
+    isLoading: boolean;
+    error: string | null;
+    isInitialized: boolean;
+    adminCredentials?: {
+        apiEndpointAdmin?: string;
+        apiKeyEndpointAdmin?: string;
+    };
+}
+interface CrudifyProviderProps {
+    config: CrudifyLoginConfig;
+    children: ReactNode;
+}
+declare const CrudifyProvider: React.FC<CrudifyProviderProps>;
+declare const useCrudify: () => CrudifyContextValue;
+
+/**
+ * Tipos de mensajes que se pueden enviar entre tabs
+ */
+type CrossTabMessageType = "SESSION_STARTED" | "SESSION_ENDED" | "TOKEN_REFRESHED" | "SESSION_PING" | "SESSION_PONG";
+/**
+ * Estructura del mensaje cross-tab
+ */
+interface CrossTabMessage {
+    type: CrossTabMessageType;
+    tabId: string;
+    timestamp: number;
+    payload?: Record<string, unknown>;
+}
+/**
+ * Tipo de callback para suscriptores
+ */
+type CrossTabListener = (message: CrossTabMessage) => void;
+/**
+ * Manager singleton para sincronización cross-tab
+ */
+declare class CrossTabSyncManager {
+    private static instance;
+    private broadcastChannel;
+    private readonly CHANNEL_NAME;
+    private tabId;
+    private listeners;
+    private isInitialized;
+    /**
+     * Constructor privado - usar getInstance()
+     */
+    private constructor();
+    /**
+     * Genera un ID único para esta pestaña
+     */
+    private static generateTabId;
+    /**
+     * Obtener la instancia singleton
+     */
+    static getInstance(): CrossTabSyncManager;
+    /**
+     * Resetear la instancia (útil para tests)
+     */
+    static resetInstance(): void;
+    /**
+     * Inicializar el canal de comunicación
+     */
+    private initialize;
+    /**
+     * Destruir el manager y limpiar recursos
+     */
+    destroy(): void;
+    /**
+     * Obtener el ID de esta pestaña
+     */
+    getTabId(): string;
+    /**
+     * Suscribirse a mensajes de otras pestañas
+     * @returns Función para desuscribirse
+     */
+    subscribe(listener: CrossTabListener): () => void;
+    /**
+     * Notificar que se inició sesión en esta pestaña
+     */
+    notifyLogin(): void;
+    /**
+     * Notificar que se cerró sesión en esta pestaña
+     */
+    notifyLogout(): void;
+    /**
+     * Notificar que se refrescaron los tokens
+     */
+    notifyTokenRefreshed(): void;
+    /**
+     * Enviar un ping para verificar otras pestañas activas
+     */
+    ping(): void;
+    /**
+     * Enviar mensaje a todas las demás pestañas
+     */
+    private broadcast;
+    /**
+     * Procesar mensaje recibido de otra pestaña
+     */
+    private handleMessage;
+}
+/**
+ * Instancia singleton exportada para uso directo
+ */
+declare const crossTabSync: CrossTabSyncManager;
+
+type CrudifyThemeProviderProps = {
+    children: ReactNode;
+    defaultTheme?: ThemeOptions;
+    disableCssBaseline?: boolean;
+};
+/**
+ * Provider de tema para aplicaciones Crudify
+ * Lee automáticamente la cookie "theme" y aplica el tema a Material-UI
+ *
+ * @example
+ * ```tsx
+ * <CrudifyThemeProvider>
+ *   <App />
+ * </CrudifyThemeProvider>
+ * ```
+ *
+ * @example Con tema por defecto personalizado
+ * ```tsx
+ * <CrudifyThemeProvider defaultTheme={{ palette: { mode: 'dark' } }}>
+ *   <App />
+ * </CrudifyThemeProvider>
+ * ```
+ */
+declare function CrudifyThemeProvider({ children, defaultTheme, disableCssBaseline }: CrudifyThemeProviderProps): react_jsx_runtime.JSX.Element;
+
+interface PasswordRequirementsProps {
+    requirements: Array<{
+        message: string;
+        valid: boolean;
+    }>;
+    show?: boolean;
+}
+declare const PasswordRequirements: React.FC<PasswordRequirementsProps>;
+
+/**
+ * Password validation utilities
+ * Evaluates password against a set of configurable rules
+ */
+
+/**
+ * Evaluates a password against a set of rules
+ * @param password - The password to validate
+ * @param rules - Array of password rules to check against
+ * @returns Array of evaluated rules with validation status
+ */
+declare function evaluatePasswordRules(password: string, rules: PasswordRule[]): EvaluatedPasswordRule[];
+/**
+ * Checks if all enforced password rules are satisfied
+ * @param evaluated - Array of evaluated password rules
+ * @returns true if all enforced rules pass, false otherwise
+ */
+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:
+ * The logger will automatically detect the environment from:
+ * 1. Explicit setEnvironment() call (highest priority)
+ * 2. Cookie named 'environment' (for production with Lambda@Edge)
+ * 3. window.__CRUDIFY_ENV__ global variable
+ * 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 cookie or global)
+ *   // 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;
+    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;
+
+interface ProtectedRouteProps {
+    children: ReactNode;
+    /**
+     * Componente a mostrar mientras se valida la sesión
+     * @default <SessionLoadingScreen stage="validating-session" />
+     */
+    loadingComponent?: ReactNode;
+    /**
+     * Ruta a la que redirigir si no está autenticado
+     * @default "/login"
+     */
+    loginPath?: string;
+}
+/**
+ * Componente para proteger rutas que requieren autenticación
+ *
+ * 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
+ *
+ * @example
+ * ```tsx
+ * <Route
+ *   path="/dashboard"
+ *   element={
+ *     <ProtectedRoute>
+ *       <Dashboard />
+ *     </ProtectedRoute>
+ *   }
+ * />
+ * ```
+ */
+declare function ProtectedRoute({ children, loadingComponent, loginPath }: ProtectedRouteProps): react_jsx_runtime.JSX.Element;
+
+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
+     * @default "/"
+     */
+    redirectTo?: string;
+    /**
+     * Componente a mostrar mientras se valida la sesión
+     * @default <SessionLoadingScreen stage="validating-session" />
+     */
+    loadingComponent?: ReactNode;
+    /**
+     * Tiempo máximo de espera (ms) para la inicialización antes de mostrar el form
+     * @default 3000
+     */
+    initTimeout?: number;
+}
+/**
+ * Componente para proteger rutas de autenticación (login, register, etc.)
+ * Redirige a home si el usuario ya está autenticado
+ *
+ * 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
+ *
+ * @example
+ * ```tsx
+ * <Route
+ *   path="/login"
+ *   element={
+ *     <AuthRoute>
+ *       <LoginPage />
+ *     </AuthRoute>
+ *   }
+ * />
+ * ```
+ */
+declare function AuthRoute({ children, redirectTo, loadingComponent, initTimeout }: AuthRouteProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Comportamiento de GuestRoute cuando el usuario está autenticado
+ */
+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
+     * @default 'redirect-if-authenticated'
+     */
+    behavior?: GuestRouteBehavior;
+    /**
+     * Ruta a la que redirigir si está autenticado y behavior es 'redirect-if-authenticated'
+     * @default "/"
+     */
+    redirectTo?: string;
+    /**
+     * Componente a mostrar mientras se valida la sesión
+     * @default <SessionLoadingScreen stage="validating-session" />
+     */
+    loadingComponent?: ReactNode;
+}
+/**
+ * Componente para rutas de invitados con comportamiento configurable
+ *
+ * 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
+ *
+ * @example
+ * ```tsx
+ * // Login - redirige si ya está autenticado
+ * <Route
+ *   path="/login"
+ *   element={
+ *     <GuestRoute behavior="redirect-if-authenticated">
+ *       <LoginPage />
+ *     </GuestRoute>
+ *   }
+ * />
+ *
+ * // Forgot password - permite acceso aunque esté autenticado
+ * <Route
+ *   path="/login/forgotPassword"
+ *   element={
+ *     <GuestRoute behavior="allow-all">
+ *       <ForgotPasswordPage />
+ *     </GuestRoute>
+ *   }
+ * />
+ * ```
+ */
+declare function GuestRoute({ children, behavior, redirectTo, loadingComponent }: GuestRouteProps): react_jsx_runtime.JSX.Element;
+
+interface SessionLoadingScreenProps {
+    /**
+     * Stage of loading to display appropriate message
+     * @default "loading"
+     */
+    stage?: "initializing" | "validating-session" | "loading";
+    /**
+     * Custom message to display (overrides default stage message)
+     */
+    message?: string;
+}
+/**
+ * Loading screen component for session-related loading states
+ *
+ * Features:
+ * - Clean, minimal design
+ * - Customizable message
+ * - Stage-based default messages
+ * - No external dependencies (works without i18n)
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <SessionLoadingScreen stage="validating-session" />
+ *
+ * // With custom message
+ * <SessionLoadingScreen
+ *   stage="validating-session"
+ *   message={t("loading.validatingSession")}
+ * />
+ * ```
+ */
+declare function SessionLoadingScreen({ stage, message, }: SessionLoadingScreenProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Utilidades de seguridad para validar redirecciones
+ * Previene ataques de open redirect permitiendo rutas dinámicas
+ */
+/**
+ * Valida que una ruta de redirección sea segura (solo rutas internas)
+ * Permite rutas dinámicas pero bloquea ataques de open redirect
+ *
+ * @param path - La ruta a validar
+ * @param defaultPath - Ruta por defecto si la validación falla
+ * @returns Ruta validada y segura
+ */
+declare const validateInternalRedirect: (path: string, defaultPath?: string) => string;
+/**
+ * Extrae y valida parámetro redirect de URL search params
+ *
+ * @param searchParams - URLSearchParams o string de query params
+ * @param defaultPath - Ruta por defecto
+ * @returns Ruta validada
+ */
+declare const extractSafeRedirectFromUrl: (searchParams: URLSearchParams | string, defaultPath?: string) => string;
+
+/**
+ * Verifica si hay tokens encriptados en localStorage
+ * Hace un check rápido sin desencriptar
+ *
+ * @returns true si parece haber tokens guardados en formato v2
+ */
+declare function hasStoredTokens(): boolean;
+/**
+ * Verifica si existe el hash de la clave de encriptación
+ * Si existe, indica que TokenStorage puede desencriptar los tokens
+ *
+ * @returns true si hay un hash de clave válido guardado
+ */
+declare function hasEncryptionKeyHash(): boolean;
+/**
+ * Determina si debemos esperar a la inicialización de la sesión
+ * antes de mostrar el formulario de login
+ *
+ * Retorna true si:
+ * - Hay tokens encriptados guardados
+ * - Hay un hash de clave de encriptación (para poder desencriptarlos)
+ *
+ * Esto indica alta probabilidad de sesión válida, por lo que
+ * deberíamos mostrar loading mientras se inicializa SessionManager
+ *
+ * @returns true si probablemente hay una sesión válida
+ */
+declare function shouldWaitForInitialization(): boolean;
+/**
+ * Verifica si los tokens parecen estar corruptos o incompletos
+ * Útil para decidir si limpiar el storage
+ *
+ * @returns true si hay datos pero parecen corruptos
+ */
+declare function hasCorruptedTokens(): boolean;
+/**
+ * Limpia tokens que parecen corruptos
+ * Solo debe llamarse si hasCorruptedTokens() retorna true
+ */
+declare function clearCorruptedTokens(): void;
+
+type InitializationPriority = "HIGH" | "LOW";
+type InitializationStatus = "UNINITIALIZED" | "INITIALIZING" | "INITIALIZED" | "ERROR";
+interface InitializationState {
+    status: InitializationStatus;
+    priority: InitializationPriority | null;
+    publicApiKey: string | null;
+    env: string | null;
+    error: Error | null;
+    initializedBy: string | null;
+}
+interface InitializationRequest {
+    priority: InitializationPriority;
+    publicApiKey: string;
+    env: "dev" | "stg" | "api" | "prod";
+    enableLogging?: boolean;
+    requestedBy: string;
+}
+/**
+ * CrudifyInitializationManager
+ *
+ * Singleton manager for controlling Crudify SDK initialization with priority system.
+ *
+ * **Priority System:**
+ * - HIGH: Explicit initialization via `<CrudifyInitializer>` component
+ * - LOW: Automatic fallback initialization in providers
+ *
+ * **Thread-Safe:**
+ * - Prevents duplicate initializations
+ * - Handles concurrent initialization requests
+ * - Shared promise ensures single initialization
+ *
+ * @example
+ * ```typescript
+ * // HIGH priority (CrudifyInitializer)
+ * await crudifyInitManager.initialize({
+ *   priority: "HIGH",
+ *   publicApiKey: "key",
+ *   env: "stg",
+ *   requestedBy: "CrudifyInitializer"
+ * });
+ *
+ * // LOW priority (provider auto-init)
+ * await crudifyInitManager.initialize({
+ *   priority: "LOW",
+ *   publicApiKey: "key",
+ *   env: "stg",
+ *   requestedBy: "SessionProvider"
+ * });
+ * ```
+ */
+declare class CrudifyInitializationManager {
+    private static instance;
+    private state;
+    private initializationPromise;
+    private highPriorityInitializerPresent;
+    private waitingForHighPriority;
+    private readonly HIGH_PRIORITY_WAIT_TIMEOUT;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): CrudifyInitializationManager;
+    /**
+     * Register that a HIGH priority initializer is present
+     * This must be called SYNCHRONOUSLY during component mount
+     */
+    registerHighPriorityInitializer(): void;
+    /**
+     * Check if a HIGH priority initializer is present
+     */
+    isHighPriorityInitializerPresent(): boolean;
+    /**
+     * Get current initialization state (read-only)
+     */
+    getState(): Readonly<InitializationState>;
+    /**
+     * Main initialization method - handles priority and concurrency
+     *
+     * @param request Initialization request with priority and config
+     * @returns Promise that resolves when initialization completes
+     * @throws Error if initialization fails
+     */
+    initialize(request: InitializationRequest): Promise<void>;
+    /**
+     * Wait for HIGH priority initializer with timeout
+     */
+    private waitForHighPriorityOrTimeout;
+    /**
+     * Actual SDK initialization
+     */
+    private performInitialization;
+    /**
+     * Reset initialization state (for testing)
+     */
+    reset(): void;
+    /**
+     * Check if initialized (without triggering initialization)
+     */
+    isInitialized(): boolean;
+    /**
+     * Get diagnostic info (for debugging)
+     */
+    getDiagnostics(): {
+        waitingCount: number;
+        waitingComponents: string[];
+        hasActivePromise: boolean;
+        status: InitializationStatus;
+        priority: InitializationPriority | null;
+        publicApiKey: string | null;
+        env: string | null;
+        error: Error | null;
+        initializedBy: string | null;
+    };
+}
+/**
+ * Export singleton instance
+ *
+ * @example
+ * ```typescript
+ * import { crudifyInitManager } from "@nocios/crudify-components";
+ *
+ * // Initialize with HIGH priority
+ * await crudifyInitManager.initialize({
+ *   priority: "HIGH",
+ *   publicApiKey: "your-key",
+ *   env: "stg",
+ *   requestedBy: "CrudifyInitializer"
+ * });
+ *
+ * // Check if initialized
+ * if (crudifyInitManager.isInitialized()) {
+ *   // Ready to use crudify SDK
+ * }
+ *
+ * // Get diagnostics
+ * console.log(crudifyInitManager.getDiagnostics());
+ * ```
+ */
+declare const crudifyInitManager: CrudifyInitializationManager;
+
+interface CrudifyInitializerConfig {
+    publicApiKey?: string;
+    env?: "dev" | "stg" | "api" | "prod";
+    enableLogging?: boolean;
+}
+interface CrudifyInitializerContextValue {
+    isInitialized: boolean;
+    isInitializing: boolean;
+    error: Error | null;
+}
+interface CrudifyInitializerProps {
+    config?: CrudifyInitializerConfig;
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+    onInitialized?: () => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * CrudifyInitializer Component
+ *
+ * HIGH priority Crudify SDK initializer component.
+ * Use this at the root of your app to explicitly control initialization.
+ *
+ * **Features:**
+ * - HIGH priority initialization (takes precedence over auto-init)
+ * - Provides initialization status via context
+ * - Optional loading fallback while initializing
+ * - Callbacks for initialization complete/error
+ * - React 18 StrictMode compatible
+ *
+ * **Usage:**
+ * ```tsx
+ * // App.tsx
+ * import { CrudifyInitializer } from "@nocios/crudify-components";
+ *
+ * function App() {
+ *   return (
+ *     <CrudifyInitializer
+ *       config={{
+ *         publicApiKey: import.meta.env.VITE_CRUDIFY_PUBLIC_API_KEY,
+ *         env: "stg",
+ *         enableLogging: true,
+ *       }}
+ *       fallback={<div>Loading Crudify...</div>}
+ *       onInitialized={() => console.log("Crudify ready!")}
+ *       onError={(err) => console.error("Init failed:", err)}
+ *     >
+ *       <SessionProvider>
+ *         <TranslationsProvider>
+ *           <App />
+ *         </TranslationsProvider>
+ *       </SessionProvider>
+ *     </CrudifyInitializer>
+ *   );
+ * }
+ * ```
+ *
+ * **Context Access:**
+ * ```tsx
+ * import { useCrudifyInitializer } from "@nocios/crudify-components";
+ *
+ * function MyComponent() {
+ *   const { isInitialized, isInitializing, error } = useCrudifyInitializer();
+ *
+ *   if (isInitializing) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   if (!isInitialized) return null;
+ *
+ *   return <div>Crudify is ready!</div>;
+ * }
+ * ```
+ */
+declare const CrudifyInitializer: React.FC<CrudifyInitializerProps>;
+/**
+ * Hook to access CrudifyInitializer context
+ *
+ * @returns Initialization status (isInitialized, isInitializing, error)
+ * @throws Error if used outside CrudifyInitializer
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isInitialized, isInitializing, error } = useCrudifyInitializer();
+ *
+ *   if (isInitializing) return <Spinner />;
+ *   if (error) return <ErrorDisplay error={error} />;
+ *
+ *   return <div>Ready!</div>;
+ * }
+ * ```
+ */
+declare const useCrudifyInitializer: () => CrudifyInitializerContextValue;
+
+/** i18next instance interface for auto-syncing translations */
+interface I18nInstance {
+    addResourceBundle: (lang: string, ns: string, resources: Record<string, string>, deep?: boolean, overwrite?: boolean) => void;
+    language?: string;
+    changeLanguage?: (lang: string) => void;
+}
+interface TranslationsProviderProps {
+    children: React.ReactNode;
+    apiKey?: string;
+    crudifyEnv?: "dev" | "stg" | "api" | "prod";
+    featureKeys?: string[];
+    language?: string;
+    devTranslations?: Record<string, string>;
+    translationUrl?: string;
+    enableDebug?: boolean;
+    skipAutoInit?: boolean;
+    autoSyncI18n?: boolean;
+    i18nInstance?: I18nInstance;
+    loadingFallback?: React.ReactNode;
+    waitForInitialLoad?: boolean;
+}
+interface TranslationsContextValue {
+    t: (key: string, variables?: Record<string, string | number>) => string;
+    language: string;
+    availableLanguages: string[];
+    translations: Record<string, Record<string, string>>;
+    isLoading: boolean;
+    error: string | null;
+    refreshTranslations: () => Promise<void>;
+}
+/**
+ * TranslationsProvider
+ *
+ * Provides translation functionality to the application
+ * Handles fetching, caching, and fallback strategies
+ *
+ * Note: The app MUST initialize crudify before mounting TranslationsProvider
+ *
+ * @example Basic usage
+ * ```tsx
+ * // App must initialize crudify first
+ * await crudify.init(publicApiKey, 'debug')
+ *
+ * <TranslationsProvider
+ *   apiKey="xxx"
+ *   language="es"
+ *   translationUrl="https://example.com/locales/es/translation.json"
+ *   skipAutoInit={true}
+ * >
+ *   <App />
+ * </TranslationsProvider>
+ * ```
+ *
+ * @example With custom loading fallback (recommended for better UX)
+ * ```tsx
+ * <TranslationsProvider
+ *   apiKey="xxx"
+ *   crudifyEnv="prod"
+ *   language={i18n.language}
+ *   autoSyncI18n={true}
+ *   i18nInstance={i18n}
+ *   waitForInitialLoad={true}  // Default - waits on first visit
+ *   loadingFallback={<LoadingSpinner />}  // Custom loading component
+ * >
+ *   <App />
+ * </TranslationsProvider>
+ * ```
+ *
+ * @example Disable waiting (legacy behavior - may show keys briefly)
+ * ```tsx
+ * <TranslationsProvider
+ *   apiKey="xxx"
+ *   language="es"
+ *   waitForInitialLoad={false}  // Don't wait - render immediately
+ * >
+ *   <App />
+ * </TranslationsProvider>
+ * ```
+ */
+declare const TranslationsProvider: React.FC<TranslationsProviderProps>;
+/**
+ * Hook to use translations
+ *
+ * @example
+ * ```tsx
+ * const MyComponent = () => {
+ *   const { t } = useTranslations();
+ *   return <h1>{t('welcome.title')}</h1>;
+ * };
+ * ```
+ */
+declare const useTranslations: () => TranslationsContextValue;
+
+interface FetchTranslationsOptions {
+    apiKey: string;
+    crudifyEnv?: "dev" | "stg" | "api" | "prod";
+    featureKeys?: string[];
+    urlTranslations?: Record<string, string>;
+}
+interface TranslationResponse {
+    languages: string[];
+    translations: Record<string, Record<string, string>>;
+    timestamp: string;
+}
+/**
+ * Translation Service
+ * Handles fetching, caching, and fallback strategies for translations
+ * Uses Crudify SDK for API calls
+ *
+ * Priority order (lowest to highest):
+ * 1. Critical bundle (fallback)
+ * 2. API translations (system + subscriber merged by backend)
+ * 3. URL translations (buildTranslations from config.json or translationUrl)
+ * 4. Dev translations (props override - handled by provider)
+ */
+declare class TranslationService {
+    private static instance;
+    private enableDebug;
+    private initializationPromise;
+    private isInitialized;
+    private constructor();
+    static getInstance(): TranslationService;
+    /**
+     * Set debug mode
+     */
+    setDebug(enable: boolean): void;
+    /**
+     * Ensure crudify is initialized before making API calls
+     * Thread-safe: multiple calls will wait for the same initialization
+     */
+    private ensureCrudifyInitialized;
+    /**
+     * Fetch translations with cache strategy
+     * 1. Try cache (if valid and not changed)
+     * 2. Ensure crudify is initialized
+     * 3. Try API fetch via crudify SDK
+     * 4. Try expired cache
+     * 5. Fall back to critical bundle
+     */
+    fetchTranslations(options: FetchTranslationsOptions): Promise<Record<string, Record<string, string>>>;
+    /**
+     * Fetch from API via crudify SDK
+     */
+    private fetchFromAPI;
+    /**
+     * Merge API translations with URL translations
+     * URL translations have higher priority
+     */
+    private mergeWithUrlTranslations;
+    /**
+     * Check if data has changed (compare timestamps or hash)
+     */
+    private hasDataChanged;
+    /**
+     * Simple hash function for data comparison
+     */
+    private hashData;
+    /**
+     * Save to localStorage
+     */
+    private saveToCache;
+    /**
+     * Read from localStorage
+     */
+    private getFromCache;
+    /**
+     * Refresh cache timestamp without changing data
+     */
+    private refreshCacheTimestamp;
+    /**
+     * Check if cache is expired
+     */
+    private isCacheExpired;
+    /**
+     * Check if there is valid (non-expired) cache available
+     * Public method for TranslationsProvider to check before rendering
+     */
+    hasValidCache(apiKey: string): boolean;
+    /**
+     * Generate cache key from apiKey
+     * Uses a hash to ensure privacy and consistent length
+     */
+    private getCacheKey;
+    /**
+     * Get only critical translations from bundle
+     */
+    private getCriticalTranslationsOnly;
+    /**
+     * Invalidate cache (useful for testing/debugging)
+     */
+    invalidateCache(apiKey: string): void;
+    /**
+     * Prefetch translations in background
+     */
+    prefetchTranslations(options: FetchTranslationsOptions): Promise<void>;
+    /**
+     * Clear all translation caches
+     */
+    clearAllCaches(): void;
+}
+declare const translationService: TranslationService;
+
+/**
+ * Critical translations bundle
+ * These translations are bundled with the application to ensure
+ * basic functionality (login, errors, loading) works even if the API is unavailable
+ *
+ * Total keys: 108
+ * - login.*: 15 keys
+ * - forgotPassword.*: 11 keys
+ * - checkCode.*: 11 keys
+ * - resetPassword.*: 19 keys
+ * - errors.*: 39 keys
+ * - loading.*: 5 keys
+ * - common (basic): 2 keys
+ * - footer.*: 2 keys
+ * - error.app.*: 4 keys
+ */
+declare const CRITICAL_TRANSLATIONS: {
+    readonly es: {
+        readonly "checkCode.codeLabel": "Código de Verificación";
+        readonly "checkCode.codePlaceholder": "Ingresa el código de 6 dígitos";
+        readonly "checkCode.codeRequired": "El código es obligatorio";
+        readonly "checkCode.emailLabel": "Correo Electrónico";
+        readonly "checkCode.emailPlaceholder": "Ingresa tu correo electrónico";
+        readonly "checkCode.emailRequired": "El correo electrónico es obligatorio";
+        readonly "checkCode.instructions": "Ingresa el código de 6 dígitos que enviamos a tu correo electrónico.";
+        readonly "checkCode.invalidEmail": "Ingresa un correo electrónico válido";
+        readonly "checkCode.resendCodeLink": "Reenviar código";
+        readonly "checkCode.title": "Verificar Código";
+        readonly "checkCode.verifyButton": "Verificar Código";
+        readonly "base.btn.back": "Volver";
+        readonly "base.btn.cancel": "Cancelar";
+        readonly "error.app.config": "Error de Configuración: {{message}}";
+        readonly "error.app.initialization": "Error durante la inicialización final de la aplicación.";
+        readonly "error.transaction": "Error en la operación";
+        readonly "base.errors.errorUnknown": "Ocurrió un error desconocido.";
+        readonly "errors.DUPLICATE": "El campo <b>{{field}}</b> debe ser único.";
+        readonly "errors.FOREIGN_KEY_NOT_FOUND": "El campo <b>{{field}}</b> debe referenciar un ítem existente.";
+        readonly "errors.INVALID_EMAIL": "El campo <b>{{field}}</b> debe ser un correo electrónico válido.";
+        readonly "errors.INVALID_OBJECT_ID": "El campo <b>{{field}}</b> debe ser un valor válido.";
+        readonly "errors.IN_USE": "El ítem está en uso y no puede ser eliminado.";
+        readonly "errors.MAX_LENGTH": "El campo <b>{{field}}</b> no debe exceder los <b>{{length}}</b> caracteres.";
+        readonly "errors.MIN_LENGTH": "El campo <b>{{field}}</b> debe tener al menos <b>{{length}}</b> caracteres.";
+        readonly "errors.MUST_NOT_BE_EMAIL": "El campo <b>{{field}}</b> no debe ser un correo electrónico.";
+        readonly "errors.NO_PERMISSION": "No tienes permiso para realizar esta acción.";
+        readonly "errors.NO_SPACES": "El campo <b>{{field}}</b> no debe contener espacios.";
+        readonly "errors.ONE_OR_MORE_OPERATIONS_FAILED": "Error en la operación";
+        readonly "errors.REQUIRED": "El campo <b>{{field}}</b> es obligatorio.";
+        readonly "errors.TOKEN_HAS_EXPIRED": "La sesión ha expirado. Por favor, inicia sesión nuevamente.";
+        readonly "errors.TOO_MANY_REQUESTS": "Límite de solicitudes alcanzado. Por favor intenta más tarde.";
+        readonly "errors.UNAUTHORIZED": "No estás autorizado para realizar esta acción.";
+        readonly "errors.all_password_fields_required": "Todos los campos de contraseña son obligatorios";
+        readonly "errors.auth.INVALID_API_KEY": "Clave de API inválida";
+        readonly "errors.auth.INVALID_CREDENTIALS": "Usuario y/o contraseña incorrectos";
+        readonly "errors.auth.NO_PERMISSION": "No tienes permisos suficientes";
+        readonly "errors.auth.SESSION_EXPIRED": "Tu sesión ha expirado. Por favor, inicia sesión nuevamente.";
+        readonly "errors.auth.TOO_MANY_REQUESTS": "Demasiados intentos. Por favor espera 15 minutos e intenta nuevamente";
+        readonly "errors.auth.UNAUTHORIZED": "No tienes permisos para realizar esta acción";
+        readonly "errors.auth.USER_NOT_ACTIVE": "Usuario no activo";
+        readonly "errors.auth.USER_NOT_FOUND": "Usuario no encontrado";
+        readonly "errors.data.BAD_REQUEST": "Solicitud inválida";
+        readonly "errors.data.FIELD_ERROR": "Error en los datos ingresados";
+        readonly "errors.data.IN_USE": "El elemento está en uso y no puede ser eliminado";
+        readonly "errors.data.ITEM_NOT_FOUND": "El elemento solicitado no fue encontrado";
+        readonly "errors.data.NOT_FOUND": "No se encontró lo solicitado";
+        readonly "errors.internal_error_changing_password": "Error interno al cambiar la contraseña. Intenta nuevamente";
+        readonly "errors.password_min_length": "La contraseña debe tener al menos 8 caracteres";
+        readonly "errors.password_mismatch": "Las contraseñas no coinciden";
+        readonly "errors.password_must_be_different": "La nueva contraseña debe ser diferente a la actual";
+        readonly "errors.system.DATABASE_CONNECTION_ERROR": "Error de conexión. Verifica tu conexión a internet.";
+        readonly "errors.system.INTERNAL_SERVER_ERROR": "Error interno del servidor. Intenta nuevamente.";
+        readonly "errors.system.INVALID_CONFIGURATION": "Error de configuración del sistema";
+        readonly "errors.system.TOO_MANY_REQUESTS": "Demasiadas solicitudes. Por favor espera un momento e intenta nuevamente";
+        readonly "errors.system.UNKNOWN_OPERATION": "Operación no reconocida";
+        readonly "errors.users_module_not_configured": "Módulo de usuarios no configurado";
+        readonly "footer.copyright": "Nocios S.R.L. Todos los derechos reservados.";
+        readonly "footer.version": "Versión";
+        readonly "forgotPassword.checkEmailInstructions": "Revisa tu bandeja de entrada para el código de verificación";
+        readonly "forgotPassword.codeAlreadyExistsMessage": "Ya se envió un código y aún es válido";
+        readonly "forgotPassword.emailLabel": "Correo Electrónico";
+        readonly "forgotPassword.emailPlaceholder": "Ingresa tu correo electrónico";
+        readonly "forgotPassword.emailRequired": "El correo electrónico es obligatorio";
+        readonly "forgotPassword.emailSentMessage": "Código enviado exitosamente";
+        readonly "forgotPassword.enterCodeLink": "Ingresar Código";
+        readonly "forgotPassword.instructions": "Ingresa tu correo electrónico y te enviaremos un código para restablecer tu contraseña.";
+        readonly "forgotPassword.invalidEmail": "Ingresa un correo electrónico válido";
+        readonly "forgotPassword.sendCodeButton": "Enviar Código";
+        readonly "forgotPassword.title": "Recuperar Contraseña";
+        readonly "base.loading.configInitial": "Cargando configuración inicial...";
+        readonly "base.loading.pleaseWait": "Cargando, por favor espera...";
+        readonly "base.loading.starting": "Iniciando aplicación...";
+        readonly "base.loading.themeSetup": "Generando tema...";
+        readonly "base.loading.validatingSession": "Validando sesión...";
+        readonly "login.alreadyHaveCodeLink": "¿Ya tienes un código?";
+        readonly "login.forgotPasswordLink": "¿Olvidaste tu contraseña?";
+        readonly "login.initializationError": "Error de inicialización";
+        readonly "login.initializing": "Inicializando...";
+        readonly "login.loginButton": "Iniciar Sesión";
+        readonly "login.logoAlt": "Logotipo";
+        readonly "login.noAccountPrompt": "¿No tienes una cuenta?";
+        readonly "login.notInitialized": "Sistema no inicializado";
+        readonly "login.passwordLabel": "Contraseña";
+        readonly "login.passwordPlaceholder": "Ingresa tu contraseña";
+        readonly "login.passwordRequired": "Contraseña es obligatoria";
+        readonly "login.signUpLink": "Regístrate";
+        readonly "login.usernameOrEmailLabel": "Correo Electrónico";
+        readonly "login.usernameOrEmailPlaceholder": "Ingresa tu correo electrónico";
+        readonly "login.usernameRequired": "Correo electrónico es obligatorio";
+        readonly "resetPassword.codeExpiredOrInvalid": "El código ha expirado o es inválido";
+        readonly "resetPassword.confirmPasswordLabel": "Confirmar Contraseña";
+        readonly "resetPassword.confirmPasswordPlaceholder": "Confirma tu nueva contraseña";
+        readonly "resetPassword.confirmPasswordRequired": "Confirma tu contraseña";
+        readonly "resetPassword.goToLoginButton": "Ir al Login";
+        readonly "resetPassword.instructions": "Ingresa tu nueva contraseña.";
+        readonly "resetPassword.invalidCode": "El código de verificación es inválido. Por favor, verifica el enlace o solicita uno nuevo.";
+        readonly "resetPassword.missingParameters": "Faltan parámetros obligatorios";
+        readonly "resetPassword.newPasswordLabel": "Nueva Contraseña";
+        readonly "resetPassword.newPasswordPlaceholder": "Ingresa tu nueva contraseña";
+        readonly "resetPassword.newPasswordRequired": "La nueva contraseña es obligatoria";
+        readonly "resetPassword.passwordTooShort": "La contraseña debe tener al menos 8 caracteres";
+        readonly "resetPassword.passwordsDoNotMatch": "Las contraseñas no coinciden";
+        readonly "resetPassword.requestNewCodeButton": "Solicitar Nuevo Código";
+        readonly "resetPassword.resetPasswordButton": "Restablecer Contraseña";
+        readonly "resetPassword.successInstructions": "Ahora puedes iniciar sesión con tu nueva contraseña";
+        readonly "resetPassword.successMessage": "Contraseña restablecida exitosamente";
+        readonly "resetPassword.title": "Nueva Contraseña";
+        readonly "resetPassword.validatingCode": "Validando código...";
+        readonly "resetPassword.passwordRequirementsNotMet": "La contraseña no cumple con todos los requisitos";
+        readonly "passwordRequirements.minLength": "Mínimo 8 caracteres";
+        readonly "passwordRequirements.uppercase": "Una letra mayúscula";
+        readonly "passwordRequirements.lowercase": "Una letra minúscula";
+        readonly "passwordRequirements.number": "Un número";
+        readonly "passwordRequirements.special": "Un carácter especial (!@#$%...)";
+        readonly "base.btn.showPassword": "Mostrar contraseña";
+        readonly "base.btn.hidePassword": "Ocultar contraseña";
+        readonly "publicPolicies.fields.conditions.customEdit": "Edición personalizada";
+        readonly "base.file.clickToPreview": "Clic para ver imagen";
+        readonly "base.file.clickToDownload": "Clic para descargar";
+        readonly "base.file.privateFile": "Archivo privado";
+        readonly "base.file.noPreview": "Sin vista previa";
+        readonly "base.file.dropHere": "Suelta el archivo aquí";
+        readonly "base.file.dragOrClick": "Arrastra archivos aquí o haz clic para seleccionar";
+        readonly "base.file.uploading": "Subiendo archivos...";
+        readonly "base.file.restore": "Restaurar";
+        readonly "base.file.delete": "Eliminar";
+        readonly "base.file.pendingDeletion": "Pendiente de eliminación";
+        readonly "base.file.allowedTypes": "Tipos permitidos: {{types}}";
+        readonly "base.file.maxSize": "Máximo {{size}} por archivo";
+        readonly "base.file.maxFiles": "Máximo {{count}} archivos";
+        readonly "base.file.validation.minFilesRequired": "Se requiere al menos un archivo";
+        readonly "base.file.validation.minFilesRequiredPlural": "Se requieren al menos {{count}} archivos";
+        readonly "base.file.validation.maxFilesExceeded": "Máximo {{count}} archivos permitidos";
+        readonly "base.file.validation.filesWithErrors": "Algunos archivos tienen errores";
+        readonly "base.file.confirmDelete.title": "Eliminar archivo";
+        readonly "base.file.confirmDelete.message": "¿Estás seguro de que deseas eliminar este archivo? Esta acción no se puede deshacer.";
+        readonly "base.file.confirmDelete.confirm": "Eliminar";
+        readonly "base.file.confirmDelete.cancel": "Cancelar";
+        readonly "base.file.deleting": "Eliminando...";
+    };
+    readonly en: {
+        readonly "checkCode.codeLabel": "Verification Code";
+        readonly "checkCode.codePlaceholder": "Enter 6-digit code";
+        readonly "checkCode.codeRequired": "Code is required";
+        readonly "checkCode.emailLabel": "Email Address";
+        readonly "checkCode.emailPlaceholder": "Enter your email address";
+        readonly "checkCode.emailRequired": "Email address is required";
+        readonly "checkCode.instructions": "Enter the 6-digit code we sent to your email address.";
+        readonly "checkCode.invalidEmail": "Enter a valid email address";
+        readonly "checkCode.resendCodeLink": "Resend code";
+        readonly "checkCode.title": "Verify Code";
+        readonly "checkCode.verifyButton": "Verify Code";
+        readonly "base.btn.back": "Back";
+        readonly "base.btn.cancel": "Cancel";
+        readonly "error.app.config": "Configuration Error: {{message}}";
+        readonly "error.app.initialization": "Error during final application initialization.";
+        readonly "error.transaction": "Operation error";
+        readonly "base.errors.errorUnknown": "An unknown error occurred.";
+        readonly "errors.DUPLICATE": "The field <b>{{field}}</b> must be unique.";
+        readonly "errors.FOREIGN_KEY_NOT_FOUND": "The field <b>{{field}}</b> must reference an existing item.";
+        readonly "errors.INVALID_EMAIL": "The field <b>{{field}}</b> must be a valid email address.";
+        readonly "errors.INVALID_OBJECT_ID": "The field <b>{{field}}</b> must be a valid value.";
+        readonly "errors.IN_USE": "The item is currently in use and cannot be deleted.";
+        readonly "errors.MAX_LENGTH": "The field <b>{{field}}</b> must not exceed <b>{{maxLength}}</b> characters.";
+        readonly "errors.MIN_LENGTH": "The field <b>{{field}}</b> must have at least <b>{{minLength}}</b> characters.";
+        readonly "errors.MUST_NOT_BE_EMAIL": "The field <b>{{field}}</b> must not be an email address.";
+        readonly "errors.NO_PERMISSION": "You do not have permission to perform this action.";
+        readonly "errors.NO_SPACES": "The field <b>{{field}}</b> must not contain spaces.";
+        readonly "errors.ONE_OR_MORE_OPERATIONS_FAILED": "Operation error";
+        readonly "errors.REQUIRED": "The field <b>{{field}}</b> is required.";
+        readonly "errors.TOKEN_HAS_EXPIRED": "Your session has expired, please log in again.";
+        readonly "errors.TOO_MANY_REQUESTS": "Request limit reached. Please try again later.";
+        readonly "errors.UNAUTHORIZED": "You are not authorized to perform this action.";
+        readonly "errors.all_password_fields_required": "All password fields are required";
+        readonly "errors.auth.INVALID_API_KEY": "Invalid API key";
+        readonly "errors.auth.INVALID_CREDENTIALS": "Incorrect username and/or password";
+        readonly "errors.auth.NO_PERMISSION": "Insufficient permissions";
+        readonly "errors.auth.SESSION_EXPIRED": "Your session has expired. Please log in again.";
+        readonly "errors.auth.TOO_MANY_REQUESTS": "Too many attempts. Please wait 15 minutes and try again";
+        readonly "errors.auth.UNAUTHORIZED": "You don't have permission to perform this action";
+        readonly "errors.auth.USER_NOT_ACTIVE": "User account is not active";
+        readonly "errors.auth.USER_NOT_FOUND": "User not found";
+        readonly "errors.data.BAD_REQUEST": "Invalid request";
+        readonly "errors.data.FIELD_ERROR": "Error in the provided data";
+        readonly "errors.data.IN_USE": "The item is in use and cannot be deleted";
+        readonly "errors.data.ITEM_NOT_FOUND": "The requested item was not found";
+        readonly "errors.data.NOT_FOUND": "The requested resource was not found";
+        readonly "errors.internal_error_changing_password": "Internal error changing password. Please try again";
+        readonly "errors.password_min_length": "Password must be at least 8 characters";
+        readonly "errors.password_mismatch": "Passwords do not match";
+        readonly "errors.password_must_be_different": "New password must be different from current password";
+        readonly "errors.system.DATABASE_CONNECTION_ERROR": "Connection error. Please check your internet connection.";
+        readonly "errors.system.INTERNAL_SERVER_ERROR": "Internal server error. Please try again.";
+        readonly "errors.system.INVALID_CONFIGURATION": "System configuration error";
+        readonly "errors.system.TOO_MANY_REQUESTS": "Too many requests. Please wait a moment and try again";
+        readonly "errors.system.UNKNOWN_OPERATION": "Unrecognized operation";
+        readonly "errors.users_module_not_configured": "Users module not configured";
+        readonly "footer.copyright": "Nocios S.R.L. All Rights Reserved.";
+        readonly "footer.version": "Version";
+        readonly "forgotPassword.checkEmailInstructions": "Check your inbox for the verification code";
+        readonly "forgotPassword.codeAlreadyExistsMessage": "A code was already sent and is still valid";
+        readonly "forgotPassword.emailLabel": "Email Address";
+        readonly "forgotPassword.emailPlaceholder": "Enter your email address";
+        readonly "forgotPassword.emailRequired": "Email address is required";
+        readonly "forgotPassword.emailSentMessage": "Code sent successfully";
+        readonly "forgotPassword.enterCodeLink": "Enter Code";
+        readonly "forgotPassword.instructions": "Enter your email address and we'll send you a code to reset your password.";
+        readonly "forgotPassword.invalidEmail": "Enter a valid email address";
+        readonly "forgotPassword.sendCodeButton": "Send Code";
+        readonly "forgotPassword.title": "Reset Password";
+        readonly "base.loading.configInitial": "Loading initial configuration...";
+        readonly "base.loading.pleaseWait": "Loading, please wait...";
+        readonly "base.loading.starting": "Starting application...";
+        readonly "base.loading.themeSetup": "Generating theme...";
+        readonly "base.loading.validatingSession": "Validating session...";
+        readonly "login.alreadyHaveCodeLink": "Already have a code?";
+        readonly "login.forgotPasswordLink": "Forgot Password?";
+        readonly "login.initializationError": "Initialization error";
+        readonly "login.initializing": "Initializing...";
+        readonly "login.loginButton": "Log In";
+        readonly "login.logoAlt": "Logo";
+        readonly "login.noAccountPrompt": "Don't have an account?";
+        readonly "login.notInitialized": "System not initialized";
+        readonly "login.passwordLabel": "Password";
+        readonly "login.passwordPlaceholder": "Enter your password";
+        readonly "login.passwordRequired": "Password is required";
+        readonly "login.signUpLink": "Sign up";
+        readonly "login.usernameOrEmailLabel": "Username or Email";
+        readonly "login.usernameOrEmailPlaceholder": "Enter your username or email";
+        readonly "login.usernameRequired": "Username or email is required";
+        readonly "resetPassword.codeExpiredOrInvalid": "Code expired or invalid";
+        readonly "resetPassword.confirmPasswordLabel": "Confirm Password";
+        readonly "resetPassword.confirmPasswordPlaceholder": "Confirm your new password";
+        readonly "resetPassword.confirmPasswordRequired": "Confirm your password";
+        readonly "resetPassword.goToLoginButton": "Go to Login";
+        readonly "resetPassword.instructions": "Enter your new password.";
+        readonly "resetPassword.invalidCode": "The verification code is invalid. Please check the link or request a new one.";
+        readonly "resetPassword.missingParameters": "Missing required parameters";
+        readonly "resetPassword.newPasswordLabel": "New Password";
+        readonly "resetPassword.newPasswordPlaceholder": "Enter your new password";
+        readonly "resetPassword.newPasswordRequired": "New password is required";
+        readonly "resetPassword.passwordTooShort": "Password must be at least 8 characters";
+        readonly "resetPassword.passwordsDoNotMatch": "Passwords do not match";
+        readonly "resetPassword.requestNewCodeButton": "Request New Code";
+        readonly "resetPassword.resetPasswordButton": "Reset Password";
+        readonly "resetPassword.successInstructions": "You can now log in with your new password";
+        readonly "resetPassword.successMessage": "Password reset successfully";
+        readonly "resetPassword.title": "New Password";
+        readonly "resetPassword.validatingCode": "Validating code...";
+        readonly "resetPassword.passwordRequirementsNotMet": "Password does not meet all requirements";
+        readonly "passwordRequirements.minLength": "Minimum 8 characters";
+        readonly "passwordRequirements.uppercase": "One uppercase letter";
+        readonly "passwordRequirements.lowercase": "One lowercase letter";
+        readonly "passwordRequirements.number": "One number";
+        readonly "passwordRequirements.special": "One special character (!@#$%...)";
+        readonly "base.btn.showPassword": "Show password";
+        readonly "base.btn.hidePassword": "Hide password";
+        readonly "publicPolicies.fields.conditions.customEdit": "Custom Edit";
+        readonly "base.file.clickToPreview": "Click to preview";
+        readonly "base.file.clickToDownload": "Click to download";
+        readonly "base.file.privateFile": "Private file";
+        readonly "base.file.noPreview": "No preview";
+        readonly "base.file.dropHere": "Drop file here";
+        readonly "base.file.dragOrClick": "Drag files here or click to select";
+        readonly "base.file.uploading": "Uploading files...";
+        readonly "base.file.restore": "Restore";
+        readonly "base.file.delete": "Delete";
+        readonly "base.file.pendingDeletion": "Pending deletion";
+        readonly "base.file.allowedTypes": "Allowed types: {{types}}";
+        readonly "base.file.maxSize": "Max {{size}} per file";
+        readonly "base.file.maxFiles": "Max {{count}} files";
+        readonly "base.file.validation.minFilesRequired": "At least one file is required";
+        readonly "base.file.validation.minFilesRequiredPlural": "At least {{count}} files are required";
+        readonly "base.file.validation.maxFilesExceeded": "Maximum {{count}} files allowed";
+        readonly "base.file.validation.filesWithErrors": "Some files have errors";
+        readonly "base.file.confirmDelete.title": "Delete file";
+        readonly "base.file.confirmDelete.message": "Are you sure you want to delete this file? This action cannot be undone.";
+        readonly "base.file.confirmDelete.confirm": "Delete";
+        readonly "base.file.deleting": "Deleting...";
+        readonly "base.file.confirmDelete.cancel": "Cancel";
+    };
+};
+type CriticalTranslationKey = keyof typeof CRITICAL_TRANSLATIONS.es;
+type SupportedLanguage = keyof typeof CRITICAL_TRANSLATIONS;
+/**
+ * Get list of supported languages
+ */
+declare const getCriticalLanguages: () => SupportedLanguage[];
+/**
+ * Get critical translations for a specific language
+ * Falls back to Spanish if language not found
+ */
+declare const getCriticalTranslations: (language: string) => Record<string, string>;
+
+/**
+ * crudifyAdmin wrapper with auto-initialization.
+ * 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>>;
+};
+
+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 };