@oxyhq/services 6.9.13 → 6.9.15

package/src/ui/context/OxyContext.js

@@ -0,0 +1,522 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOxy = exports.OxyContextProvider = exports.OxyProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const core_1 = require("@oxyhq/core");
+const core_2 = require("@oxyhq/core");
+const sonner_1 = require("../../lib/sonner");
+const authStore_1 = require("../stores/authStore");
+const shallow_1 = require("zustand/react/shallow");
+const useSessionSocket_1 = require("../hooks/useSessionSocket");
+const useLanguageManagement_1 = require("../hooks/useLanguageManagement");
+const useSessionManagement_1 = require("../hooks/useSessionManagement");
+const useAuthOperations_1 = require("./hooks/useAuthOperations");
+const useDeviceManagement_1 = require("../hooks/useDeviceManagement");
+const storageHelpers_1 = require("../utils/storageHelpers");
+const errorHandlers_1 = require("../utils/errorHandlers");
+const bottomSheetManager_1 = require("../navigation/bottomSheetManager");
+const react_query_1 = require("@tanstack/react-query");
+const queryClient_1 = require("../hooks/queryClient");
+const useAvatarPicker_1 = require("../hooks/useAvatarPicker");
+const accountStore_1 = require("../stores/accountStore");
+const core_3 = require("@oxyhq/core");
+const useWebSSO_1 = require("../hooks/useWebSSO");
+const OxyContext = (0, react_1.createContext)(null);
+let cachedUseFollowHook = null;
+const loadUseFollowHook = () => {
+    if (cachedUseFollowHook) {
+        return cachedUseFollowHook;
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { useFollow } = require('../hooks/useFollow');
+        cachedUseFollowHook = useFollow;
+        return cachedUseFollowHook;
+    }
+    catch (error) {
+        if (__DEV__) {
+            core_3.logger.warn('useFollow hook is not available. Please import useFollow from @oxyhq/services directly.', { component: 'OxyContext', method: 'loadUseFollowHook' }, error);
+        }
+        const fallback = () => {
+            throw new Error('useFollow hook is only available in the UI bundle. Import it from @oxyhq/services.');
+        };
+        cachedUseFollowHook = fallback;
+        return cachedUseFollowHook;
+    }
+};
+const OxyProvider = ({ children, oxyServices: providedOxyServices, baseURL, authWebUrl, authRedirectUri, storageKeyPrefix = 'oxy_session', onAuthStateChange, onError, }) => {
+    const oxyServicesRef = (0, react_1.useRef)(null);
+    if (!oxyServicesRef.current) {
+        if (providedOxyServices) {
+            oxyServicesRef.current = providedOxyServices;
+        }
+        else if (baseURL) {
+            oxyServicesRef.current = new core_1.OxyServices({
+                baseURL,
+                authWebUrl,
+                authRedirectUri,
+            });
+        }
+        else {
+            throw new Error('Either oxyServices or baseURL must be provided to OxyContextProvider');
+        }
+    }
+    const oxyServices = oxyServicesRef.current;
+    const { user, isAuthenticated, isLoading, error, loginSuccess, loginFailure, logoutStore, } = (0, authStore_1.useAuthStore)((0, shallow_1.useShallow)((state) => ({
+        user: state.user,
+        isAuthenticated: state.isAuthenticated,
+        isLoading: state.isLoading,
+        error: state.error,
+        loginSuccess: state.loginSuccess,
+        loginFailure: state.loginFailure,
+        logoutStore: state.logout,
+    })));
+    const [tokenReady, setTokenReady] = (0, react_1.useState)(true);
+    const [initialized, setInitialized] = (0, react_1.useState)(false);
+    const setAuthState = authStore_1.useAuthStore.setState;
+    const logger = (0, react_1.useCallback)((message, err) => {
+        if (__DEV__) {
+            console.warn(`[OxyContext] ${message}`, err);
+        }
+    }, []);
+    const storageKeys = (0, react_1.useMemo)(() => (0, storageHelpers_1.getStorageKeys)(storageKeyPrefix), [storageKeyPrefix]);
+    // Simple storage initialization - no complex hook needed
+    const storageRef = (0, react_1.useRef)(null);
+    const [storage, setStorage] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        let mounted = true;
+        (0, storageHelpers_1.createPlatformStorage)()
+            .then((storageInstance) => {
+            if (mounted) {
+                storageRef.current = storageInstance;
+                setStorage(storageInstance);
+            }
+        })
+            .catch((err) => {
+            if (mounted) {
+                logger('Failed to initialize storage', err);
+                onError?.({
+                    message: 'Failed to initialize storage',
+                    code: 'STORAGE_INIT_ERROR',
+                    status: 500,
+                });
+            }
+        });
+        return () => {
+            mounted = false;
+        };
+    }, [logger, onError]);
+    // Offline queuing is now handled by TanStack Query mutations
+    // No need for custom offline queue
+    const { currentLanguage, metadata: currentLanguageMetadata, languageName: currentLanguageName, nativeLanguageName: currentNativeLanguageName, setLanguage, applyLanguagePreference, } = (0, useLanguageManagement_1.useLanguageManagement)({
+        storage,
+        languageKey: storageKeys.language,
+        onError,
+        logger,
+    });
+    const queryClient = (0, react_query_1.useQueryClient)();
+    const { sessions, activeSessionId, setActiveSessionId, updateSessions, switchSession, refreshSessions, clearSessionState, saveActiveSessionId, trackRemovedSession, } = (0, useSessionManagement_1.useSessionManagement)({
+        oxyServices,
+        storage,
+        storageKeyPrefix,
+        loginSuccess,
+        logoutStore,
+        applyLanguagePreference,
+        onAuthStateChange,
+        onError,
+        setAuthError: (message) => setAuthState({ error: message }),
+        logger,
+        setTokenReady,
+        queryClient,
+    });
+    const { signIn, logout, logoutAll, } = (0, useAuthOperations_1.useAuthOperations)({
+        oxyServices,
+        storage,
+        sessions,
+        activeSessionId,
+        setActiveSessionId,
+        updateSessions,
+        saveActiveSessionId,
+        clearSessionState,
+        switchSession,
+        applyLanguagePreference,
+        onAuthStateChange,
+        onError,
+        loginSuccess,
+        loginFailure,
+        logoutStore,
+        setAuthState,
+        logger,
+    });
+    // Clear all account data (sessions, cache, etc.)
+    const clearAllAccountData = (0, react_1.useCallback)(async () => {
+        // Clear TanStack Query cache (in-memory)
+        queryClient.clear();
+        // Clear persisted query cache
+        if (storage) {
+            try {
+                await (0, queryClient_1.clearQueryCache)(storage);
+            }
+            catch (error) {
+                logger('Failed to clear persisted query cache', error);
+            }
+        }
+        // Clear session state (sessions, activeSessionId, storage)
+        await clearSessionState();
+        // Reset account store
+        accountStore_1.useAccountStore.getState().reset();
+        // Clear HTTP service cache
+        oxyServices.clearCache();
+    }, [queryClient, storage, clearSessionState, logger, oxyServices]);
+    const { getDeviceSessions, logoutAllDeviceSessions, updateDeviceName } = (0, useDeviceManagement_1.useDeviceManagement)({
+        oxyServices,
+        activeSessionId,
+        onError,
+        clearSessionState,
+        logger,
+    });
+    const useFollowHook = loadUseFollowHook();
+    // Refs for mutable callbacks to avoid stale closures in restoreSessionsFromStorage (#187)
+    const switchSessionRef = (0, react_1.useRef)(switchSession);
+    switchSessionRef.current = switchSession;
+    const updateSessionsRef = (0, react_1.useRef)(updateSessions);
+    updateSessionsRef.current = updateSessions;
+    const clearSessionStateRef = (0, react_1.useRef)(clearSessionState);
+    clearSessionStateRef.current = clearSessionState;
+    const restoreSessionsFromStorage = (0, react_1.useCallback)(async () => {
+        if (!storage) {
+            return;
+        }
+        setTokenReady(false);
+        try {
+            const storedSessionIdsJson = await storage.getItem(storageKeys.sessionIds);
+            const storedSessionIds = storedSessionIdsJson ? JSON.parse(storedSessionIdsJson) : [];
+            const storedActiveSessionId = await storage.getItem(storageKeys.activeSessionId);
+            let validSessions = [];
+            if (storedSessionIds.length > 0) {
+                // Validate all sessions in parallel (with 8s timeout per session) to avoid
+                // sequential blocking that freezes the app on startup
+                const VALIDATION_TIMEOUT = 8000;
+                const results = await Promise.allSettled(storedSessionIds.map(async (sessionId) => {
+                    const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(null), VALIDATION_TIMEOUT));
+                    const validationPromise = oxyServices
+                        .validateSession(sessionId, { useHeaderValidation: true })
+                        .catch((validationError) => {
+                        if (!(0, errorHandlers_1.isInvalidSessionError)(validationError) && !(0, errorHandlers_1.isTimeoutOrNetworkError)(validationError)) {
+                            logger('Session validation failed during init', validationError);
+                        }
+                        else if (__DEV__ && (0, errorHandlers_1.isTimeoutOrNetworkError)(validationError)) {
+                            core_3.logger.debug('Session validation timeout (expected when offline)', { component: 'OxyContext', method: 'restoreSessionsFromStorage' }, validationError);
+                        }
+                        return null;
+                    });
+                    return Promise.race([validationPromise, timeoutPromise]).then((validation) => {
+                        if (validation?.valid && validation.user) {
+                            const now = new Date();
+                            return {
+                                sessionId,
+                                deviceId: '',
+                                expiresAt: new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+                                lastActive: now.toISOString(),
+                                userId: validation.user.id?.toString() ?? '',
+                                isCurrent: sessionId === storedActiveSessionId,
+                            };
+                        }
+                        return null;
+                    });
+                }));
+                validSessions = results
+                    .filter((r) => r.status === 'fulfilled')
+                    .map((r) => r.value)
+                    .filter((s) => s !== null);
+                // Always persist validated sessions to storage (even empty list)
+                // to clear stale/expired session IDs that would cause 401 loops on restart
+                updateSessionsRef.current(validSessions, { merge: false });
+            }
+            if (storedActiveSessionId) {
+                try {
+                    await switchSessionRef.current(storedActiveSessionId);
+                }
+                catch (switchError) {
+                    // Silently handle expected errors (invalid sessions, timeouts, network issues)
+                    if ((0, errorHandlers_1.isInvalidSessionError)(switchError)) {
+                        await storage.removeItem(storageKeys.activeSessionId);
+                        updateSessionsRef.current(validSessions.filter((session) => session.sessionId !== storedActiveSessionId), { merge: false });
+                        // Don't log expected session errors during restoration
+                    }
+                    else if ((0, errorHandlers_1.isTimeoutOrNetworkError)(switchError)) {
+                        // Timeout/network error - non-critical, don't block
+                        if (__DEV__) {
+                            core_3.logger.debug('Active session validation timeout (expected when offline)', { component: 'OxyContext', method: 'restoreSessionsFromStorage' }, switchError);
+                        }
+                    }
+                    else {
+                        // Only log unexpected errors
+                        logger('Active session validation error', switchError);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (__DEV__) {
+                core_3.logger.error('Auth init error', error instanceof Error ? error : new Error(String(error)), { component: 'OxyContext', method: 'restoreSessionsFromStorage' });
+            }
+            await clearSessionStateRef.current();
+        }
+        finally {
+            setTokenReady(true);
+        }
+    }, [
+        logger,
+        oxyServices,
+        storage,
+        storageKeys.activeSessionId,
+        storageKeys.sessionIds,
+    ]);
+    (0, react_1.useEffect)(() => {
+        if (!storage || initialized) {
+            return;
+        }
+        setInitialized(true);
+        restoreSessionsFromStorage().catch((error) => {
+            if (__DEV__) {
+                logger('Failed to restore sessions from storage', error);
+            }
+        });
+    }, [restoreSessionsFromStorage, storage, initialized, logger]);
+    // Web SSO: Automatically check for cross-domain session on web platforms
+    // Also used for popup auth - updates all state and persists session
+    const handleWebSSOSession = (0, react_1.useCallback)(async (session) => {
+        if (!session?.user || !session?.sessionId) {
+            if (__DEV__) {
+                core_3.logger.warn('handleWebSSOSession: Invalid session', { component: 'OxyContext' });
+            }
+            return;
+        }
+        // Set the access token on the HTTP client before updating UI state
+        if (session.accessToken) {
+            oxyServices.httpService.setTokens(session.accessToken);
+        }
+        else {
+            await oxyServices.getTokenBySession(session.sessionId);
+        }
+        const clientSession = {
+            sessionId: session.sessionId,
+            deviceId: session.deviceId || '',
+            expiresAt: session.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+            lastActive: new Date().toISOString(),
+            userId: session.user.id?.toString() ?? '',
+            isCurrent: true,
+        };
+        updateSessions([clientSession], { merge: true });
+        setActiveSessionId(session.sessionId);
+        loginSuccess(session.user);
+        onAuthStateChange?.(session.user);
+        // Persist to storage
+        if (storage) {
+            await storage.setItem(storageKeys.activeSessionId, session.sessionId);
+            const existingIds = await storage.getItem(storageKeys.sessionIds);
+            let sessionIds = [];
+            try {
+                sessionIds = existingIds ? JSON.parse(existingIds) : [];
+            }
+            catch { /* corrupted storage */ }
+            if (!sessionIds.includes(session.sessionId)) {
+                sessionIds.push(session.sessionId);
+                await storage.setItem(storageKeys.sessionIds, JSON.stringify(sessionIds));
+            }
+        }
+    }, [oxyServices, updateSessions, setActiveSessionId, loginSuccess, onAuthStateChange, storage, storageKeys]);
+    // Enable web SSO only after local storage check completes and no user found
+    const shouldTryWebSSO = (0, useWebSSO_1.isWebBrowser)() && tokenReady && !user && initialized;
+    (0, useWebSSO_1.useWebSSO)({
+        oxyServices,
+        onSessionFound: handleWebSSOSession,
+        onError: (error) => {
+            if (__DEV__) {
+                core_3.logger.debug('Web SSO check failed (non-critical)', { component: 'OxyContext' }, error);
+            }
+        },
+        enabled: shouldTryWebSSO,
+    });
+    // IdP session validation via lightweight iframe check
+    // When user returns to tab, verify auth.oxy.so still has their session
+    // If session is gone (cleared/logged out), clear local session too
+    const lastIdPCheckRef = (0, react_1.useRef)(0);
+    const pendingIdPCleanupRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        if (!(0, useWebSSO_1.isWebBrowser)() || !user || !initialized)
+            return;
+        const checkIdPSession = () => {
+            // Debounce: check at most once per 30 seconds
+            const now = Date.now();
+            if (now - lastIdPCheckRef.current < 30000)
+                return;
+            lastIdPCheckRef.current = now;
+            // Clean up any in-flight check before starting a new one
+            pendingIdPCleanupRef.current?.();
+            // Load hidden iframe to check IdP session via postMessage
+            const iframe = document.createElement('iframe');
+            iframe.style.cssText = 'display:none;width:0;height:0;border:0';
+            const idpOrigin = authWebUrl || 'https://auth.oxy.so';
+            iframe.src = `${idpOrigin}/auth/session-check?client_id=${encodeURIComponent(window.location.origin)}`;
+            let cleaned = false;
+            const cleanup = () => {
+                if (cleaned)
+                    return;
+                cleaned = true;
+                window.removeEventListener('message', handleMessage);
+                iframe.remove();
+            };
+            const handleMessage = async (event) => {
+                if (event.origin !== idpOrigin)
+                    return;
+                if (event.data?.type !== 'oxy-session-check')
+                    return;
+                cleanup();
+                if (!event.data.hasSession) {
+                    sonner_1.toast.info('Your session has ended. Please sign in again.');
+                    await clearSessionState();
+                }
+            };
+            window.addEventListener('message', handleMessage);
+            document.body.appendChild(iframe);
+            setTimeout(cleanup, 5000); // Timeout after 5s
+            pendingIdPCleanupRef.current = cleanup;
+        };
+        const handleVisibilityChange = () => {
+            if (document.visibilityState === 'visible') {
+                checkIdPSession();
+            }
+        };
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return () => {
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+            pendingIdPCleanupRef.current?.();
+            pendingIdPCleanupRef.current = null;
+        };
+    }, [user, initialized, clearSessionState]);
+    const activeSession = activeSessionId
+        ? sessions.find((session) => session.sessionId === activeSessionId)
+        : undefined;
+    const currentDeviceId = activeSession?.deviceId ?? null;
+    const userId = user?.id;
+    const refreshSessionsWithUser = (0, react_1.useCallback)(() => refreshSessions(userId), [refreshSessions, userId]);
+    const handleSessionRemoved = (0, react_1.useCallback)((sessionId) => {
+        trackRemovedSession(sessionId);
+    }, [trackRemovedSession]);
+    const handleRemoteSignOut = (0, react_1.useCallback)(() => {
+        sonner_1.toast.info('You have been signed out remotely.');
+        logout().catch((remoteError) => logger('Failed to process remote sign out', remoteError));
+    }, [logger, logout]);
+    (0, useSessionSocket_1.useSessionSocket)({
+        userId,
+        activeSessionId,
+        currentDeviceId,
+        refreshSessions: refreshSessionsWithUser,
+        logout,
+        clearSessionState,
+        baseURL: oxyServices.getBaseURL(),
+        getAccessToken: () => oxyServices.getAccessToken(),
+        onRemoteSignOut: handleRemoteSignOut,
+        onSessionRemoved: handleSessionRemoved,
+    });
+    const switchSessionForContext = (0, react_1.useCallback)(async (sessionId) => {
+        await switchSession(sessionId);
+    }, [switchSession]);
+    // Identity management wrappers (delegate to KeyManager)
+    const hasIdentity = (0, react_1.useCallback)(async () => {
+        return core_2.KeyManager.hasIdentity();
+    }, []);
+    const getPublicKey = (0, react_1.useCallback)(async () => {
+        return core_2.KeyManager.getPublicKey();
+    }, []);
+    // Create showBottomSheet function that uses the global function
+    const showBottomSheetForContext = (0, react_1.useCallback)((screenOrConfig) => {
+        (0, bottomSheetManager_1.showBottomSheet)(screenOrConfig);
+    }, []);
+    // Avatar picker extracted into dedicated hook
+    const { openAvatarPicker } = (0, useAvatarPicker_1.useAvatarPicker)({
+        oxyServices,
+        currentLanguage,
+        activeSessionId,
+        queryClient,
+        showBottomSheet: showBottomSheetForContext,
+    });
+    const contextValue = (0, react_1.useMemo)(() => ({
+        user,
+        sessions,
+        activeSessionId,
+        isAuthenticated,
+        isLoading,
+        isTokenReady: tokenReady,
+        isStorageReady: storage !== null,
+        error,
+        currentLanguage,
+        currentLanguageMetadata,
+        currentLanguageName,
+        currentNativeLanguageName,
+        hasIdentity,
+        getPublicKey,
+        signIn,
+        handlePopupSession: handleWebSSOSession,
+        logout,
+        logoutAll,
+        switchSession: switchSessionForContext,
+        removeSession: logout,
+        refreshSessions: refreshSessionsWithUser,
+        setLanguage,
+        getDeviceSessions,
+        logoutAllDeviceSessions,
+        updateDeviceName,
+        clearSessionState,
+        clearAllAccountData,
+        oxyServices,
+        useFollow: useFollowHook,
+        showBottomSheet: showBottomSheetForContext,
+        openAvatarPicker,
+    }), [
+        activeSessionId,
+        signIn,
+        handleWebSSOSession,
+        currentLanguage,
+        currentLanguageMetadata,
+        currentLanguageName,
+        currentNativeLanguageName,
+        error,
+        getDeviceSessions,
+        getPublicKey,
+        hasIdentity,
+        isAuthenticated,
+        isLoading,
+        logout,
+        logoutAll,
+        logoutAllDeviceSessions,
+        oxyServices,
+        refreshSessionsWithUser,
+        sessions,
+        setLanguage,
+        storage,
+        switchSessionForContext,
+        tokenReady,
+        updateDeviceName,
+        clearAllAccountData,
+        useFollowHook,
+        user,
+        showBottomSheetForContext,
+        openAvatarPicker,
+    ]);
+    return ((0, jsx_runtime_1.jsx)(OxyContext.Provider, { value: contextValue, children: children }));
+};
+exports.OxyProvider = OxyProvider;
+exports.OxyContextProvider = exports.OxyProvider;
+const useOxy = () => {
+    const context = (0, react_1.useContext)(OxyContext);
+    if (!context) {
+        throw new Error('useOxy must be used within an OxyContextProvider');
+    }
+    return context;
+};
+exports.useOxy = useOxy;
+exports.default = OxyContext;

