@oxyhq/services 6.9.13 → 6.9.15

package/src/ui/hooks/useAssets.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAssets = exports.setOxyAssetInstance = void 0;
+const react_1 = require("react");
+const assetStore_1 = require("../stores/assetStore");
+// Create a singleton instance for the hook
+let oxyInstance = null;
+const setOxyAssetInstance = (instance) => {
+    oxyInstance = instance;
+};
+exports.setOxyAssetInstance = setOxyAssetInstance;
+/**
+ * Hook for managing assets with Zustand store integration
+ */
+const useAssets = () => {
+    const { assets, uploadProgress, loading, errors, setAsset, setAssets, removeAsset, setUploadProgress, removeUploadProgress, addLink, removeLink, setUploading, setLinking, setDeleting, setUploadError, setLinkError, setDeleteError, clearErrors, getAssetsByApp, getAssetsByEntity, getAssetUsageCount, isAssetLinked, reset } = (0, assetStore_1.useAssetStore)();
+    // Upload asset with progress tracking
+    const upload = (0, react_1.useCallback)(async (file, metadata) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            clearErrors();
+            setUploading(true);
+            const result = await oxyInstance.assetUpload(file, undefined, metadata);
+            // Update progress with final status
+            if (result?.file) {
+                const fileId = result.file.id;
+                setUploadProgress(fileId, {
+                    fileId,
+                    uploaded: file.size,
+                    total: file.size,
+                    percentage: 100,
+                    status: 'complete'
+                });
+                // Remove progress after a short delay
+                setTimeout(() => {
+                    removeUploadProgress(fileId);
+                }, 2000);
+            }
+            // Add asset to store
+            if (result.file) {
+                setAsset(result.file);
+                return result.file;
+            }
+            return null;
+        }
+        catch (error) {
+            setUploadError((error instanceof Error ? error.message : null) || 'Upload failed');
+            throw error;
+        }
+        finally {
+            setUploading(false);
+        }
+    }, [
+        clearErrors,
+        setUploading,
+        setUploadProgress,
+        removeUploadProgress,
+        setAsset,
+        setUploadError
+    ]);
+    // Link asset to entity
+    const link = (0, react_1.useCallback)(async (assetId, app, entityType, entityId) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            clearErrors();
+            setLinking(true);
+            // Auto-detect visibility for avatars and profile banners
+            const visibility = (entityType === 'avatar' || entityType === 'profile-banner')
+                ? 'public'
+                : undefined;
+            const result = await oxyInstance.assetLink(assetId, app, entityType, entityId, visibility);
+            if (result.file) {
+                setAsset(result.file);
+            }
+            else {
+                // If API doesn't return full file, update store optimistically
+                addLink(assetId, {
+                    app,
+                    entityType,
+                    entityId,
+                    createdBy: '', // Will be filled by server
+                    createdAt: new Date().toISOString()
+                });
+            }
+        }
+        catch (error) {
+            setLinkError((error instanceof Error ? error.message : null) || 'Link failed');
+            throw error;
+        }
+        finally {
+            setLinking(false);
+        }
+    }, [clearErrors, setLinking, setAsset, addLink, setLinkError]);
+    // Unlink asset from entity
+    const unlink = (0, react_1.useCallback)(async (assetId, app, entityType, entityId) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            clearErrors();
+            setLinking(true);
+            const result = await oxyInstance.assetUnlink(assetId, app, entityType, entityId);
+            if (result.file) {
+                setAsset(result.file);
+            }
+            else {
+                // Update store optimistically
+                removeLink(assetId, app, entityType, entityId);
+            }
+        }
+        catch (error) {
+            setLinkError((error instanceof Error ? error.message : null) || 'Unlink failed');
+            throw error;
+        }
+        finally {
+            setLinking(false);
+        }
+    }, [clearErrors, setLinking, setAsset, removeLink, setLinkError]);
+    // Get asset URL
+    const getUrl = (0, react_1.useCallback)(async (assetId, variant, expiresIn) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        const result = await oxyInstance.assetGetUrl(assetId, variant, expiresIn);
+        return result.url;
+    }, []);
+    // Get asset metadata
+    const getAsset = (0, react_1.useCallback)(async (assetId) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        const result = await oxyInstance.assetGet(assetId);
+        if (result.file) {
+            setAsset(result.file);
+            return result.file;
+        }
+        throw new Error('Asset not found');
+    }, [setAsset]);
+    // Delete asset
+    const deleteAsset = (0, react_1.useCallback)(async (assetId, force = false) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            clearErrors();
+            setDeleting(true);
+            await oxyInstance.assetDelete(assetId, force);
+            removeAsset(assetId);
+        }
+        catch (error) {
+            setDeleteError((error instanceof Error ? error.message : null) || 'Delete failed');
+            throw error;
+        }
+        finally {
+            setDeleting(false);
+        }
+    }, [clearErrors, setDeleting, removeAsset, setDeleteError]);
+    // Restore asset from trash
+    const restore = (0, react_1.useCallback)(async (assetId) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        const result = await oxyInstance.assetRestore(assetId);
+        if (result.file) {
+            setAsset(result.file);
+        }
+    }, [setAsset]);
+    // Get variants
+    const getVariants = (0, react_1.useCallback)(async (assetId) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        return await oxyInstance.assetGetVariants(assetId);
+    }, []);
+    return {
+        // State
+        assets: Object.values(assets),
+        uploadProgress,
+        loading,
+        errors,
+        // Actions
+        upload,
+        link,
+        unlink,
+        getUrl,
+        getAsset,
+        deleteAsset,
+        restore,
+        getVariants,
+        // Utility methods
+        getAssetsByApp,
+        getAssetsByEntity,
+        getAssetUsageCount,
+        isAssetLinked,
+        // Store management
+        clearErrors,
+        reset
+    };
+};
+exports.useAssets = useAssets;

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

