@oxyhq/services 6.9.13 → 6.9.15

package/src/ui/hooks/useLanguageManagement.d.ts

@@ -0,0 +1,24 @@
+import type { ApiError, User } from '@oxyhq/core';
+import { type LanguageMetadata } from '@oxyhq/core';
+import type { StorageInterface } from '../utils/storageHelpers';
+export interface UseLanguageManagementOptions {
+    storage: StorageInterface | null;
+    languageKey: string;
+    onError?: (error: ApiError) => void;
+    logger?: (message: string, error?: unknown) => void;
+}
+export interface UseLanguageManagementResult {
+    currentLanguage: string;
+    metadata: LanguageMetadata | null;
+    languageName: string;
+    nativeLanguageName: string;
+    setLanguage: (languageId: string) => Promise<void>;
+    applyLanguagePreference: (user: User | null) => Promise<void>;
+    hydrateLanguage: () => Promise<void>;
+}
+/**
+ * Manage UI language state, persistence, and metadata derivation.
+ *
+ * @param options - Configuration for storage access and error reporting
+ */
+export declare const useLanguageManagement: ({ storage, languageKey, onError, logger, }: UseLanguageManagementOptions) => UseLanguageManagementResult;

package/src/ui/hooks/useLanguageManagement.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLanguageManagement = void 0;
+const react_1 = require("react");
+const core_1 = require("@oxyhq/core");
+const errorHandlers_1 = require("../utils/errorHandlers");
+const DEFAULT_LANGUAGE = 'en-US';
+/**
+ * Manage UI language state, persistence, and metadata derivation.
+ *
+ * @param options - Configuration for storage access and error reporting
+ */
+const useLanguageManagement = ({ storage, languageKey, onError, logger, }) => {
+    const [currentLanguage, setCurrentLanguage] = (0, react_1.useState)(DEFAULT_LANGUAGE);
+    const loadLanguageFromStorage = (0, react_1.useCallback)(async () => {
+        if (!storage) {
+            return;
+        }
+        try {
+            const savedLanguageRaw = await storage.getItem(languageKey);
+            const normalized = (0, core_1.normalizeLanguageCode)(savedLanguageRaw) || savedLanguageRaw;
+            if (normalized) {
+                setCurrentLanguage(normalized);
+            }
+        }
+        catch (error) {
+            const message = (0, errorHandlers_1.extractErrorMessage)(error, 'Failed to load language preference');
+            onError?.({
+                message,
+                code: 'LANGUAGE_LOAD_ERROR',
+                status: 500,
+            });
+            if (logger) {
+                logger(message, error);
+            }
+            else if (__DEV__) {
+                console.warn('Failed to load language preference:', error);
+            }
+        }
+    }, [languageKey, logger, onError, storage]);
+    (0, react_1.useEffect)(() => {
+        loadLanguageFromStorage().catch((error) => {
+            if (logger) {
+                logger('Unexpected error loading language', error);
+            }
+        });
+    }, [loadLanguageFromStorage, logger]);
+    const setLanguage = (0, react_1.useCallback)(async (languageId) => {
+        if (!storage) {
+            throw new Error('Storage not initialized');
+        }
+        const normalized = (0, core_1.normalizeLanguageCode)(languageId) || languageId;
+        try {
+            await storage.setItem(languageKey, normalized);
+            setCurrentLanguage(normalized);
+        }
+        catch (error) {
+            const message = (0, errorHandlers_1.extractErrorMessage)(error, 'Failed to save language preference');
+            onError?.({
+                message,
+                code: 'LANGUAGE_SAVE_ERROR',
+                status: 500,
+            });
+            if (logger) {
+                logger(message, error);
+            }
+            else if (__DEV__) {
+                console.warn('Failed to save language preference:', error);
+            }
+            throw error instanceof Error ? error : new Error(message);
+        }
+    }, [languageKey, logger, onError, storage]);
+    const applyLanguagePreference = (0, react_1.useCallback)(async (user) => {
+        if (!storage || !user) {
+            return;
+        }
+        const userLanguage = user?.language;
+        if (!userLanguage) {
+            return;
+        }
+        try {
+            const normalized = (0, core_1.normalizeLanguageCode)(userLanguage) || userLanguage;
+            await storage.setItem(languageKey, normalized);
+            setCurrentLanguage(normalized);
+        }
+        catch (error) {
+            if (logger) {
+                logger('Failed to apply server language preference', error);
+            }
+            else if (__DEV__) {
+                console.warn('Failed to apply server language preference', error);
+            }
+        }
+    }, [languageKey, logger, storage]);
+    const metadata = (0, react_1.useMemo)(() => (0, core_1.getLanguageMetadata)(currentLanguage), [currentLanguage]);
+    const languageName = (0, react_1.useMemo)(() => (0, core_1.getLanguageName)(currentLanguage), [currentLanguage]);
+    const nativeLanguageName = (0, react_1.useMemo)(() => (0, core_1.getNativeLanguageName)(currentLanguage), [currentLanguage]);
+    return {
+        currentLanguage,
+        metadata,
+        languageName,
+        nativeLanguageName,
+        setLanguage,
+        applyLanguagePreference,
+        hydrateLanguage: loadLanguageFromStorage,
+    };
+};
+exports.useLanguageManagement = useLanguageManagement;

