@nocios/crudify-ui 2.0.0 → 3.0.0

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import crudify__default from '@nocios/crudify-browser';
 export * from '@nocios/crudify-browser';
 export { default as crudify } from '@nocios/crudify-browser';
 import React, { ReactNode } from 'react';
@@ -158,792 +157,6 @@ interface ValidationError {
     code: string;
 }
 
-/**
- * Configuration interface for CrudifyDataProvider
- * Supports multi-tenant configurations via environment variables, cookies, or direct props
- */
-interface CrudifyConfig {
-    env?: "dev" | "stg" | "prod";
-    publicApiKey?: string;
-    loginActions?: string[];
-    appName?: string;
-    logo?: string;
-    colors?: Record<string, string>;
-}
-/**
- * Source of configuration values for debugging and validation
- */
-type ConfigSource = "props" | "env" | "cookies" | "default";
-/**
- * Detailed configuration with source tracking for debugging
- */
-interface ResolvedConfig extends Required<CrudifyConfig> {
-    configSource: Record<keyof CrudifyConfig, ConfigSource>;
-    rawConfig: Record<string, any>;
-}
-/**
- * Configuration Manager for CrudifyDataProvider
- *
- * Handles configuration priority:
- * 1. Props passed explicitly to the Provider
- * 2. Environment variables (VITE_TEST_*)
- * 3. Cookies (for multi-tenant)
- * 4. Default values or error if required fields missing
- *
- * This ensures compatibility with both crudia-ui (cookie-based) and crudify-ui (env-based)
- */
-declare class ConfigurationManager {
-    private static instance;
-    private resolvedConfig;
-    private configError;
-    /**
-     * Singleton pattern to ensure consistent configuration across the app
-     */
-    static getInstance(): ConfigurationManager;
-    /**
-     * Reset the singleton instance (useful for testing)
-     */
-    static resetInstance(): void;
-    private constructor();
-    /**
-     * Resolve configuration from all sources with proper priority
-     */
-    resolveConfig(propsConfig?: Partial<CrudifyConfig>): ResolvedConfig;
-    /**
-     * Check if current configuration is still valid for the given props
-     */
-    private isConfigStillValid;
-    /**
-     * Resolve a single config value with priority and source tracking
-     */
-    private resolveValue;
-    /**
-     * Obtener configuración de variables de entorno
-     */
-    private getEnvConfig;
-    /**
-     * Obtener configuración de cookies (soporte multi-tenant)
-     */
-    private getCookieConfig;
-    /**
-     * Get the current resolved configuration
-     */
-    getConfig(): ResolvedConfig | null;
-    /**
-     * Get any configuration errors
-     */
-    getConfigError(): string | null;
-    /**
-     * Check if configuration is valid (no errors and has required fields)
-     */
-    isConfigured(): boolean;
-    /**
-     * Clear the current configuration (useful for testing or reconfiguration)
-     */
-    clearConfig(): void;
-}
-/**
- * Singleton instance for easy access
- */
-declare const configurationManager: ConfigurationManager;
-
-/**
- * CrudifyInitializer handles the critical task of initializing the crudify library
- * exactly once, preventing the "Crudify: Not initialized" and double initialization errors
- * that occur when both crudia-ui and crudify-ui try to initialize crudify independently.
- *
- * This is a singleton that ensures:
- * 1. Only one initialization attempt at a time
- * 2. Subsequent calls wait for the first initialization to complete
- * 3. Proper error handling and recovery
- * 4. Verification that crudify methods are available after initialization
- * 5. Thread-safe initialization in React's concurrent mode
- */
-declare class CrudifyInitializer {
-    private static instance;
-    private state;
-    /**
-     * Singleton pattern to ensure global initialization coordination
-     */
-    static getInstance(): CrudifyInitializer;
-    /**
-     * Reset the singleton instance (useful for testing)
-     */
-    static resetInstance(): void;
-    private constructor();
-    /**
-     * Inicializar crudify con la configuración dada
-     * Este método es idempotente y thread-safe
-     */
-    initialize(config: CrudifyConfig): Promise<void>;
-    /**
-     * Realizar el proceso de inicialización actual
-     */
-    private performInitialization;
-    /**
-     * Verificar que crudify esté correctamente inicializado revisando métodos principales
-     */
-    private verifyInitialization;
-    /**
-     * Verificar si la configuración dada es la misma que la actual
-     */
-    private isConfigurationSame;
-    /**
-     * Resetear el estado de inicialización (útil para testing o cambios de configuración)
-     */
-    reset(): void;
-    /**
-     * Obtener el estado actual de inicialización
-     */
-    getStatus(): {
-        isInitialized: boolean;
-        isInitializing: boolean;
-        initializationError: string | null;
-        config: CrudifyConfig | null;
-    };
-    /**
-     * Verificar si crudify está listo para usar
-     */
-    isReady(): boolean;
-    /**
-     * Obtener el error de inicialización actual, si existe
-     */
-    getError(): string | null;
-    /**
-     * Forzar re-inicialización (útil cuando la configuración cambia)
-     */
-    reinitialize(config: CrudifyConfig): Promise<void>;
-    /**
-     * Verificar si la inicialización está actualmente en progreso
-     */
-    isInitializing(): boolean;
-    /**
-     * Esperar a que cualquier inicialización en curso se complete
-     */
-    waitForInitialization(): Promise<void>;
-}
-/**
- * Instancia singleton para fácil acceso
- */
-declare const crudifyInitializer: CrudifyInitializer;
-
-/**
- * Enhanced JWT payload interface with Cognito-specific fields
- */
-interface JWTPayload$1 extends JwtPayload {
-    "cognito:username"?: string;
-}
-/**
- * TokenManager handles all JWT token operations with automatic synchronization
- * between storage and crudify library. It maintains 100% compatibility with
- * the existing crudia-ui storage patterns while providing enhanced functionality.
- *
- * Key features:
- * - Automatic storage <-> crudify synchronization
- * - Token validation and expiration checking
- * - Migration support from plain localStorage to encrypted localStorage
- * - Backward compatibility with existing token storage keys
- * - Automatic cleanup of expired tokens
- */
-declare class TokenManager {
-    private static instance;
-    private readonly TOKEN_KEY;
-    private tokenCache;
-    private parsedTokenCache;
-    private expirationCheckInterval;
-    private storageEventListener;
-    /**
-     * Singleton pattern to ensure consistent token management
-     */
-    static getInstance(): TokenManager;
-    /**
-     * Reset the singleton instance (useful for testing)
-     */
-    static resetInstance(): void;
-    private constructor();
-    /**
-     * Initialize the token manager with storage synchronization
-     */
-    private initializeTokenManager;
-    /**
-     * Migrate tokens from plain localStorage to encrypted localStorage
-     * This ensures compatibility with older implementations
-     */
-    private migrateFromLocalStorage;
-    /**
-     * Load token from storage and synchronize with crudify
-     */
-    private loadTokenFromStorage;
-    /**
-     * Set up automatic token expiration checking
-     */
-    private setupExpirationCheck;
-    /**
-     * Set up storage event listener for cross-tab synchronization
-     */
-    private setupStorageListener;
-    /**
-     * Set a new JWT token with automatic synchronization
-     */
-    setToken(token: string | null): void;
-    /**
-     * Get the current JWT token
-     */
-    getToken(): string | null;
-    /**
-     * Parse the current JWT token
-     */
-    parseToken(token?: string | null): JWTPayload$1 | null;
-    /**
-     * Check if a token is valid (properly formatted and not expired)
-     */
-    isTokenValid(token?: string | null): boolean;
-    /**
-     * Get token expiration time as Date object
-     */
-    getTokenExpiration(): Date | null;
-    /**
-     * Clear the current token from all storages and crudify
-     */
-    clearToken(): void;
-    /**
-     * Synchronize token with crudify library
-     */
-    private syncTokenWithCrudify;
-    /**
-     * Refresh token (placeholder for future implementation)
-     */
-    refreshToken(): Promise<void>;
-    /**
-     * Get user information from the current token
-     */
-    getUserInfo(): {
-        email: string | null;
-        userId: string | null;
-        userIdentifier: string | null;
-        username: string | null;
-    };
-    /**
-     * Check if user is currently authenticated
-     */
-    isAuthenticated(): boolean;
-    /**
-     * Get time until token expires in minutes
-     */
-    getTimeUntilExpiration(): number | null;
-    /**
-     * Cleanup resources (call when the component unmounts)
-     */
-    cleanup(): void;
-    /**
-     * Get debug information about the current token state
-     */
-    getDebugInfo(): {
-        hasToken: boolean;
-        tokenLength: number;
-        isValid: boolean;
-        isAuthenticated: boolean;
-        expiration: string | null;
-        minutesUntilExpiry: number | null;
-        userInfo: {
-            email: string | null;
-            userId: string | null;
-            userIdentifier: string | null;
-            username: string | null;
-        };
-        parsedTokenKeys: string[];
-    };
-}
-/**
- * Singleton instance for easy access
- */
-declare const tokenManager: TokenManager;
-
-/**
- * Context state interface for CrudifyDataProvider
- */
-interface CrudifyDataContextState {
-    config: ResolvedConfig | null;
-    isConfigured: boolean;
-    configError: string | null;
-    configSource: string;
-    isInitialized: boolean;
-    isInitializing: boolean;
-    initializationError: string | null;
-    isAuthenticated: boolean;
-    token: string | null;
-    user: JWTPayload$1 | null;
-    tokenExpiration: Date | null;
-    setToken: (token: string | null) => void;
-    logout: () => void;
-    refreshConfig: () => void;
-    reinitialize: () => Promise<void>;
-    getDebugInfo: () => Record<string, any>;
-}
-/**
- * Props for CrudifyDataProvider
- */
-interface CrudifyDataProviderProps {
-    children: ReactNode;
-    env?: "dev" | "stg" | "prod";
-    publicApiKey?: string;
-    loginActions?: string[];
-    appName?: string;
-    logo?: string;
-    colors?: Record<string, string>;
-}
-/**
- * CrudifyDataProvider - The unified provider that encapsulates all crudify functionality
- *
- * This provider replaces the fragmented implementations in both crudia-ui and crudify-ui
- * with a single, robust solution that handles:
- *
- * 1. Configuration management (props > env vars > cookies)
- * 2. Crudify initialization (single, thread-safe initialization)
- * 3. JWT token management (compatible with existing storage patterns)
- * 4. Error handling and recovery
- * 5. Cross-tab synchronization
- *
- * It maintains 100% backward compatibility with crudia-ui while providing
- * enhanced functionality for crudify-ui.
- */
-declare const CrudifyDataProvider: React.FC<CrudifyDataProviderProps>;
-/**
- * Hook para usar el contexto de CrudifyDataProvider
- */
-declare const useCrudifyDataContext: () => CrudifyDataContextState;
-
-/**
- * Return type for useCrudifyAuth hook
- */
-interface UseCrudifyAuthReturn {
-    isAuthenticated: boolean;
-    loading: boolean;
-    error: string | null;
-    token: string | null;
-    user: JWTPayload$1 | null;
-    tokenExpiration: Date | null;
-    setToken: (token: string | null) => void;
-    logout: () => void;
-    refreshToken?: () => Promise<void>;
-}
-/**
- * useCrudifyAuth - Simplified hook for authentication state management
- *
- * This hook provides a clean interface for managing authentication state
- * within the CrudifyDataProvider system. It abstracts away the complexity
- * of token management, storage synchronization, and crudify integration.
- *
- * Features:
- * - Real-time authentication status
- * - Automatic token validation
- * - Cross-tab synchronization
- * - Simple login/logout actions
- * - JWT payload access
- *
- * @example
- * ```tsx
- * function LoginComponent() {
- *   const { isAuthenticated, login, logout, user } = useCrudifyAuth();
- *
- *   if (isAuthenticated) {
- *     return (
- *       <div>
- *         Welcome {user?.email}!
- *         <button onClick={logout}>Logout</button>
- *       </div>
- *     );
- *   }
- *
- *   return <LoginForm onLogin={login} />;
- * }
- * ```
- */
-declare const useCrudifyAuth: () => UseCrudifyAuthReturn;
-
-/**
- * Complete user data structure
- */
-interface CrudifyUserData {
-    session: JWTPayload$1 | null;
-    data: UserProfile | null;
-}
-/**
- * Return type for useCrudifyUser hook
- */
-interface UseCrudifyUserReturn {
-    user: CrudifyUserData;
-    loading: boolean;
-    error: string | null;
-    refreshProfile: () => Promise<void>;
-    clearProfile: () => void;
-}
-/**
- * Options for useCrudifyUser hook
- */
-interface UseCrudifyUserOptions {
-    autoFetch?: boolean;
-    retryOnError?: boolean;
-    maxRetries?: number;
-}
-/**
- * useCrudifyUser - Comprehensive user data management hook
- *
- * This hook provides complete user data management by combining:
- * 1. JWT token data (basic user information)
- * 2. Database profile data (complete user profile)
- * 3. Extended formatted data for display
- *
- * It automatically fetches user profile data from the database when
- * the user is authenticated and provides intelligent caching,
- * error handling, and retry mechanisms.
- *
- * Features:
- * - Automatic profile fetching when authenticated
- * - Intelligent caching and deduplication
- * - Retry mechanism for network errors
- * - Cross-tab synchronization
- * - Extended data formatting for easy display
- * - Proper cleanup and memory management
- *
- * @example
- * ```tsx
- * function UserProfilePage() {
- *   const {
- *     user,
- *     loading,
- *     error,
- *     refreshProfile
- *   } = useCrudifyUser({ autoFetch: true });
- *
- *   if (loading) return <LoadingSpinner />;
- *   if (error) return <div>Error: {error}</div>;
- *
- *   return (
- *     <div>
- *       <h1>Welcome {user.data?.fullName || user.session?.email}</h1>
- *       <p>Session data: {JSON.stringify(user.session, null, 2)}</p>
- *       <p>Profile data: {JSON.stringify(user.data, null, 2)}</p>
- *       <button onClick={refreshProfile}>Refresh</button>
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useCrudifyUser: (options?: UseCrudifyUserOptions) => UseCrudifyUserReturn;
-
-/**
- * Return type for useCrudifyData hook
- */
-interface UseCrudifyDataReturn {
-    readItems: (moduleKey: string, filter?: object, options?: any) => Promise<CrudifyApiResponse>;
-    readItem: (moduleKey: string, filter: object, options?: any) => Promise<CrudifyApiResponse>;
-    createItem: (moduleKey: string, data: object, options?: any) => Promise<CrudifyApiResponse>;
-    updateItem: (moduleKey: string, data: object, options?: any) => Promise<CrudifyApiResponse>;
-    deleteItem: (moduleKey: string, id: string, options?: any) => Promise<CrudifyApiResponse>;
-    transaction: (operations: any[], options?: any) => Promise<CrudifyApiResponse>;
-    login: (email: string, password: string) => Promise<CrudifyApiResponse>;
-    isInitialized: boolean;
-    isInitializing: boolean;
-    initializationError: string | null;
-    isReady: () => boolean;
-    waitForReady: () => Promise<void>;
-}
-/**
- * useCrudifyData - Comprehensive hook for crudify operations
- *
- * This hook provides a clean interface for all crudify database operations
- * with automatic initialization checking, error handling, and loading states.
- * It ensures that all operations are only executed when crudify is properly
- * initialized and configured.
- *
- * Features:
- * - Automatic initialization checking
- * - Type-safe CRUD operations
- * - Transaction support
- * - Login operations
- * - Ready state management
- * - Proper error handling
- *
- * All operations will throw an error if crudify is not properly initialized,
- * ensuring data integrity and preventing silent failures.
- *
- * @example
- * ```tsx
- * function DataComponent() {
- *   const {
- *     readItems,
- *     createItem,
- *     isInitialized,
- *     isReady
- *   } = useCrudifyData();
- *
- *   const loadUsers = async () => {
- *     if (!isReady()) {
- *       console.warn("Crudify not ready yet");
- *       return;
- *     }
- *
- *     try {
- *       const response = await readItems("users", { limit: 10 });
- *       if (response.success) {
- *         console.log("Users:", response.data);
- *       }
- *     } catch (error) {
- *       console.error("Error loading users:", error);
- *     }
- *   };
- *
- *   return (
- *     <div>
- *       <button onClick={loadUsers} disabled={!isInitialized}>
- *         Load Users
- *       </button>
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useCrudifyData: () => UseCrudifyDataReturn;
-
-/**
- * Return type for useCrudifyConfig hook
- */
-interface UseCrudifyConfigReturn {
-    config: ResolvedConfig | null;
-    isConfigured: boolean;
-    configError: string | null;
-    configSource: string;
-    rawConfig: Record<string, any>;
-    refreshConfig: () => void;
-    getDebugInfo: () => Record<string, any>;
-}
-/**
- * useCrudifyConfig - Configuration access and debugging hook
- *
- * This hook provides access to the current crudify configuration,
- * including source tracking for debugging and configuration validation.
- * It's particularly useful for development and troubleshooting
- * configuration issues across different environments.
- *
- * Features:
- * - Current configuration access
- * - Source tracking (props, env, cookies, defaults)
- * - Configuration validation status
- * - Debug information for troubleshooting
- * - Configuration refresh capability
- *
- * @example
- * ```tsx
- * function ConfigDebugComponent() {
- *   const {
- *     config,
- *     isConfigured,
- *     configError,
- *     configSource,
- *     getDebugInfo
- *   } = useCrudifyConfig();
- *
- *   if (!isConfigured) {
- *     return (
- *       <div>
- *         <h3>Configuration Error</h3>
- *         <p>{configError}</p>
- *       </div>
- *     );
- *   }
- *
- *   return (
- *     <div>
- *       <h3>Current Configuration</h3>
- *       <p>Environment: {config?.env}</p>
- *       <p>App Name: {config?.appName}</p>
- *       <p>Source: {configSource}</p>
- *       <pre>{JSON.stringify(getDebugInfo(), null, 2)}</pre>
- *     </div>
- *   );
- * }
- * ```
- */
-declare const useCrudifyConfig: () => UseCrudifyConfigReturn;
-
-/**
- * Return type for useCrudifyInstance hook
- */
-interface UseCrudifyInstanceReturn {
-    getStructure: (options?: any) => Promise<CrudifyApiResponse>;
-    getStructurePublic: (options?: any) => Promise<CrudifyApiResponse>;
-    readItems: (moduleKey: string, filter?: object, options?: any) => Promise<CrudifyApiResponse>;
-    readItem: (moduleKey: string, filter: object, options?: any) => Promise<CrudifyApiResponse>;
-    createItem: (moduleKey: string, data: object, options?: any) => Promise<CrudifyApiResponse>;
-    updateItem: (moduleKey: string, data: object, options?: any) => Promise<CrudifyApiResponse>;
-    deleteItem: (moduleKey: string, id: string, options?: any) => Promise<CrudifyApiResponse>;
-    transaction: (operations: any[], options?: any) => Promise<CrudifyApiResponse>;
-    login: (email: string, password: string) => Promise<CrudifyApiResponse>;
-    isReady: boolean;
-    isInitialized: boolean;
-    isInitializing: boolean;
-    initializationError: string | null;
-    waitForReady: () => Promise<void>;
-}
-/**
- * useCrudifyInstance - Hook that provides access to the initialized crudify instance
- *
- * This hook ensures that all parts of the application use the same, properly initialized
- * instance of crudify. It waits for initialization to complete and provides methods
- * that are guaranteed to work with the initialized instance.
- *
- * Key benefits:
- * - Single source of truth for crudify instance
- * - Automatic waiting for initialization
- * - Consistent error handling
- * - Type-safe operations
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { getStructure, isReady } = useCrudifyInstance();
- *
- *   const loadStructure = async () => {
- *     if (!isReady) {
- *       console.warn("Crudify not ready yet");
- *       return;
- *     }
- *
- *     try {
- *       const response = await getStructure();
- *       if (response.success) {
- *         console.log("Structure:", response.data);
- *       }
- *     } catch (error) {
- *       console.error("Error loading structure:", error);
- *     }
- *   };
- *
- *   return (
- *     <button onClick={loadStructure} disabled={!isReady}>
- *       Load Structure
- *     </button>
- *   );
- * }
- * ```
- */
-declare const useCrudifyInstance: () => UseCrudifyInstanceReturn;
-/**
- * Get the initialized crudify instance directly (for use outside React components)
- * This function waits for initialization to complete before returning the instance
- */
-declare const getCrudifyInstanceAsync: () => Promise<typeof crudify__default>;
-/**
- * Get crudify instance with manual ready check (for use outside React components)
- * Throws error if not ready - use getCrudifyInstanceAsync for automatic waiting
- */
-declare const getCrudifyInstanceSync: () => Promise<typeof crudify__default>;
-
-interface UseUserProfileOptions {
-    autoFetch?: boolean;
-    retryOnError?: boolean;
-    maxRetries?: number;
-}
-interface UseUserProfileReturn {
-    userProfile: UserProfile | null;
-    loading: boolean;
-    error: string | null;
-    extendedData: Record<string, any>;
-    refreshProfile: () => Promise<void>;
-    clearProfile: () => void;
-}
-declare const useUserProfile: (options?: UseUserProfileOptions) => UseUserProfileReturn;
-
-interface UseCrudifyLoginOptions {
-    showErrorNotifications?: boolean;
-    showSuccessNotifications?: boolean;
-}
-declare const useCrudifyLogin: (config: CrudifyLoginConfig, _options?: UseCrudifyLoginOptions) => {
-    config: {
-        publicApiKey: string | null;
-        env: "dev" | "stg" | "prod";
-        appName: string;
-        loginActions: string[];
-    };
-};
-
-interface JWTPayload extends JwtPayload {
-    "cognito:username"?: string;
-}
-declare const decodeJwtSafely: (token: string) => JWTPayload | null;
-declare const getCurrentUserEmail: () => string | null;
-declare const isTokenExpired: (token: string) => boolean;
-
-declare const getCookie: (name: string) => string | null;
-
-declare class SecureStorage {
-    private readonly encryptionKey;
-    private readonly storage;
-    constructor(storageType?: "localStorage" | "sessionStorage");
-    private generateEncryptionKey;
-    setItem(key: string, value: string, expiryMinutes?: number): void;
-    getItem(key: string): string | null;
-    removeItem(key: string): void;
-    setToken(token: string): void;
-    getToken(): string | null;
-}
-declare const secureSessionStorage: SecureStorage;
-declare const secureLocalStorage: SecureStorage;
-
-declare const ERROR_CODES: {
-    readonly INVALID_CREDENTIALS: "INVALID_CREDENTIALS";
-    readonly UNAUTHORIZED: "UNAUTHORIZED";
-    readonly INVALID_API_KEY: "INVALID_API_KEY";
-    readonly USER_NOT_FOUND: "USER_NOT_FOUND";
-    readonly USER_NOT_ACTIVE: "USER_NOT_ACTIVE";
-    readonly NO_PERMISSION: "NO_PERMISSION";
-    readonly ITEM_NOT_FOUND: "ITEM_NOT_FOUND";
-    readonly NOT_FOUND: "NOT_FOUND";
-    readonly IN_USE: "IN_USE";
-    readonly FIELD_ERROR: "FIELD_ERROR";
-    readonly BAD_REQUEST: "BAD_REQUEST";
-    readonly INVALID_EMAIL: "INVALID_EMAIL";
-    readonly INVALID_CODE: "INVALID_CODE";
-    readonly INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR";
-    readonly DATABASE_CONNECTION_ERROR: "DATABASE_CONNECTION_ERROR";
-    readonly INVALID_CONFIGURATION: "INVALID_CONFIGURATION";
-    readonly UNKNOWN_OPERATION: "UNKNOWN_OPERATION";
-    readonly TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS";
-    readonly NETWORK_ERROR: "NETWORK_ERROR";
-    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
-};
-type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
-type ErrorSeverity = "info" | "warning" | "error" | "critical";
-declare const ERROR_SEVERITY_MAP: Record<ErrorCode, ErrorSeverity>;
-interface ParsedError {
-    code: ErrorCode;
-    message: string;
-    severity: ErrorSeverity;
-    field?: string;
-    details?: Record<string, unknown>;
-}
-/**
- * Parse a Crudify API response and extract standardized error information
- */
-declare function parseApiError(response: unknown): ParsedError[];
-/**
- * Parse transaction response errors
- */
-declare function parseTransactionError(response: unknown): ParsedError[];
-/**
- * Get a human-readable error message for an error code
- */
-declare function getErrorMessage(code: ErrorCode): string;
-/**
- * Handle JavaScript/Network errors and convert to ParsedError
- */
-declare function parseJavaScriptError(error: unknown): ParsedError;
-/**
- * Universal error handler that can process any type of error from Crudify APIs
- */
-declare function handleCrudifyError(error: unknown): ParsedError[];
-
 type TokenData = {
     accessToken: string;
     refreshToken: string;
@@ -1356,4 +569,95 @@ interface UseDataReturn {
  */
 declare const useData: () => UseDataReturn;
 
-export { type ApiError, type BoxScreenType, type CrudifyApiResponse, type CrudifyConfig, type CrudifyDataContextState, CrudifyDataProvider, type CrudifyDataProviderProps, CrudifyLogin, type CrudifyLoginConfig, type CrudifyLoginProps, type CrudifyLoginTranslations, type CrudifyTransactionResponse, type CrudifyUserData, ERROR_CODES, ERROR_SEVERITY_MAP, type ErrorCode, type ErrorSeverity, type ForgotPasswordRequest, type JWTPayload$1 as JWTPayload, type JwtPayload, LoginComponent, type LoginRequest, type LoginResponse, type LoginResult, POLICY_ACTIONS, PREFERRED_POLICY_ORDER, type ParsedError, Policies, type PolicyAction, ProtectedRoute, type ProtectedRouteProps, type ResetPasswordRequest, type ResolvedConfig, type SessionConfig, SessionDebugInfo, SessionManager, SessionProvider, type SessionProviderProps, type SessionState, SessionStatus, type StorageType, type TokenData, TokenStorage, type TransactionResponseData, type UseAuthReturn, type UseCrudifyAuthReturn, type UseCrudifyConfigReturn, type UseCrudifyDataReturn, type UseCrudifyInstanceReturn, type UseCrudifyUserOptions, type UseCrudifyUserReturn, type UseDataReturn, type UseSessionOptions, type UseUserDataOptions, type UseUserDataReturn, type UserData, type UserLoginData, type UserProfile, UserProfileDisplay, type ValidateCodeRequest, type ValidationError, configurationManager, crudifyInitializer, decodeJwtSafely, getCookie, getCrudifyInstanceAsync, getCrudifyInstanceSync, getCurrentUserEmail, getErrorMessage, handleCrudifyError, isTokenExpired, parseApiError, parseJavaScriptError, parseTransactionError, secureLocalStorage, secureSessionStorage, tokenManager, useAuth, useCrudifyAuth, useCrudifyConfig, useCrudifyData, useCrudifyDataContext, useCrudifyInstance, useCrudifyLogin, useCrudifyUser, useData, useSession, useSessionContext, useUserData, useUserProfile };
+interface UseUserProfileOptions {
+    autoFetch?: boolean;
+    retryOnError?: boolean;
+    maxRetries?: number;
+}
+interface UseUserProfileReturn {
+    userProfile: UserProfile | null;
+    loading: boolean;
+    error: string | null;
+    extendedData: Record<string, any>;
+    refreshProfile: () => Promise<void>;
+    clearProfile: () => void;
+}
+declare const useUserProfile: (options?: UseUserProfileOptions) => UseUserProfileReturn;
+
+interface JWTPayload extends JwtPayload {
+    "cognito:username"?: string;
+}
+declare const decodeJwtSafely: (token: string) => JWTPayload | null;
+declare const getCurrentUserEmail: () => string | null;
+declare const isTokenExpired: (token: string) => boolean;
+
+declare const getCookie: (name: string) => string | null;
+
+declare class SecureStorage {
+    private readonly encryptionKey;
+    private readonly storage;
+    constructor(storageType?: "localStorage" | "sessionStorage");
+    private generateEncryptionKey;
+    setItem(key: string, value: string, expiryMinutes?: number): void;
+    getItem(key: string): string | null;
+    removeItem(key: string): void;
+    setToken(token: string): void;
+    getToken(): string | null;
+}
+declare const secureSessionStorage: SecureStorage;
+declare const secureLocalStorage: SecureStorage;
+
+declare const ERROR_CODES: {
+    readonly INVALID_CREDENTIALS: "INVALID_CREDENTIALS";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly INVALID_API_KEY: "INVALID_API_KEY";
+    readonly USER_NOT_FOUND: "USER_NOT_FOUND";
+    readonly USER_NOT_ACTIVE: "USER_NOT_ACTIVE";
+    readonly NO_PERMISSION: "NO_PERMISSION";
+    readonly ITEM_NOT_FOUND: "ITEM_NOT_FOUND";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly IN_USE: "IN_USE";
+    readonly FIELD_ERROR: "FIELD_ERROR";
+    readonly BAD_REQUEST: "BAD_REQUEST";
+    readonly INVALID_EMAIL: "INVALID_EMAIL";
+    readonly INVALID_CODE: "INVALID_CODE";
+    readonly INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR";
+    readonly DATABASE_CONNECTION_ERROR: "DATABASE_CONNECTION_ERROR";
+    readonly INVALID_CONFIGURATION: "INVALID_CONFIGURATION";
+    readonly UNKNOWN_OPERATION: "UNKNOWN_OPERATION";
+    readonly TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
+};
+type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+type ErrorSeverity = "info" | "warning" | "error" | "critical";
+declare const ERROR_SEVERITY_MAP: Record<ErrorCode, ErrorSeverity>;
+interface ParsedError {
+    code: ErrorCode;
+    message: string;
+    severity: ErrorSeverity;
+    field?: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * Parse a Crudify API response and extract standardized error information
+ */
+declare function parseApiError(response: unknown): ParsedError[];
+/**
+ * Parse transaction response errors
+ */
+declare function parseTransactionError(response: unknown): ParsedError[];
+/**
+ * Get a human-readable error message for an error code
+ */
+declare function getErrorMessage(code: ErrorCode): string;
+/**
+ * Handle JavaScript/Network errors and convert to ParsedError
+ */
+declare function parseJavaScriptError(error: unknown): ParsedError;
+/**
+ * Universal error handler that can process any type of error from Crudify APIs
+ */
+declare function handleCrudifyError(error: unknown): ParsedError[];
+
+export { type ApiError, type BoxScreenType, type CrudifyApiResponse, CrudifyLogin, type CrudifyLoginConfig, type CrudifyLoginProps, type CrudifyLoginTranslations, type CrudifyTransactionResponse, ERROR_CODES, ERROR_SEVERITY_MAP, type ErrorCode, type ErrorSeverity, type ForgotPasswordRequest, type JwtPayload, LoginComponent, type LoginRequest, type LoginResponse, type LoginResult, POLICY_ACTIONS, PREFERRED_POLICY_ORDER, type ParsedError, Policies, type PolicyAction, ProtectedRoute, type ProtectedRouteProps, type ResetPasswordRequest, type SessionConfig, SessionDebugInfo, SessionManager, SessionProvider, type SessionProviderProps, type SessionState, SessionStatus, type StorageType, type TokenData, TokenStorage, type TransactionResponseData, type UseAuthReturn, type UseDataReturn, type UseSessionOptions, type UseUserDataOptions, type UseUserDataReturn, type UserData, type UserLoginData, type UserProfile, UserProfileDisplay, type ValidateCodeRequest, type ValidationError, decodeJwtSafely, getCookie, getCurrentUserEmail, getErrorMessage, handleCrudifyError, isTokenExpired, parseApiError, parseJavaScriptError, parseTransactionError, secureLocalStorage, secureSessionStorage, useAuth, useData, useSession, useSessionContext, useUserData, useUserProfile };