package/src/ui/context/ThemeContext.d.ts

@@ -0,0 +1,18 @@
+import React, { type ReactNode } from 'react';
+type ResolvedTheme = 'light' | 'dark';
+interface ThemeContextType {
+    resolvedTheme: ResolvedTheme;
+    isLoaded: boolean;
+}
+export declare const ThemeContext: React.Context<ThemeContextType | undefined>;
+interface ThemeProviderProps {
+    theme: 'light' | 'dark';
+    children: ReactNode;
+}
+/**
+ * ThemeProvider component that accepts a theme prop and provides it via context.
+ * This allows Accounts-style components to access theme through hooks.
+ */
+export declare function ThemeProvider({ theme, children }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useThemeContext(): ThemeContextType;
+export {};

package/src/ui/context/ThemeContext.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThemeContext = void 0;
+exports.ThemeProvider = ThemeProvider;
+exports.useThemeContext = useThemeContext;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+exports.ThemeContext = (0, react_1.createContext)(undefined);
+/**
+ * ThemeProvider component that accepts a theme prop and provides it via context.
+ * This allows Accounts-style components to access theme through hooks.
+ */
+function ThemeProvider({ theme, children }) {
+    return ((0, jsx_runtime_1.jsx)(exports.ThemeContext.Provider, { value: {
+            resolvedTheme: theme,
+            isLoaded: true,
+        }, children: children }));
+}
+function useThemeContext() {
+    const context = (0, react_1.useContext)(exports.ThemeContext);
+    if (context === undefined) {
+        throw new Error('useThemeContext must be used within a ThemeProvider');
+    }
+    return context;
+}

package/src/ui/context/hooks/useAuthOperations.d.ts

@@ -0,0 +1,39 @@
+import type { ApiError, User } from '@oxyhq/core';
+import type { AuthState } from '../../stores/authStore';
+import type { ClientSession } from '@oxyhq/core';
+import type { StorageInterface } from '../../utils/storageHelpers';
+import type { OxyServices } from '@oxyhq/core';
+export interface UseAuthOperationsOptions {
+    oxyServices: OxyServices;
+    storage: StorageInterface | null;
+    sessions: ClientSession[];
+    activeSessionId: string | null;
+    setActiveSessionId: (sessionId: string | null) => void;
+    updateSessions: (sessions: ClientSession[], options?: {
+        merge?: boolean;
+    }) => void;
+    saveActiveSessionId: (sessionId: string) => Promise<void>;
+    clearSessionState: () => Promise<void>;
+    switchSession: (sessionId: string) => Promise<User>;
+    applyLanguagePreference: (user: User) => Promise<void>;
+    onAuthStateChange?: (user: User | null) => void;
+    onError?: (error: ApiError) => void;
+    loginSuccess: (user: User) => void;
+    loginFailure: (message: string) => void;
+    logoutStore: () => void;
+    setAuthState: (state: Partial<AuthState>) => void;
+    logger?: (message: string, error?: unknown) => void;
+}
+export interface UseAuthOperationsResult {
+    /** Sign in with existing public key */
+    signIn: (publicKey: string, deviceName?: string) => Promise<User>;
+    /** Logout from current session */
+    logout: (targetSessionId?: string) => Promise<void>;
+    /** Logout from all sessions */
+    logoutAll: () => Promise<void>;
+}
+/**
+ * Authentication operations using public key cryptography.
+ * Accepts public key as parameter - identity management is handled by the app layer.
+ */
+export declare const useAuthOperations: ({ oxyServices, storage, sessions, activeSessionId, setActiveSessionId, updateSessions, saveActiveSessionId, clearSessionState, switchSession, applyLanguagePreference, onAuthStateChange, onError, loginSuccess, loginFailure, logoutStore, setAuthState, logger, }: UseAuthOperationsOptions) => UseAuthOperationsResult;