package/src/ui/hooks/useProfileEditing.d.ts

@@ -0,0 +1,35 @@
+export interface ProfileUpdateData {
+    displayName?: string;
+    lastName?: string;
+    username?: string;
+    email?: string;
+    bio?: string;
+    location?: string;
+    locations?: Array<{
+        id: string;
+        name: string;
+        label?: string;
+        coordinates?: {
+            lat: number;
+            lon: number;
+        };
+    }>;
+    links?: string[];
+    linksMetadata?: Array<{
+        url: string;
+        title?: string;
+        description?: string;
+        image?: string;
+        id: string;
+    }>;
+    avatar?: string;
+}
+/**
+ * Hook for managing profile editing operations
+ * Provides functions to update profile fields and handle saving
+ */
+export declare const useProfileEditing: () => {
+    saveProfile: (updates: ProfileUpdateData) => Promise<boolean>;
+    updateField: (field: string, value: any) => Promise<boolean>;
+    isSaving: boolean;
+};

package/src/ui/hooks/useProfileEditing.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useProfileEditing = void 0;
+const react_1 = require("react");
+const useI18n_1 = require("./useI18n");
+const useAccountMutations_1 = require("./mutations/useAccountMutations");
+const authStore_1 = require("../stores/authStore");
+/**
+ * Hook for managing profile editing operations
+ * Provides functions to update profile fields and handle saving
+ */
+const useProfileEditing = () => {
+    const { t } = (0, useI18n_1.useI18n)();
+    const updateProfileMutation = (0, useAccountMutations_1.useUpdateProfile)();
+    /**
+     * Save profile updates to the server using TanStack Query
+     */
+    const saveProfile = (0, react_1.useCallback)(async (updates) => {
+        // Prepare update object
+        const updateData = {};
+        if (updates.username !== undefined) {
+            updateData.username = updates.username;
+        }
+        if (updates.email !== undefined) {
+            updateData.email = updates.email;
+        }
+        if (updates.bio !== undefined) {
+            updateData.bio = updates.bio;
+        }
+        if (updates.location !== undefined || updates.locations !== undefined) {
+            updateData.location = updates.locations && updates.locations.length > 0
+                ? updates.locations[0].name
+                : updates.location || '';
+            if (updates.locations) {
+                updateData.locations = updates.locations;
+            }
+        }
+        if (updates.links !== undefined) {
+            updateData.links = updates.links;
+        }
+        if (updates.linksMetadata !== undefined) {
+            updateData.linksMetadata = updates.linksMetadata;
+        }
+        if (updates.avatar !== undefined) {
+            updateData.avatar = updates.avatar;
+        }
+        // Handle name field
+        if (updates.displayName !== undefined || updates.lastName !== undefined) {
+            const currentUser = authStore_1.useAuthStore.getState().user;
+            const currentName = currentUser?.name;
+            updateData.name = {
+                first: updates.displayName ?? (typeof currentName === 'object' ? currentName?.first : '') ?? '',
+                last: updates.lastName ?? (typeof currentName === 'object' ? currentName?.last : '') ?? '',
+            };
+        }
+        try {
+            await updateProfileMutation.mutateAsync(updateData);
+            return true;
+        }
+        catch (error) {
+            // Error toast is handled by the mutation
+            return false;
+        }
+    }, [updateProfileMutation, t]);
+    /**
+     * Update a single profile field
+     */
+    const updateField = (0, react_1.useCallback)(async (field, value) => {
+        const updates = {};
+        switch (field) {
+            case 'displayName':
+                updates.displayName = value;
+                break;
+            case 'username':
+                updates.username = value;
+                break;
+            case 'email':
+                updates.email = value;
+                break;
+            case 'bio':
+                updates.bio = value;
+                break;
+            case 'location':
+                updates.locations = value;
+                break;
+            case 'links':
+                updates.linksMetadata = value;
+                updates.links = value.map((link) => link.url || link);
+                break;
+            default:
+                return false;
+        }
+        return await saveProfile(updates);
+    }, [saveProfile]);
+    return {
+        saveProfile,
+        updateField,
+        isSaving: updateProfileMutation.isPending,
+    };
+};
+exports.useProfileEditing = useProfileEditing;