@@ -0,0 +1,50 @@
+interface UseAsyncActionOptions<T> {
+    /** Function to execute */
+    action: () => Promise<T>;
+    /** Success message to display */
+    successMessage?: string;
+    /** Error message to display (or function to get message from error) */
+    errorMessage?: string | ((error: any) => string);
+    /** Callback on success */
+    onSuccess?: (result: T) => void;
+    /** Callback on error */
+    onError?: (error: any) => void;
+    /** Show loading toast */
+    showLoadingToast?: boolean;
+    /** Loading message */
+    loadingMessage?: string;
+}
+interface UseAsyncActionReturn<T> {
+    /** Execute the action */
+    execute: () => Promise<T | undefined>;
+    /** Whether the action is currently executing */
+    isLoading: boolean;
+    /** The last error that occurred */
+    error: Error | null;
+    /** Reset the error state */
+    resetError: () => void;
+}
+/**
+ * Hook for handling async actions with loading state, error handling, and toast notifications.
+ * Reduces boilerplate for common patterns like try-catch with toast feedback.
+ *
+ * @example
+ * const { execute, isLoading } = useAsyncAction({
+ *   action: () => api.saveSettings(settings),
+ *   successMessage: 'Settings saved!',
+ *   errorMessage: 'Failed to save settings',
+ * });
+ *
+ * <Button onPress={execute} disabled={isLoading}>Save</Button>
+ */
+export declare function useAsyncAction<T = void>(options: UseAsyncActionOptions<T>): UseAsyncActionReturn<T>;
+/**
+ * Simplified version that just executes an async action with toast feedback.
+ * Useful for one-off actions.
+ */
+export declare function executeWithToast<T>(action: () => Promise<T>, options?: {
+    successMessage?: string;
+    errorMessage?: string;
+    loadingMessage?: string;
+}): Promise<T | undefined>;
+export default useAsyncAction;

