@nocios/crudify-components 1.0.0

package/dist/index-BUKX3duW.d.ts

@@ -0,0 +1,854 @@
+import { U as UserProfile, e as CrudifyRequestOptions, C as CrudifyApiResponse, g as TransactionInput, d as CrudifyOperationOptions } from './api-B4uXiHF0.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { b as NotificationSeverity } from './GlobalNotificationProvider-Zq18OkpI.js';
+import { CrudifyResponse } from '@nocios/crudify-sdk';
+
+type TokenData = {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    refreshExpiresAt: number;
+    apiEndpointAdmin?: string;
+    apiKeyEndpointAdmin?: string;
+};
+type StorageType = "localStorage" | "sessionStorage" | "none";
+declare class TokenStorage {
+    private static readonly TOKEN_KEY;
+    private static readonly ENCRYPTION_KEY_STORAGE;
+    private static readonly SALT_KEY;
+    private static encryptionKey;
+    private static salt;
+    private static fingerprint;
+    private static storageType;
+    private static initPromise;
+    private static lastSuccessfulLoginTime;
+    private static readonly LOGIN_GRACE_PERIOD_MS;
+    /**
+     * Configurar tipo de almacenamiento
+     */
+    static setStorageType(type: StorageType): void;
+    /**
+     * Initialize encryption key (async)
+     * Must be called before encrypt/decrypt operations
+     *
+     * Incluye lógica de retry para manejar casos donde localStorage
+     * puede no estar disponible momentáneamente (ej: durante hydration)
+     */
+    private static initialize;
+    /**
+     * Check storage version and clear if outdated (migration)
+     */
+    private static checkStorageVersion;
+    /**
+     * Get or create salt for key derivation
+     */
+    private static getOrCreateSalt;
+    /**
+     * Generate browser fingerprint for encryption key derivation
+     * IMPORTANTE: Esta función genera un fingerprint DETERMINÍSTICO basado en
+     * características estables del navegador. NO usa valores aleatorios para
+     * garantizar que los tokens puedan desencriptarse después de un page reload.
+     *
+     * Flujo:
+     * 1. Si existe un hash guardado en localStorage, lo usa (consistencia)
+     * 2. Si no existe, genera uno basado SOLO en características estables del navegador
+     * 3. Guarda el hash para futuras sesiones
+     */
+    private static generateFingerprint;
+    /**
+     * Verificar si el storage está disponible
+     */
+    private static isStorageAvailable;
+    /**
+     * Obtener instancia de storage
+     */
+    private static getStorage;
+    /**
+     * Encrypt data (async)
+     */
+    private static encryptData;
+    /**
+     * Decrypt data (async)
+     */
+    private static decryptData;
+    /**
+     * Guardar tokens de forma segura (async)
+     */
+    static saveTokens(tokens: TokenData): Promise<void>;
+    /**
+     * Obtener tokens guardados (async)
+     */
+    static getTokens(): Promise<TokenData | null>;
+    /**
+     * Limpiar tokens almacenados (async for consistency)
+     */
+    static clearTokens(): Promise<void>;
+    /**
+     * Rotar clave de encriptación (limpia tokens existentes por seguridad)
+     */
+    static rotateEncryptionKey(): Promise<void>;
+    /**
+     * Verificar si hay tokens válidos guardados (async)
+     */
+    static hasValidTokens(): Promise<boolean>;
+    /**
+     * Asegura que TokenStorage esté inicializado
+     * Útil para cross-tab sync donde necesitamos esperar
+     * a que la clave de encriptación esté lista antes de leer tokens
+     */
+    static ensureInitialized(): Promise<void>;
+    /**
+     * Obtener información de expiración (async)
+     */
+    static getExpirationInfo(): Promise<{
+        accessExpired: boolean;
+        refreshExpired: boolean;
+        accessExpiresIn: number;
+        refreshExpiresIn: number;
+    } | null>;
+    /**
+     * Actualizar solo el access token (después de refresh) - async
+     */
+    static updateAccessToken(newAccessToken: string, newExpiresAt: number): Promise<void>;
+    /**
+     * Event types for cross-tab synchronization
+     */
+    static readonly SYNC_EVENTS: {
+        readonly TOKENS_CLEARED: "TOKENS_CLEARED";
+        readonly TOKENS_UPDATED: "TOKENS_UPDATED";
+    };
+    /**
+     * Cross-tab sync event details
+     */
+    static createSyncEvent(type: (typeof TokenStorage.SYNC_EVENTS)[keyof typeof TokenStorage.SYNC_EVENTS], tokens: TokenData | null, hadPreviousTokens: boolean): {
+        type: "TOKENS_CLEARED" | "TOKENS_UPDATED";
+        tokens: TokenData | null;
+        hadPreviousTokens: boolean;
+    };
+    /**
+     * Suscribirse a cambios de tokens entre tabs
+     * Permite sincronizar logout/login entre múltiples tabs/ventanas
+     *
+     * Note: This remains sync as it's event-based, but the callback receives
+     * tokens that are already decrypted asynchronously
+     */
+    /**
+     * Flag interno para ignorar eventos de storage generados por esta pestaña
+     * Se usa para prevenir que cambios locales disparen callbacks de cross-tab sync
+     */
+    private static ignoreNextStorageEvent;
+    private static ignoreStorageEventTimeout;
+    /**
+     * Marca que el próximo evento de storage debe ser ignorado
+     * Útil cuando hacemos cambios locales que no queremos sincronizar como cross-tab
+     */
+    static markLocalChange(): void;
+    /**
+     * Marca que se acaba de hacer un login exitoso
+     * Inicia el grace period durante el cual se ignoran eventos TOKENS_CLEARED
+     */
+    static markSuccessfulLogin(): void;
+    /**
+     * Verifica si estamos dentro del grace period del login
+     * @returns true si el login exitoso fue hace menos de LOGIN_GRACE_PERIOD_MS
+     */
+    static isWithinLoginGracePeriod(): boolean;
+    static subscribeToChanges(callback: (tokens: TokenData | null, eventType: (typeof TokenStorage.SYNC_EVENTS)[keyof typeof TokenStorage.SYNC_EVENTS], hadPreviousTokens: boolean) => void): () => void;
+}
+
+type SessionConfig = {
+    storageType?: StorageType;
+    autoRestore?: boolean;
+    enableLogging?: boolean;
+    onSessionExpired?: () => void;
+    onSessionRestored?: (tokens: TokenData) => void;
+    onLoginSuccess?: (tokens: TokenData) => void;
+    onLogout?: () => void;
+    showNotification?: (message: string, severity?: "error" | "info" | "success" | "warning") => void;
+    translateFn?: (key: string) => string;
+    apiEndpointAdmin?: string;
+    apiKeyEndpointAdmin?: string;
+    publicApiKey?: string;
+    env?: "dev" | "stg" | "api" | "prod";
+};
+/**
+ * Response data from a successful login
+ */
+interface LoginResponseData {
+    token: string;
+    refreshToken: string;
+    expiresAt: number;
+    refreshExpiresAt: number;
+    [key: string]: unknown;
+}
+type LoginResult = {
+    success: boolean;
+    tokens?: TokenData;
+    data?: LoginResponseData;
+    error?: string;
+    rawResponse?: Record<string, unknown>;
+};
+declare class SessionManager {
+    private static instance;
+    private config;
+    private initialized;
+    private crudifyInitialized;
+    private lastActivityTime;
+    private isRefreshingLocally;
+    private refreshPromise;
+    private constructor();
+    static getInstance(): SessionManager;
+    /**
+     * Initialize SessionManager with configuration
+     */
+    initialize(config?: SessionConfig): Promise<void>;
+    /**
+     * Login with automatic token persistence
+     */
+    login(email: string, password: string): Promise<LoginResult>;
+    /**
+     * Logout con limpieza de tokens
+     */
+    logout(): Promise<void>;
+    /**
+     * ✅ MEJORADO: Restaurar sesión desde storage con validación robusta
+     */
+    restoreSession(): Promise<boolean>;
+    /**
+     * Verificar si el usuario está autenticado
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Obtener información de tokens actuales
+     */
+    getTokenInfo(): Promise<{
+        isLoggedIn: boolean;
+        crudifyTokens: {
+            accessToken: string;
+            refreshToken: string;
+            expiresAt: number;
+            refreshExpiresAt: number;
+            isExpired: boolean;
+            isRefreshExpired: boolean;
+            isValid: boolean;
+            expiresIn: number;
+            willExpireSoon: boolean;
+        };
+        storageInfo: {
+            accessExpired: boolean;
+            refreshExpired: boolean;
+            accessExpiresIn: number;
+            refreshExpiresIn: number;
+        } | null;
+        hasValidTokens: boolean;
+        apiEndpointAdmin: string | undefined;
+        apiKeyEndpointAdmin: string | undefined;
+    }>;
+    /**
+     * ✅ FASE 4: Refrescar tokens con protección contra concurrencia
+     */
+    refreshTokens(): Promise<boolean>;
+    /**
+     * ✅ FASE 4: Método privado que realiza el refresh real
+     */
+    private _performRefresh;
+    /**
+     * ✅ FASE 4: Verificar si hay un refresh en progreso
+     */
+    isRefreshing(): boolean;
+    /**
+     * ✅ MEJORADO FASE 3: Configurar interceptor de respuesta NON-BLOCKING
+     * El interceptor NO debe hacer await, solo detectar y emitir eventos
+     */
+    setupResponseInterceptor(): void;
+    /**
+     * Ensure crudify SDK is initialized
+     * Thread-safe: multiple calls will wait for the same initialization
+     */
+    private ensureCrudifyInitialized;
+    /**
+     * ✅ FASE 3.1: Detectar errores de autorización en todos los formatos posibles (mejorado)
+     *
+     * JUSTIFICACIÓN PARA `any`:
+     * El backend retorna respuestas en 5 formatos incompatibles:
+     * 1. GraphQL Array: { errors: [{ errorType?, message?, extensions.code? }] }
+     * 2. GraphQL Object: { errors: { fieldName: [messages] } }
+     * 3. REST Status: { data: { response: { status } } }
+     * 4. Parsed JSON: { data: { response: { data: JSON string } } }
+     * 5. Error Code: { errorCode: "CODE" }
+     *
+     * @param response - API response with dynamic structure that varies by error format
+     */
+    private detectAuthorizationError;
+    /**
+     * ✅ FASE 2: Actualizar timestamp de última actividad del usuario
+     * Debe llamarse cuando el usuario realiza cualquier acción (CRUD, navegación, etc.)
+     */
+    updateLastActivity(): void;
+    /**
+     * ✅ FASE 2: Obtener tiempo transcurrido desde última actividad (en milisegundos)
+     */
+    getTimeSinceLastActivity(): number;
+    /**
+     * ✅ MEJORADO FASE 3: Verificar inactividad simplificada
+     * Solo verifica timeout de inactividad absoluta
+     * La renovación de tokens se maneja en useSession con lógica de TTL
+     * @returns 'logout' si debe desloguear por inactividad, 'none' si no hace nada
+     */
+    checkInactivity(): "logout" | "none";
+    /**
+     * Limpiar sesión completamente
+     */
+    clearSession(): Promise<void>;
+    /**
+     * Obtener mensaje de sesión expirada traducido
+     */
+    private getSessionExpiredMessage;
+    private log;
+    private formatError;
+}
+
+/**
+ * Tipos e interfaces para el hook useSession
+ */
+
+/**
+ * Estado del hook useSession
+ */
+type SessionState = {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    isLoggingOut: boolean;
+    isInitialized: boolean;
+    tokens: TokenData | null;
+    error: string | null;
+};
+/**
+ * Opciones de configuración para useSession
+ */
+type UseSessionOptions = {
+    autoRestore?: boolean;
+    enableLogging?: boolean;
+    onSessionExpired?: () => void;
+    onSessionRestored?: (tokens: TokenData) => void;
+    showNotification?: (message: string, severity?: "error" | "info" | "success" | "warning") => void;
+    translateFn?: (key: string) => string;
+    apiEndpointAdmin?: string;
+    apiKeyEndpointAdmin?: string;
+    publicApiKey?: string;
+    env?: "dev" | "stg" | "api" | "prod";
+};
+/**
+ * Retorno completo del hook useSession
+ */
+type UseSessionReturn = SessionState & {
+    login: (email: string, password: string) => Promise<LoginResult>;
+    logout: () => Promise<void>;
+    refreshTokens: () => Promise<boolean>;
+    clearError: () => void;
+    getTokenInfo: () => Promise<TokenInfoResult>;
+    updateActivity: () => void;
+    isExpiringSoon: boolean;
+    expiresIn: number;
+    refreshExpiresIn: number;
+};
+/**
+ * Resultado de getTokenInfo
+ */
+type TokenInfoResult = {
+    crudifyTokens: {
+        accessToken: string | null;
+        refreshToken: string | null;
+        expiresAt: number;
+        refreshExpiresAt: number;
+        expiresIn: number;
+    };
+};
+
+/**
+ * Hook de React para manejo de sesiones con Refresh Token Pattern
+ * Proporciona una API simple para manejar autenticación en componentes React
+ *
+ * @param options - Opciones de configuración del hook
+ * @returns Estado de sesión y funciones de control
+ *
+ * @example
+ * ```tsx
+ * const { isAuthenticated, login, logout } = useSession({
+ *   onSessionExpired: () => navigate('/login')
+ * });
+ * ```
+ */
+declare function useSession(options?: UseSessionOptions): UseSessionReturn;
+
+type SessionData = {
+    _id: string;
+    email: string;
+    subscriberKey: string;
+    [key: string]: unknown;
+} | null;
+type CrudifyConfig = {
+    publicApiKey?: string;
+    env?: "dev" | "stg" | "api" | "prod";
+    appName?: string;
+    loginActions?: string[];
+    logo?: string;
+};
+type SessionContextType = {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    isLoggingOut: boolean;
+    isInitialized: boolean;
+    tokens: TokenData | null;
+    error: string | null;
+    sessionData: SessionData;
+    config: CrudifyConfig;
+    login: (email: string, password: string) => Promise<LoginResult>;
+    logout: () => Promise<void>;
+    refreshTokens: () => Promise<boolean>;
+    clearError: () => void;
+    getTokenInfo: () => ReturnType<typeof useSession>["getTokenInfo"] extends () => infer R ? R : unknown;
+    isExpiringSoon: boolean;
+    expiresIn: number;
+    refreshExpiresIn: number;
+};
+type NotificationOptions = {
+    enabled?: boolean;
+    maxNotifications?: number;
+    defaultAutoHideDuration?: number;
+    position?: {
+        vertical: "top" | "bottom";
+        horizontal: "left" | "center" | "right";
+    };
+    allowHtml?: boolean;
+};
+type SessionProviderProps = {
+    children: ReactNode;
+    options?: UseSessionOptions;
+    config?: CrudifyConfig;
+    showNotifications?: boolean;
+    notificationOptions?: NotificationOptions;
+};
+/**
+ * Main session provider to wrap the application.
+ * Auto-initializes internal CrudifyProvider if config.publicApiKey is provided.
+ */
+declare function SessionProvider(props: SessionProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook para usar el contexto de sesión
+ */
+declare function useSessionContext(): SessionContextType;
+/**
+ * Componente para mostrar información de la sesión (debug)
+ */
+declare function SessionDebugInfo(): react_jsx_runtime.JSX.Element;
+
+/**
+ * Complete user data structure (compatible con legacy)
+ */
+interface UserData {
+    session: Record<string, unknown> | null;
+    data: UserProfile | null;
+}
+/**
+ * Return type compatible con useCrudifyUser legacy
+ */
+interface UseUserDataReturn {
+    user: UserData;
+    loading: boolean;
+    error: string | null;
+    refreshProfile: () => Promise<void>;
+    clearProfile: () => void;
+}
+/**
+ * Options compatible con useCrudifyUser legacy
+ */
+interface UseUserDataOptions {
+    autoFetch?: boolean;
+    retryOnError?: boolean;
+    maxRetries?: number;
+}
+/**
+ * useUserData - Hook completo que reemplaza useCrudifyUser del sistema legacy
+ *
+ * Funcionalidades completas:
+ * - Auto-fetch de datos del usuario desde la base de datos
+ * - Manejo inteligente de caché y deduplicación
+ * - Mecanismo de retry para errores de red
+ * - Sincronización cross-tab vía SessionProvider
+ * - Formateo extendido de datos para display
+ * - Limpieza apropiada y gestión de memoria
+ * - Compatible 100% con API de useCrudifyUser legacy
+ * - Usa el nuevo sistema de refresh tokens por debajo
+ */
+declare const useUserData: (options?: UseUserDataOptions) => UseUserDataReturn;
+
+/**
+ * Return type compatible con useCrudifyAuth legacy
+ */
+interface UseAuthReturn {
+    isAuthenticated: boolean;
+    loading: boolean;
+    error: string | null;
+    token: string | null;
+    user: Record<string, unknown> | null;
+    tokenExpiration: Date | null;
+    setToken: (token: string | null) => void;
+    logout: () => Promise<void>;
+    refreshToken: () => Promise<boolean>;
+    login: (email: string, password: string) => Promise<LoginResult>;
+    isExpiringSoon: boolean;
+    expiresIn: number;
+    refreshExpiresIn: number;
+    getTokenInfo: () => ReturnType<SessionContextType["getTokenInfo"]>;
+    clearError: () => void;
+}
+/**
+ * useAuth - Hook de autenticación completo
+ *
+ * Este hook reemplaza completamente a useCrudifyAuth del sistema legacy
+ * manteniendo 100% compatibilidad de API pero usando el nuevo SessionProvider
+ * que incluye Refresh Token Pattern, almacenamiento seguro, y gestión automática
+ * de expiración de tokens.
+ *
+ * Funcionalidades completas:
+ * - Estado de autenticación en tiempo real
+ * - Validación automática de tokens
+ * - Sincronización cross-tab
+ * - Acciones simples login/logout
+ * - Acceso al payload JWT vía sessionData
+ * - Refresh automático de tokens
+ * - Gestión de expiración de sesiones
+ * - Almacenamiento seguro y encriptado
+ * - Compatibilidad 100% con API legacy
+ *
+ * @example
+ * ```tsx
+ * function LoginComponent() {
+ *   const { isAuthenticated, login, logout, user } = useAuth();
+ *
+ *   if (isAuthenticated) {
+ *     return (
+ *       <div>
+ *         Welcome {user?.email}!
+ *         <button onClick={logout}>Logout</button>
+ *       </div>
+ *     );
+ *   }
+ *
+ *   return <LoginForm onLogin={login} />;
+ * }
+ * ```
+ */
+declare const useAuth: () => UseAuthReturn;
+
+/**
+ * Return type compatible con useCrudifyData legacy
+ */
+interface UseDataReturn {
+    readItems: (moduleKey: string, filter?: object, options?: CrudifyRequestOptions) => Promise<CrudifyApiResponse>;
+    readItem: (moduleKey: string, filter: object, options?: CrudifyRequestOptions) => Promise<CrudifyApiResponse>;
+    createItem: (moduleKey: string, data: object, options?: CrudifyRequestOptions) => Promise<CrudifyApiResponse>;
+    updateItem: (moduleKey: string, data: object, options?: CrudifyRequestOptions) => Promise<CrudifyApiResponse>;
+    deleteItem: (moduleKey: string, id: string, options?: CrudifyRequestOptions) => Promise<CrudifyApiResponse>;
+    transaction: (operations: TransactionInput, options?: CrudifyRequestOptions) => Promise<CrudifyApiResponse>;
+    login: (email: string, password: string) => Promise<CrudifyApiResponse>;
+    isInitialized: boolean;
+    isInitializing: boolean;
+    initializationError: string | null;
+    isReady: () => boolean;
+    waitForReady: () => Promise<void>;
+}
+/**
+ * useData - Hook completo para operaciones de datos
+ *
+ * Este hook reemplaza completamente a useCrudifyData del sistema legacy
+ * manteniendo 100% compatibilidad de API pero usando el nuevo SessionProvider
+ * que proporciona mejor manejo de estados y errores.
+ *
+ * Funcionalidades completas:
+ * - Verificación automática de inicialización
+ * - Operaciones CRUD type-safe
+ * - Soporte para transacciones
+ * - Operaciones de login
+ * - Gestión de estados ready
+ * - Manejo apropiado de errores
+ * - Compatible 100% con API legacy
+ *
+ * Todas las operaciones verifican que el sistema esté inicializado correctamente,
+ * asegurando integridad de datos y previniendo fallas silenciosas.
+ *
+ * @example
+ * ```tsx
+ * function DataComponent() {
+ *   const {
+ *     readItems,
+ *     createItem,
+ *     isInitialized,
+ *     isReady
+ *   } = useData();
+ *
+ *   const loadUsers = async () => {
+ *     if (!isReady()) {
+ *       console.warn("System 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 useData: () => UseDataReturn;
+
+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;
+
+/**
+ * Complete hook for file handling with:
+ * - Progressive upload to S3 with pre-signed URLs
+ * - Per-file progress tracking
+ * - Type and size validation
+ * - Soft delete (disableFile)
+ * - Multiple file support
+ */
+/**
+ * Individual file status
+ */
+type FileStatus = "pending" | "uploading" | "completed" | "error" | "removing" | "pendingDeletion";
+/**
+ * Represents a file in the system
+ */
+interface FileItem {
+    /** Unique file ID (generated or from server) */
+    id: string;
+    /** Original file name */
+    name: string;
+    /** Size in bytes */
+    size: number;
+    /** MIME content type */
+    contentType: string;
+    /** Current file status */
+    status: FileStatus;
+    /** Upload progress (0-100) */
+    progress: number;
+    /**
+     * Relative file path (includes visibility)
+     * Format: "public/path/file.ext" or "private/path/file.ext"
+     */
+    filePath?: string;
+    /**
+     * File visibility
+     * Extracted from filePath for convenience
+     */
+    visibility?: "public" | "private";
+    /** Public URL for public files */
+    publicUrl?: string;
+    /** Preview URL (for images) */
+    previewUrl?: string;
+    /** Error message if failed */
+    errorMessage?: string;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Original file (only during upload) */
+    file?: File;
+    /** Whether this file existed before (was loaded from server) */
+    isExisting?: boolean;
+}
+/**
+ * Hook configuration
+ */
+interface UseFileUploadOptions {
+    /** Allowed MIME types (e.g., ["image/png", "image/jpeg", "application/pdf"]) */
+    acceptedTypes?: string[];
+    /** Maximum file size in bytes (default: 10MB) */
+    maxFileSize?: number;
+    /** Maximum number of files (undefined = no limit) */
+    maxFiles?: number;
+    /** Minimum number of required files (default: 0) */
+    minFiles?: number;
+    /**
+     * Visibility of uploaded files
+     * @default "private"
+     */
+    visibility?: "public" | "private";
+    /** Callback when an upload completes successfully */
+    onUploadComplete?: (file: FileItem) => void;
+    /** Callback when an upload fails */
+    onUploadError?: (file: FileItem, error: string) => void;
+    /** Callback when a file is removed */
+    onFileRemoved?: (file: FileItem) => void;
+    /** Callback when the file list changes */
+    onFilesChange?: (files: FileItem[]) => void;
+    /** Form mode: 'create' or 'edit' - affects delete behavior */
+    mode?: "create" | "edit";
+}
+/**
+ * Hook return type
+ */
+interface UseFileUploadReturn {
+    /** Current file list */
+    files: FileItem[];
+    /** Active files (excluding pendingDeletion) */
+    activeFiles: FileItem[];
+    /** Count of active files */
+    activeFileCount: number;
+    /** Whether uploads are in progress */
+    isUploading: boolean;
+    /** Number of pending uploads */
+    pendingCount: number;
+    /** Add files (triggers automatic upload) */
+    addFiles: (files: FileList | File[]) => Promise<void>;
+    /** Remove a file - returns whether confirmation is needed */
+    removeFile: (fileId: string) => Promise<{
+        needsConfirmation: boolean;
+        isExisting: boolean;
+    }>;
+    /** Delete a file immediately from server (for new files or create mode) */
+    deleteFileImmediately: (fileId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Restore a file that was marked for deletion */
+    restoreFile: (fileId: string) => boolean;
+    /** Clear all files */
+    clearFiles: () => void;
+    /** Retry upload for a failed file */
+    retryUpload: (fileId: string) => Promise<void>;
+    /** Validate if minimum requirements are met */
+    isValid: boolean;
+    /** Validation error message (i18n key) */
+    validationError: string | null;
+    /** Validation error i18n key */
+    validationErrorKey: string | null;
+    /** Validation error params for i18n interpolation */
+    validationErrorParams: Record<string, string | number>;
+    /** Wait for all uploads to complete and return completed file paths */
+    waitForUploads: () => Promise<string[]>;
+    /**
+     * Completed file paths (for saving in form)
+     * Relative paths with visibility - subscriberKey is added in backend
+     */
+    completedFilePaths: string[];
+    /** Initialize with existing files (for editing) */
+    initializeFiles: (existingFiles: Array<{
+        filePath: string;
+        name: string;
+        size?: number;
+        contentType?: string;
+    }>, baseUrl?: string) => void;
+    /** Whether the user has interacted with the field */
+    isTouched: boolean;
+    /** Mark the field as touched (to show validation errors) */
+    markAsTouched: () => void;
+    /** Whether the form has been submitted */
+    isSubmitted: boolean;
+    /** Mark the form as submitted (to show all validation errors) */
+    markAsSubmitted: () => void;
+    /**
+     * Get URL for file preview
+     * - Public: returns publicUrl directly
+     * - Private: requests signed URL from backend
+     */
+    getPreviewUrl: (fileId: string) => Promise<string | null>;
+    /** List of file IDs pending deletion */
+    pendingDeletions: string[];
+    /** Whether there are files pending deletion */
+    hasPendingDeletions: boolean;
+    /** Execute all pending deletions (call this on form submit) */
+    commitDeletions: () => Promise<{
+        success: boolean;
+        errors: string[];
+    }>;
+    /** Cancel all pending deletions and restore files */
+    restorePendingDeletions: () => void;
+}
+/**
+ * Hook for complete file handling with S3 upload
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   files,
+ *   addFiles,
+ *   removeFile,
+ *   isUploading,
+ *   isValid,
+ *   completedS3Keys
+ * } = useFileUpload({
+ *   acceptedTypes: ["image/png", "image/jpeg", "application/pdf"],
+ *   maxFileSize: 5 * 1024 * 1024, // 5MB
+ *   maxFiles: 3,
+ *   minFiles: 1
+ * });
+ *
+ * // In form submit
+ * const handleSubmit = async () => {
+ *   await waitForUploads(); // Wait for pending uploads
+ *   if (!isValid) return;
+ *
+ *   await crudify.createItem("documents", {
+ *     files: completedS3Keys
+ *   });
+ * };
+ * ```
+ */
+declare const useFileUpload: (options?: UseFileUploadOptions) => UseFileUploadReturn;
+
+/** App structure action configuration */
+interface AppStructureAction {
+    key: string;
+    moduleKey?: string;
+    [key: string]: unknown;
+}
+interface CrudifyWithNotificationsOptions {
+    showSuccessNotifications?: boolean;
+    showErrorNotifications?: boolean;
+    customErrorMessages?: Record<string, string>;
+    defaultErrorMessage?: string;
+    autoHideDuration?: number;
+    appStructure?: AppStructureAction[];
+    translateFn?: (key: string, options?: Record<string, unknown>) => string;
+}
+declare const useCrudifyWithNotifications: (options?: CrudifyWithNotificationsOptions) => {
+    createItem: (moduleKey: string, data: object, options?: CrudifyOperationOptions) => Promise<CrudifyResponse>;
+    updateItem: (moduleKey: string, data: object, options?: CrudifyOperationOptions) => Promise<CrudifyResponse>;
+    deleteItem: (moduleKey: string, id: string, options?: CrudifyOperationOptions) => Promise<CrudifyResponse>;
+    readItem: (moduleKey: string, filter: object, options?: CrudifyOperationOptions) => Promise<CrudifyResponse>;
+    readItems: (moduleKey: string, filter: object, options?: CrudifyOperationOptions) => Promise<CrudifyResponse>;
+    transaction: (data: TransactionInput, options?: CrudifyOperationOptions) => Promise<CrudifyResponse>;
+    handleResponse: (response: CrudifyResponse, successMessage?: string) => CrudifyResponse;
+    getErrorMessage: (response: CrudifyResponse) => string;
+    getErrorSeverity: (response: CrudifyResponse) => NotificationSeverity;
+    shouldShowNotification: (response: CrudifyResponse) => boolean;
+};
+
+export { type FileItem as F, type LoginResult as L, type NotificationOptions as N, SessionManager as S, TokenStorage as T, type UseSessionOptions as U, type SessionConfig as a, type TokenData as b, type StorageType as c, type SessionState as d, SessionProvider as e, useSessionContext as f, SessionDebugInfo as g, type SessionProviderProps as h, useUserData as i, type UseUserDataReturn as j, type UseUserDataOptions as k, type UserData as l, useAuth as m, type UseAuthReturn as n, useData as o, type UseDataReturn as p, useUserProfile as q, useFileUpload as r, type UseFileUploadOptions as s, type UseFileUploadReturn as t, useSession as u, type FileStatus as v, useCrudifyWithNotifications as w };