package/src/ui/hooks/useQueryClient.d.ts

@@ -0,0 +1,6 @@
+import type { QueryClient } from '@tanstack/react-query';
+/**
+ * Custom hook to access the QueryClient
+ * Provides type safety and ensures client is available
+ */
+export declare const useQueryClient: () => QueryClient;

package/src/ui/hooks/useQueryClient.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useQueryClient = void 0;
+const react_query_1 = require("@tanstack/react-query");
+/**
+ * Custom hook to access the QueryClient
+ * Provides type safety and ensures client is available
+ */
+const useQueryClient = () => {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    if (!queryClient) {
+        throw new Error('QueryClient is not available. Make sure OxyProvider is wrapping your app.');
+    }
+    return queryClient;
+};
+exports.useQueryClient = useQueryClient;

package/src/ui/hooks/useSessionManagement.d.ts

@@ -0,0 +1,40 @@
+import type { ApiError, User } from '@oxyhq/core';
+import type { ClientSession } from '@oxyhq/core';
+import { getStorageKeys, type StorageInterface } from '../utils/storageHelpers';
+import type { OxyServices } from '@oxyhq/core';
+import type { QueryClient } from '@tanstack/react-query';
+export interface UseSessionManagementOptions {
+    oxyServices: OxyServices;
+    storage: StorageInterface | null;
+    storageKeyPrefix?: string;
+    loginSuccess: (user: User) => void;
+    logoutStore: () => void;
+    applyLanguagePreference: (user: User) => Promise<void>;
+    onAuthStateChange?: (user: User | null) => void;
+    onError?: (error: ApiError) => void;
+    setAuthError?: (message: string | null) => void;
+    logger?: (message: string, error?: unknown) => void;
+    setTokenReady?: (ready: boolean) => void;
+    queryClient?: QueryClient | null;
+}
+export interface UseSessionManagementResult {
+    sessions: ClientSession[];
+    activeSessionId: string | null;
+    setActiveSessionId: (sessionId: string | null) => void;
+    updateSessions: (incoming: ClientSession[], options?: {
+        merge?: boolean;
+    }) => void;
+    switchSession: (sessionId: string) => Promise<User>;
+    refreshSessions: (activeUserId?: string) => Promise<void>;
+    clearSessionState: () => Promise<void>;
+    saveActiveSessionId: (sessionId: string) => Promise<void>;
+    trackRemovedSession: (sessionId: string) => void;
+    storageKeys: ReturnType<typeof getStorageKeys>;
+    isRefreshInFlight: boolean;
+}
+/**
+ * Manage session state, persistence, and high-level multi-session operations.
+ *
+ * @param options - Session management configuration
+ */
+export declare const useSessionManagement: ({ oxyServices, storage, storageKeyPrefix, loginSuccess, logoutStore, applyLanguagePreference, onAuthStateChange, onError, setAuthError, logger, setTokenReady, queryClient, }: UseSessionManagementOptions) => UseSessionManagementResult;