package/src/ui/hooks/useAsyncAction.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAsyncAction = useAsyncAction;
+exports.executeWithToast = executeWithToast;
+const react_1 = require("react");
+const sonner_1 = require("../../lib/sonner");
+/**
+ * Hook for handling async actions with loading state, error handling, and toast notifications.
+ * Reduces boilerplate for common patterns like try-catch with toast feedback.
+ *
+ * @example
+ * const { execute, isLoading } = useAsyncAction({
+ *   action: () => api.saveSettings(settings),
+ *   successMessage: 'Settings saved!',
+ *   errorMessage: 'Failed to save settings',
+ * });
+ *
+ * <Button onPress={execute} disabled={isLoading}>Save</Button>
+ */
+function useAsyncAction(options) {
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const execute = (0, react_1.useCallback)(async () => {
+        const { action, successMessage, errorMessage, onSuccess, onError, showLoadingToast, loadingMessage, } = options;
+        setIsLoading(true);
+        setError(null);
+        if (showLoadingToast && loadingMessage) {
+            sonner_1.toast.loading(loadingMessage);
+        }
+        try {
+            const result = await action();
+            if (successMessage) {
+                sonner_1.toast.success(successMessage);
+            }
+            onSuccess?.(result);
+            return result;
+        }
+        catch (err) {
+            const message = typeof errorMessage === 'function'
+                ? errorMessage(err)
+                : errorMessage || (err instanceof Error ? err.message : null) || 'An error occurred';
+            sonner_1.toast.error(message);
+            setError(err instanceof Error ? err : new Error(message));
+            onError?.(err);
+            return undefined;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [options]);
+    const resetError = (0, react_1.useCallback)(() => {
+        setError(null);
+    }, []);
+    return { execute, isLoading, error, resetError };
+}
+/**
+ * Simplified version that just executes an async action with toast feedback.
+ * Useful for one-off actions.
+ */
+async function executeWithToast(action, options) {
+    const { successMessage, errorMessage, loadingMessage } = options || {};
+    if (loadingMessage) {
+        sonner_1.toast.loading(loadingMessage);
+    }
+    try {
+        const result = await action();
+        if (successMessage) {
+            sonner_1.toast.success(successMessage);
+        }
+        return result;
+    }
+    catch (err) {
+        sonner_1.toast.error(errorMessage || (err instanceof Error ? err.message : null) || 'An error occurred');
+        return undefined;
+    }
+}
+exports.default = useAsyncAction;

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

@@ -0,0 +1,77 @@
+/**
+ * Unified Auth Hook
+ *
+ * Provides a clean, standard interface for authentication across all platforms.
+ * This is the recommended way to access auth state in Oxy apps.
+ *
+ * Usage:
+ * ```tsx
+ * import { useAuth } from '@oxyhq/services';
+ *
+ * function MyComponent() {
+ *   const { user, isAuthenticated, isLoading, signIn, signOut } = useAuth();
+ *
+ *   if (isLoading) return <Loading />;
+ *   if (!isAuthenticated) return <SignInButton onClick={() => signIn()} />;
+ *   return <Welcome user={user} />;
+ * }
+ * ```
+ *
+ * Cross-domain SSO:
+ * - Web: Automatic via FedCM (Chrome 108+, Safari 16.4+)
+ * - Native: Automatic via shared Keychain/Account Manager
+ * - Manual sign-in: signIn() opens popup (web) or auth sheet (native)
+ */
+import { useOxy } from '../context/OxyContext';
+import type { User } from '@oxyhq/core';
+export interface AuthState {
+    /** Current authenticated user, null if not authenticated */
+    user: User | null;
+    /** Whether user is authenticated */
+    isAuthenticated: boolean;
+    /** Whether auth state is being determined (initial load) */
+    isLoading: boolean;
+    /** Whether the auth token is ready for API calls */
+    isReady: boolean;
+    /** Current error message, if any */
+    error: string | null;
+}
+export interface AuthActions {
+    /**
+     * Sign in
+     * - Web: Opens popup to auth.oxy.so (no public key needed)
+     * - Native: Uses cryptographic identity from keychain
+     */
+    signIn: (publicKey?: string) => Promise<User>;
+    /**
+     * Sign out current session
+     */
+    signOut: () => Promise<void>;
+    /**
+     * Sign out all sessions across all devices
+     */
+    signOutAll: () => Promise<void>;
+    /**
+     * Refresh auth state (re-check session validity)
+     */
+    refresh: () => Promise<void>;
+}
+export interface UseAuthReturn extends AuthState, AuthActions {
+    /** Access to full OxyServices instance for advanced usage */
+    oxyServices: ReturnType<typeof useOxy>['oxyServices'];
+    /** Open a bottom sheet screen (e.g. 'AccountSettings', 'FileManagement') */
+    showBottomSheet: ReturnType<typeof useOxy>['showBottomSheet'];
+    /** Open the avatar picker bottom sheet */
+    openAvatarPicker: ReturnType<typeof useOxy>['openAvatarPicker'];
+}
+/**
+ * Unified auth hook for all Oxy apps
+ *
+ * Features:
+ * - Zero config: Just wrap with OxyProvider and use
+ * - Cross-platform: Same API on native and web
+ * - Auto SSO: Web apps automatically check for cross-domain sessions
+ * - Type-safe: Full TypeScript support
+ */
+export declare function useAuth(): UseAuthReturn;
+export { useOxy } from '../context/OxyContext';

package/src/ui/hooks/useAuth.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Unified Auth Hook
+ *
+ * Provides a clean, standard interface for authentication across all platforms.
+ * This is the recommended way to access auth state in Oxy apps.
+ *
+ * Usage:
+ * ```tsx
+ * import { useAuth } from '@oxyhq/services';
+ *
+ * function MyComponent() {
+ *   const { user, isAuthenticated, isLoading, signIn, signOut } = useAuth();
+ *
+ *   if (isLoading) return <Loading />;
+ *   if (!isAuthenticated) return <SignInButton onClick={() => signIn()} />;
+ *   return <Welcome user={user} />;
+ * }
+ * ```
+ *
+ * Cross-domain SSO:
+ * - Web: Automatic via FedCM (Chrome 108+, Safari 16.4+)
+ * - Native: Automatic via shared Keychain/Account Manager
+ * - Manual sign-in: signIn() opens popup (web) or auth sheet (native)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOxy = void 0;
+exports.useAuth = useAuth;
+const react_1 = require("react");
+const OxyContext_1 = require("../context/OxyContext");
+const useWebSSO_1 = require("./useWebSSO");
+/**
+ * Unified auth hook for all Oxy apps
+ *
+ * Features:
+ * - Zero config: Just wrap with OxyProvider and use
+ * - Cross-platform: Same API on native and web
+ * - Auto SSO: Web apps automatically check for cross-domain sessions
+ * - Type-safe: Full TypeScript support
+ */
+function useAuth() {
+    const { user, isAuthenticated, isLoading, isTokenReady, error, signIn: oxySignIn, handlePopupSession, logout, logoutAll, refreshSessions, oxyServices, hasIdentity, getPublicKey, showBottomSheet, openAvatarPicker, } = (0, OxyContext_1.useOxy)();
+    const signIn = (0, react_1.useCallback)(async (publicKey) => {
+        // Check if we're on the identity provider itself (auth.oxy.so)
+        // Only auth.oxy.so has local login forms - accounts.oxy.so is a client app
+        const isIdentityProvider = (0, useWebSSO_1.isWebBrowser)() &&
+            window.location.hostname === 'auth.oxy.so';
+        // Web (not on IdP): Use popup-based authentication
+        // We go straight to popup to preserve the "user gesture" (click event)
+        // FedCM silent SSO already runs on page load via useWebSSO
+        // If user is clicking "Sign In", they need interactive auth NOW
+        if ((0, useWebSSO_1.isWebBrowser)() && !publicKey && !isIdentityProvider) {
+            try {
+                const popupSession = await oxyServices.signInWithPopup?.();
+                if (popupSession?.user) {
+                    // The popup auth flow fetches full user data, so the session user
+                    // contains full User fields even though the base type is MinimalUserData.
+                    // Cast to the expected shape for handlePopupSession.
+                    const sessionWithUser = {
+                        ...popupSession,
+                        user: popupSession.user,
+                    };
+                    await handlePopupSession(sessionWithUser);
+                    return sessionWithUser.user;
+                }
+                throw new Error('Sign-in failed. Please try again.');
+            }
+            catch (popupError) {
+                if (popupError instanceof Error && popupError.message.includes('blocked')) {
+                    throw new Error('Popup blocked. Please allow popups for this site.');
+                }
+                throw popupError;
+            }
+        }
+        // Native: Use cryptographic identity
+        // If public key provided, use it directly
+        if (publicKey) {
+            return oxySignIn(publicKey);
+        }
+        // Try to get existing identity
+        const hasExisting = await hasIdentity();
+        if (hasExisting) {
+            const existingKey = await getPublicKey();
+            if (existingKey) {
+                return oxySignIn(existingKey);
+            }
+        }
+        // No identity - show auth UI
+        if (showBottomSheet) {
+            showBottomSheet('OxyAuth');
+            // Return a promise that resolves when auth completes
+            return new Promise((_, reject) => {
+                reject(new Error('Please complete sign-in in the auth sheet'));
+            });
+        }
+        // Web fallback: navigate to login page on auth domain
+        if ((0, useWebSSO_1.isWebBrowser)()) {
+            const loginUrl = window.location.hostname.includes('oxy.so')
+                ? '/login'
+                : 'https://accounts.oxy.so/login';
+            window.location.href = loginUrl;
+            return new Promise(() => { }); // Never resolves, page will redirect
+        }
+        throw new Error('No authentication method available');
+    }, [oxySignIn, hasIdentity, getPublicKey, showBottomSheet, oxyServices, handlePopupSession]);
+    const signOut = (0, react_1.useCallback)(async () => {
+        await logout();
+    }, [logout]);
+    const signOutAll = (0, react_1.useCallback)(async () => {
+        await logoutAll();
+    }, [logoutAll]);
+    const refresh = (0, react_1.useCallback)(async () => {
+        await refreshSessions();
+    }, [refreshSessions]);
+    return {
+        // State
+        user,
+        isAuthenticated,
+        isLoading,
+        isReady: isTokenReady,
+        error,
+        // Actions
+        signIn,
+        signOut,
+        signOutAll,
+        refresh,
+        // Advanced
+        oxyServices,
+        showBottomSheet,
+        openAvatarPicker,
+    };
+}
+// Re-export useOxy for backward compatibility and advanced usage
+var OxyContext_2 = require("../context/OxyContext");
+Object.defineProperty(exports, "useOxy", { enumerable: true, get: function () { return OxyContext_2.useOxy; } });

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

@@ -0,0 +1,24 @@
+/**
+ * Avatar Picker Hook
+ *
+ * Extracts avatar selection logic from OxyContext for better modularity.
+ * Opens the FileManagement bottom sheet in select mode for image files,
+ * then updates the user's profile avatar.
+ */
+import type { OxyServices } from '@oxyhq/core';
+import type { QueryClient } from '@tanstack/react-query';
+import type { RouteName } from '../navigation/routes';
+interface UseAvatarPickerOptions {
+    oxyServices: OxyServices;
+    currentLanguage: string | null | undefined;
+    activeSessionId: string | null;
+    queryClient: QueryClient;
+    showBottomSheet: (config: {
+        screen: RouteName;
+        props?: Record<string, unknown>;
+    }) => void;
+}
+export declare function useAvatarPicker({ oxyServices, currentLanguage, activeSessionId, queryClient, showBottomSheet, }: UseAvatarPickerOptions): {
+    openAvatarPicker: () => void;
+};
+export {};

package/src/ui/hooks/useAvatarPicker.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Avatar Picker Hook
+ *
+ * Extracts avatar selection logic from OxyContext for better modularity.
+ * Opens the FileManagement bottom sheet in select mode for image files,
+ * then updates the user's profile avatar.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAvatarPicker = useAvatarPicker;
+const react_1 = require("react");
+const core_1 = require("@oxyhq/core");
+const sonner_1 = require("../../lib/sonner");
+const core_2 = require("@oxyhq/core");
+const avatarUtils_1 = require("../utils/avatarUtils");
+function useAvatarPicker({ oxyServices, currentLanguage, activeSessionId, queryClient, showBottomSheet, }) {
+    const openAvatarPicker = (0, react_1.useCallback)(() => {
+        showBottomSheet({
+            screen: 'FileManagement',
+            props: {
+                selectMode: true,
+                multiSelect: false,
+                disabledMimeTypes: ['video/', 'audio/', 'application/pdf'],
+                afterSelect: 'none',
+                onSelect: async (file) => {
+                    if (!file.contentType.startsWith('image/')) {
+                        sonner_1.toast.error((0, core_1.translate)(currentLanguage ?? undefined, 'editProfile.toasts.selectImage') || 'Please select an image file');
+                        return;
+                    }
+                    try {
+                        await (0, core_2.updateAvatarVisibility)(file.id, oxyServices, 'OxyContext');
+                        await (0, avatarUtils_1.updateProfileWithAvatar)({ avatar: file.id }, oxyServices, activeSessionId, queryClient);
+                        sonner_1.toast.success((0, core_1.translate)(currentLanguage ?? undefined, 'editProfile.toasts.avatarUpdated') || 'Avatar updated');
+                    }
+                    catch (e) {
+                        const message = e instanceof Error ? e.message : undefined;
+                        sonner_1.toast.error(message || (0, core_1.translate)(currentLanguage ?? undefined, 'editProfile.toasts.updateAvatarFailed') || 'Failed to update avatar');
+                    }
+                },
+            },
+        });
+    }, [oxyServices, currentLanguage, showBottomSheet, activeSessionId, queryClient]);
+    return { openAvatarPicker };
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Hook to get the current color scheme (theme).
+ * Returns the resolved theme from ThemeContext if available, otherwise falls back to React Native's useColorScheme.
+ *
+ * Always calls hooks in the same order to maintain React hook rules.
+ */
+export declare function useColorScheme(): 'light' | 'dark';

package/src/ui/hooks/useColorScheme.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useColorScheme = useColorScheme;
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const ThemeContext_1 = require("../context/ThemeContext");
+/**
+ * Hook to get the current color scheme (theme).
+ * Returns the resolved theme from ThemeContext if available, otherwise falls back to React Native's useColorScheme.
+ *
+ * Always calls hooks in the same order to maintain React hook rules.
+ */
+function useColorScheme() {
+    // Always call hooks in the same order - never conditionally
+    const rnColorScheme = (0, react_native_1.useColorScheme)();
+    const themeContext = (0, react_1.useContext)(ThemeContext_1.ThemeContext);
+    // If ThemeContext is available, use it; otherwise fall back to React Native's color scheme
+    if (themeContext?.resolvedTheme) {
+        return themeContext.resolvedTheme;
+    }
+    // Fall back to React Native's color scheme detection
+    return (rnColorScheme ?? 'light');
+}

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

@@ -0,0 +1,26 @@
+import type { ApiError } from '@oxyhq/core';
+import type { OxyServices } from '@oxyhq/core';
+export interface UseDeviceManagementOptions {
+    oxyServices: OxyServices;
+    activeSessionId: string | null;
+    onError?: (error: ApiError) => void;
+    clearSessionState: () => Promise<void>;
+    logger?: (message: string, error?: unknown) => void;
+}
+export interface UseDeviceManagementResult {
+    getDeviceSessions: () => Promise<Array<{
+        sessionId: string;
+        deviceId: string;
+        deviceName?: string;
+        lastActive?: string;
+        expiresAt?: string;
+    }>>;
+    logoutAllDeviceSessions: () => Promise<void>;
+    updateDeviceName: (deviceName: string) => Promise<void>;
+}
+/**
+ * Provide device session management helpers tied to the current active session.
+ *
+ * @param options - Device management configuration
+ */
+export declare const useDeviceManagement: ({ oxyServices, activeSessionId, onError, clearSessionState, logger, }: UseDeviceManagementOptions) => UseDeviceManagementResult;