package/src/ui/hooks/useSessionManagement.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSessionManagement = void 0;
+const react_1 = require("react");
+const core_1 = require("@oxyhq/core");
+const sessionHelpers_1 = require("../utils/sessionHelpers");
+const storageHelpers_1 = require("../utils/storageHelpers");
+const errorHandlers_1 = require("../utils/errorHandlers");
+const queryClient_1 = require("./queryClient");
+const DEFAULT_SAVE_ERROR_MESSAGE = 'Failed to save session data';
+const CLEAR_STORAGE_ERROR = 'Failed to clear storage';
+/**
+ * Manage session state, persistence, and high-level multi-session operations.
+ *
+ * @param options - Session management configuration
+ */
+const useSessionManagement = ({ oxyServices, storage, storageKeyPrefix, loginSuccess, logoutStore, applyLanguagePreference, onAuthStateChange, onError, setAuthError, logger, setTokenReady, queryClient, }) => {
+    const [sessions, setSessions] = (0, react_1.useState)([]);
+    const [activeSessionId, setActiveSessionId] = (0, react_1.useState)(null);
+    // Refs to avoid recreating callbacks when sessions/activeSessionId change
+    const sessionsRef = (0, react_1.useRef)(sessions);
+    sessionsRef.current = sessions;
+    const activeSessionIdRef = (0, react_1.useRef)(activeSessionId);
+    activeSessionIdRef.current = activeSessionId;
+    const refreshInFlightRef = (0, react_1.useRef)(null);
+    const removedSessionsRef = (0, react_1.useRef)(new Set());
+    const lastRefreshRef = (0, react_1.useRef)(0);
+    const storageKeys = (0, react_1.useMemo)(() => (0, storageHelpers_1.getStorageKeys)(storageKeyPrefix), [storageKeyPrefix]);
+    const saveSessionIds = (0, react_1.useCallback)(async (sessionIds) => {
+        if (!storage)
+            return;
+        try {
+            const uniqueIds = Array.from(new Set(sessionIds));
+            await storage.setItem(storageKeys.sessionIds, JSON.stringify(uniqueIds));
+        }
+        catch (error) {
+            if (logger) {
+                logger(DEFAULT_SAVE_ERROR_MESSAGE, error);
+            }
+            else if (__DEV__) {
+                console.warn('Failed to save session IDs:', error);
+            }
+        }
+    }, [logger, storage, storageKeys.sessionIds]);
+    const updateSessions = (0, react_1.useCallback)((incoming, options = {}) => {
+        setSessions((prevSessions) => {
+            const processed = options.merge
+                ? (0, core_1.mergeSessions)(prevSessions, incoming, activeSessionIdRef.current, false)
+                : (0, core_1.normalizeAndSortSessions)(incoming, activeSessionIdRef.current, false);
+            if (storage) {
+                void saveSessionIds(processed.map((session) => session.sessionId));
+            }
+            if ((0, core_1.sessionsArraysEqual)(prevSessions, processed)) {
+                return prevSessions;
+            }
+            return processed;
+        });
+    }, [saveSessionIds, storage]);
+    const saveActiveSessionId = (0, react_1.useCallback)(async (sessionId) => {
+        if (!storage)
+            return;
+        try {
+            await storage.setItem(storageKeys.activeSessionId, sessionId);
+        }
+        catch (error) {
+            (0, errorHandlers_1.handleAuthError)(error, {
+                defaultMessage: DEFAULT_SAVE_ERROR_MESSAGE,
+                code: 'SESSION_PERSISTENCE_ERROR',
+                onError,
+                setAuthError,
+                logger,
+            });
+        }
+    }, [logger, onError, setAuthError, storage, storageKeys.activeSessionId]);
+    const removeActiveSessionId = (0, react_1.useCallback)(async () => {
+        if (!storage)
+            return;
+        try {
+            await storage.removeItem(storageKeys.activeSessionId);
+        }
+        catch (error) {
+            (0, errorHandlers_1.handleAuthError)(error, {
+                defaultMessage: DEFAULT_SAVE_ERROR_MESSAGE,
+                code: 'SESSION_PERSISTENCE_ERROR',
+                onError,
+                setAuthError,
+                logger,
+            });
+        }
+    }, [logger, onError, setAuthError, storage, storageKeys.activeSessionId]);
+    const clearSessionStorage = (0, react_1.useCallback)(async () => {
+        if (!storage)
+            return;
+        try {
+            await storage.removeItem(storageKeys.activeSessionId);
+            await storage.removeItem(storageKeys.sessionIds);
+            // Note: Identity sync state ('oxy_identity_synced') is managed by accounts app
+        }
+        catch (error) {
+            (0, errorHandlers_1.handleAuthError)(error, {
+                defaultMessage: CLEAR_STORAGE_ERROR,
+                code: 'STORAGE_ERROR',
+                onError,
+                setAuthError,
+                logger,
+            });
+        }
+    }, [logger, onError, setAuthError, storage, storageKeys.activeSessionId, storageKeys.sessionIds]);
+    const clearSessionState = (0, react_1.useCallback)(async () => {
+        setSessions([]);
+        setActiveSessionId(null);
+        logoutStore();
+        // Clear TanStack Query cache (in-memory)
+        if (queryClient) {
+            queryClient.clear();
+        }
+        // Clear persisted query cache
+        if (storage) {
+            try {
+                await (0, queryClient_1.clearQueryCache)(storage);
+            }
+            catch (error) {
+                if (logger) {
+                    logger('Failed to clear persisted query cache', error);
+                }
+            }
+        }
+        await clearSessionStorage();
+        onAuthStateChange?.(null);
+    }, [clearSessionStorage, logoutStore, onAuthStateChange, queryClient, storage, logger]);
+    const activateSession = (0, react_1.useCallback)(async (sessionId, user) => {
+        await oxyServices.getTokenBySession(sessionId);
+        setTokenReady?.(true);
+        setActiveSessionId(sessionId);
+        loginSuccess(user);
+        await saveActiveSessionId(sessionId);
+        await applyLanguagePreference(user);
+        onAuthStateChange?.(user);
+    }, [
+        applyLanguagePreference,
+        loginSuccess,
+        onAuthStateChange,
+        oxyServices,
+        saveActiveSessionId,
+        setTokenReady,
+    ]);
+    const removalTimerIdsRef = (0, react_1.useRef)(new Set());
+    const trackRemovedSession = (0, react_1.useCallback)((sessionId) => {
+        removedSessionsRef.current.add(sessionId);
+        const timerId = setTimeout(() => {
+            removedSessionsRef.current.delete(sessionId);
+            removalTimerIdsRef.current.delete(timerId);
+        }, 5000);
+        removalTimerIdsRef.current.add(timerId);
+    }, []);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            removalTimerIdsRef.current.forEach(clearTimeout);
+        };
+    }, []);
+    const findReplacementSession = (0, react_1.useCallback)(async (sessionIds) => {
+        if (!sessionIds.length) {
+            return null;
+        }
+        const validationResults = await (0, sessionHelpers_1.validateSessionBatch)(oxyServices, sessionIds, {
+            maxConcurrency: 3,
+        });
+        const validSession = validationResults.find((result) => result.valid);
+        if (!validSession) {
+            return null;
+        }
+        const validation = await oxyServices.validateSession(validSession.sessionId, {
+            useHeaderValidation: true,
+        });
+        if (!validation?.valid || !validation.user) {
+            return null;
+        }
+        const user = validation.user;
+        await activateSession(validSession.sessionId, user);
+        return user;
+    }, [activateSession, oxyServices]);
+    const switchSession = (0, react_1.useCallback)(async (sessionId) => {
+        try {
+            const validation = await oxyServices.validateSession(sessionId, { useHeaderValidation: true });
+            if (!validation?.valid) {
+                throw new Error('Session is invalid or expired');
+            }
+            if (!validation.user) {
+                throw new Error('User data not available from session validation');
+            }
+            const user = validation.user;
+            await activateSession(sessionId, user);
+            try {
+                const deviceSessions = await (0, sessionHelpers_1.fetchSessionsWithFallback)(oxyServices, sessionId, {
+                    fallbackUserId: user.id,
+                    logger,
+                });
+                updateSessions(deviceSessions, { merge: true });
+            }
+            catch (error) {
+                if (__DEV__) {
+                    console.warn('Failed to synchronize sessions after switch:', error);
+                }
+            }
+            return user;
+        }
+        catch (error) {
+            const invalidSession = (0, errorHandlers_1.isInvalidSessionError)(error);
+            if (invalidSession) {
+                updateSessions(sessionsRef.current.filter((session) => session.sessionId !== sessionId), {
+                    merge: false,
+                });
+                if (sessionId === activeSessionIdRef.current) {
+                    const otherSessionIds = sessionsRef.current
+                        .filter((session) => session.sessionId !== sessionId && !removedSessionsRef.current.has(session.sessionId))
+                        .map((session) => session.sessionId);
+                    const replacementUser = await findReplacementSession(otherSessionIds);
+                    if (replacementUser) {
+                        return replacementUser;
+                    }
+                }
+            }
+            (0, errorHandlers_1.handleAuthError)(error, {
+                defaultMessage: 'Failed to switch session',
+                code: invalidSession ? 'INVALID_SESSION' : 'SESSION_SWITCH_ERROR',
+                onError,
+                setAuthError,
+                logger,
+            });
+            throw error instanceof Error ? error : new Error('Failed to switch session');
+        }
+    }, [
+        activateSession,
+        findReplacementSession,
+        logger,
+        onError,
+        oxyServices,
+        setAuthError,
+        updateSessions,
+    ]);
+    const refreshSessions = (0, react_1.useCallback)(async (activeUserId) => {
+        if (!activeSessionIdRef.current)
+            return;
+        if (refreshInFlightRef.current) {
+            await refreshInFlightRef.current;
+            return;
+        }
+        const now = Date.now();
+        if (now - lastRefreshRef.current < 500) {
+            return;
+        }
+        lastRefreshRef.current = now;
+        const refreshPromise = (async () => {
+            try {
+                const deviceSessions = await (0, sessionHelpers_1.fetchSessionsWithFallback)(oxyServices, activeSessionIdRef.current, {
+                    fallbackUserId: activeUserId,
+                    logger,
+                });
+                updateSessions(deviceSessions, { merge: true });
+            }
+            catch (error) {
+                if ((0, errorHandlers_1.isInvalidSessionError)(error)) {
+                    const otherSessions = sessionsRef.current
+                        .filter((session) => session.sessionId !== activeSessionIdRef.current &&
+                        !removedSessionsRef.current.has(session.sessionId))
+                        .map((session) => session.sessionId);
+                    const replacementUser = await findReplacementSession(otherSessions);
+                    if (!replacementUser) {
+                        await clearSessionState();
+                    }
+                    return;
+                }
+                (0, errorHandlers_1.handleAuthError)(error, {
+                    defaultMessage: 'Failed to refresh sessions',
+                    code: 'SESSION_REFRESH_ERROR',
+                    onError,
+                    setAuthError,
+                    logger,
+                });
+            }
+            finally {
+                refreshInFlightRef.current = null;
+                lastRefreshRef.current = Date.now();
+            }
+        })();
+        refreshInFlightRef.current = refreshPromise;
+        await refreshPromise;
+    }, [
+        clearSessionState,
+        findReplacementSession,
+        logger,
+        onError,
+        oxyServices,
+        setAuthError,
+        updateSessions,
+    ]);
+    const isRefreshInFlight = Boolean(refreshInFlightRef.current);
+    return {
+        sessions,
+        activeSessionId,
+        setActiveSessionId,
+        updateSessions,
+        switchSession,
+        refreshSessions,
+        clearSessionState,
+        saveActiveSessionId,
+        trackRemovedSession,
+        storageKeys,
+        isRefreshInFlight,
+    };
+};
+exports.useSessionManagement = useSessionManagement;

package/src/ui/hooks/useSessionSocket.d.ts

@@ -0,0 +1,14 @@
+interface UseSessionSocketProps {
+    userId: string | null | undefined;
+    activeSessionId: string | null | undefined;
+    currentDeviceId: string | null | undefined;
+    refreshSessions: () => Promise<void>;
+    logout: () => Promise<void>;
+    clearSessionState: () => Promise<void>;
+    baseURL: string;
+    getAccessToken: () => string | null;
+    onRemoteSignOut?: () => void;
+    onSessionRemoved?: (sessionId: string) => void;
+}
+export declare function useSessionSocket({ userId, activeSessionId, currentDeviceId, refreshSessions, logout, clearSessionState, baseURL, getAccessToken, onRemoteSignOut, onSessionRemoved }: UseSessionSocketProps): void;
+export {};