@oxyhq/services 6.9.13 → 6.9.15

package/lib/typescript/ui/hooks/queries/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Query Hooks
+ *
+ * TanStack Query hooks for fetching Oxy services data.
+ * All hooks follow the same pattern with optional `enabled` parameter.
+ */
+export { useUserProfile, useUserProfiles, useCurrentUser, useUserById, useUserByUsername, useUsersBySessions, usePrivacySettings, } from './useAccountQueries';
+export { useSessions, useSession, useDeviceSessions, useUserDevices, useSecurityInfo, } from './useServicesQueries';
+export { useSecurityActivity, useRecentSecurityActivity, } from './useSecurityQueries';
+export { queryKeys, invalidateAccountQueries, invalidateUserQueries, invalidateSessionQueries } from './queryKeys';

package/lib/typescript/ui/hooks/queries/queryKeys.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Centralized query keys for TanStack Query
+ *
+ * Following best practices:
+ * - Use arrays for hierarchical keys
+ * - Include all parameters in the key
+ * - Use consistent naming conventions
+ */
+export declare const queryKeys: {
+    readonly accounts: {
+        readonly all: readonly ["accounts"];
+        readonly lists: () => readonly ["accounts", "list"];
+        readonly list: (sessionIds: string[]) => readonly ["accounts", "list", string[]];
+        readonly details: () => readonly ["accounts", "detail"];
+        readonly detail: (sessionId: string) => readonly ["accounts", "detail", string];
+        readonly current: () => readonly ["accounts", "current"];
+        readonly settings: () => readonly ["accounts", "settings"];
+    };
+    readonly users: {
+        readonly all: readonly ["users"];
+        readonly lists: () => readonly ["users", "list"];
+        readonly list: (userIds: string[]) => readonly ["users", "list", string[]];
+        readonly details: () => readonly ["users", "detail"];
+        readonly detail: (userId: string) => readonly ["users", "detail", string];
+        readonly profile: (sessionId: string) => readonly ["users", "detail", string, "profile"];
+    };
+    readonly sessions: {
+        readonly all: readonly ["sessions"];
+        readonly lists: () => readonly ["sessions", "list"];
+        readonly list: (userId?: string) => readonly ["sessions", "list", string | undefined];
+        readonly details: () => readonly ["sessions", "detail"];
+        readonly detail: (sessionId: string) => readonly ["sessions", "detail", string];
+        readonly active: () => readonly ["sessions", "active"];
+        readonly device: (deviceId: string) => readonly ["sessions", "device", string];
+    };
+    readonly devices: {
+        readonly all: readonly ["devices"];
+        readonly lists: () => readonly ["devices", "list"];
+        readonly list: (userId?: string) => readonly ["devices", "list", string | undefined];
+        readonly details: () => readonly ["devices", "detail"];
+        readonly detail: (deviceId: string) => readonly ["devices", "detail", string];
+    };
+    readonly privacy: {
+        readonly all: readonly ["privacy"];
+        readonly settings: (userId?: string) => readonly ["privacy", "settings", string];
+    };
+    readonly security: {
+        readonly all: readonly ["security"];
+        readonly activity: (limit?: number, offset?: number, eventType?: string) => readonly ["security", "activity", number | undefined, number | undefined, string | undefined];
+        readonly recent: (limit: number) => readonly ["security", "recent", number];
+    };
+};
+/**
+ * Helper to invalidate all account-related queries
+ */
+export declare const invalidateAccountQueries: (queryClient: any) => void;
+/**
+ * Helper to invalidate all user-related queries
+ */
+export declare const invalidateUserQueries: (queryClient: any) => void;
+/**
+ * Helper to invalidate all session-related queries
+ */
+export declare const invalidateSessionQueries: (queryClient: any) => void;

package/lib/typescript/ui/hooks/queries/useAccountQueries.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Get user profile by session ID
+ */
+export declare const useUserProfile: (sessionId: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get multiple user profiles by session IDs (batch query)
+ */
+export declare const useUserProfiles: (sessionIds: string[], options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>[];
+/**
+ * Get current authenticated user
+ */
+export declare const useCurrentUser: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get user by ID
+ */
+export declare const useUserById: (userId: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get user profile by username
+ */
+export declare const useUserByUsername: (username: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Batch get users by session IDs (optimized single API call)
+ */
+export declare const useUsersBySessions: (sessionIds: string[], options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get privacy settings for a user
+ */
+export declare const usePrivacySettings: (userId?: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;

package/lib/typescript/ui/hooks/queries/useSecurityQueries.d.ts

@@ -0,0 +1,14 @@
+import type { SecurityEventType } from '@oxyhq/core';
+/**
+ * Get user's security activity with pagination
+ */
+export declare const useSecurityActivity: (options?: {
+    limit?: number;
+    offset?: number;
+    eventType?: SecurityEventType;
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get recent security activity (convenience hook)
+ */
+export declare const useRecentSecurityActivity: (limit?: number) => import("@tanstack/react-query").UseQueryResult<SecurityActivity[], Error>;

package/lib/typescript/ui/hooks/queries/useServicesQueries.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Get all active sessions for the current user
+ */
+export declare const useSessions: (userId?: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<ClientSession[], Error>;
+/**
+ * Get specific session by ID
+ */
+export declare const useSession: (sessionId: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<ClientSession, Error>;
+/**
+ * Get device sessions for the current active session
+ */
+export declare const useDeviceSessions: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get user devices
+ */
+export declare const useUserDevices: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get security information
+ */
+export declare const useSecurityInfo: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;

package/lib/typescript/ui/hooks/queryClient.d.ts

@@ -0,0 +1,18 @@
+import { QueryClient } from '@tanstack/react-query';
+import type { StorageInterface } from '../utils/storageHelpers';
+/**
+ * Custom persistence adapter for TanStack Query using our StorageInterface
+ */
+export declare const createPersistenceAdapter: (storage: StorageInterface) => {
+    persistClient: (client: any) => Promise<void>;
+    restoreClient: () => Promise<any>;
+    removeClient: () => Promise<void>;
+};
+/**
+ * Create a QueryClient with offline-first configuration
+ */
+export declare const createQueryClient: (storage?: StorageInterface | null) => QueryClient;
+/**
+ * Clear persisted query cache
+ */
+export declare const clearQueryCache: (storage: StorageInterface) => Promise<void>;

package/lib/typescript/ui/hooks/useAssets.d.ts

@@ -0,0 +1,34 @@
+import type { OxyServices } from '@oxyhq/core';
+import { type Asset } from '@oxyhq/core';
+export declare const setOxyAssetInstance: (instance: OxyServices) => void;
+/**
+ * Hook for managing assets with Zustand store integration
+ */
+export declare const useAssets: () => {
+    assets: Asset[];
+    uploadProgress: Record<string, AssetUploadProgress>;
+    loading: {
+        uploading: boolean;
+        linking: boolean;
+        deleting: boolean;
+    };
+    errors: {
+        upload?: string;
+        link?: string;
+        delete?: string;
+    };
+    upload: (file: File, metadata?: Record<string, any>) => Promise<Asset | null>;
+    link: (assetId: string, app: string, entityType: string, entityId: string) => Promise<void>;
+    unlink: (assetId: string, app: string, entityType: string, entityId: string) => Promise<void>;
+    getUrl: (assetId: string, variant?: string, expiresIn?: number) => Promise<string>;
+    getAsset: (assetId: string) => Promise<Asset>;
+    deleteAsset: (assetId: string, force?: boolean) => Promise<void>;
+    restore: (assetId: string) => Promise<void>;
+    getVariants: (assetId: string) => Promise<any>;
+    getAssetsByApp: (app: string) => Asset[];
+    getAssetsByEntity: (app: string, entityType: string, entityId: string) => Asset[];
+    getAssetUsageCount: (assetId: string) => number;
+    isAssetLinked: (assetId: string, app: string, entityType: string, entityId: string) => boolean;
+    clearErrors: () => void;
+    reset: () => void;
+};

package/lib/typescript/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/lib/typescript/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/lib/typescript/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/lib/typescript/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/lib/typescript/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;

package/lib/typescript/ui/hooks/useFileDownloadUrl.d.ts

@@ -0,0 +1,21 @@
+import { OxyServices } from '@oxyhq/core';
+export declare const setOxyFileUrlInstance: (instance: OxyServices) => void;
+export interface UseFileDownloadUrlOptions {
+    variant?: string;
+    expiresIn?: number;
+}
+export interface UseFileDownloadUrlResult {
+    url: string | null;
+    loading: boolean;
+    error: Error | null;
+}
+/**
+ * Hook to resolve a file's download URL asynchronously.
+ *
+ * Prefers the provided `oxyServices` instance, falls back to the module-level
+ * singleton set via `setOxyFileUrlInstance`.
+ *
+ * Uses `getFileDownloadUrlAsync` first, falling back to the synchronous
+ * `getFileDownloadUrl` if the async call fails.
+ */
+export declare const useFileDownloadUrl: (fileIdOrServices?: string | OxyServices | null, fileIdOrOptions?: string | UseFileDownloadUrlOptions | null, maybeOptions?: UseFileDownloadUrlOptions) => UseFileDownloadUrlResult;

package/lib/typescript/ui/hooks/useFileFiltering.d.ts

@@ -0,0 +1,28 @@
+import type { FileMetadata } from '@oxyhq/core';
+export type ViewMode = 'all' | 'photos' | 'videos' | 'documents' | 'audio';
+export type SortBy = 'date' | 'size' | 'name' | 'type';
+export type SortOrder = 'asc' | 'desc';
+interface UseFileFilteringOptions {
+    files: FileMetadata[];
+    initialViewMode?: ViewMode;
+    initialSortBy?: SortBy;
+    initialSortOrder?: SortOrder;
+}
+interface UseFileFilteringReturn {
+    filteredFiles: FileMetadata[];
+    viewMode: ViewMode;
+    setViewMode: (mode: ViewMode) => void;
+    searchQuery: string;
+    setSearchQuery: (query: string) => void;
+    sortBy: SortBy;
+    setSortBy: (sort: SortBy) => void;
+    sortOrder: SortOrder;
+    setSortOrder: (order: SortOrder) => void;
+    toggleSortOrder: () => void;
+}
+/**
+ * Hook for file filtering, sorting, and search functionality
+ * Extracts common file management logic for reuse across components
+ */
+export declare function useFileFiltering({ files, initialViewMode, initialSortBy, initialSortOrder, }: UseFileFilteringOptions): UseFileFilteringReturn;
+export {};

package/lib/typescript/ui/hooks/useFollow.d.ts

@@ -0,0 +1,92 @@
+import type { OxyServices } from '@oxyhq/core';
+/**
+ * useFollow — Hook for follow state management.
+ *
+ * Performance fixes:
+ * 1. Uses granular Zustand selectors instead of subscribing to the entire store.
+ *    The old `useFollowStore()` caused every component using this hook to re-render
+ *    on ANY store change (any user's follow status, loading state, error, or count).
+ * 2. Callbacks depend on primitive values (userId, isFollowing) not object references,
+ *    so they remain stable across renders.
+ * 3. Store action methods are accessed via getState() in callbacks to avoid
+ *    subscribing to the action functions themselves (they never change but including
+ *    them in selectors would cause unnecessary selector recalculations).
+ */
+export declare const useFollow: (userId?: string | string[]) => {
+    isFollowing: boolean;
+    isLoading: boolean;
+    error: string | null;
+    toggleFollow: () => Promise<void>;
+    setFollowStatus: (following: boolean) => void;
+    fetchStatus: () => Promise<void>;
+    clearError: () => void;
+    followerCount: number | null;
+    followingCount: number | null;
+    isLoadingCounts: boolean;
+    fetchUserCounts: () => Promise<void>;
+    setFollowerCount: (count: number) => void;
+    setFollowingCount: (count: number) => void;
+    followData?: undefined;
+    toggleFollowForUser?: undefined;
+    setFollowStatusForUser?: undefined;
+    fetchStatusForUser?: undefined;
+    fetchAllStatuses?: undefined;
+    clearErrorForUser?: undefined;
+    isAnyLoading?: undefined;
+    hasAnyError?: undefined;
+    allFollowing?: undefined;
+    allNotFollowing?: undefined;
+} | {
+    followData: Record<string, {
+        isFollowing: boolean;
+        isLoading: boolean;
+        error: string | null;
+    }>;
+    toggleFollowForUser: (targetUserId: string) => Promise<void>;
+    setFollowStatusForUser: (targetUserId: string, following: boolean) => void;
+    fetchStatusForUser: (targetUserId: string) => Promise<void>;
+    fetchAllStatuses: () => Promise<void>;
+    clearErrorForUser: (targetUserId: string) => void;
+    isAnyLoading: boolean;
+    hasAnyError: boolean;
+    allFollowing: boolean;
+    allNotFollowing: boolean;
+    isFollowing?: undefined;
+    isLoading?: undefined;
+    error?: undefined;
+    toggleFollow?: undefined;
+    setFollowStatus?: undefined;
+    fetchStatus?: undefined;
+    clearError?: undefined;
+    followerCount?: undefined;
+    followingCount?: undefined;
+    isLoadingCounts?: undefined;
+    fetchUserCounts?: undefined;
+    setFollowerCount?: undefined;
+    setFollowingCount?: undefined;
+};
+/**
+ * useFollowForButton — Lightweight follow hook for FollowButton in list contexts.
+ *
+ * Unlike useFollow, this hook:
+ * - Accepts oxyServices directly (no useOxy() context subscription)
+ * - Only subscribes to the specific user's follow and loading state
+ * - Returns only what FollowButton needs (no counts, no multi-user)
+ */
+export declare const useFollowForButton: (userId: string, oxyServices: OxyServices) => {
+    isFollowing: boolean;
+    isLoading: boolean;
+    error: string | null;
+    toggleFollow: () => Promise<void>;
+    fetchStatus: () => Promise<void>;
+    setFollowStatus: (following: boolean) => void;
+    clearError: () => void;
+};
+export declare const useFollowerCounts: (userId: string) => {
+    followerCount: number;
+    followingCount: number;
+    isLoadingCounts: boolean;
+    fetchUserCounts: () => Promise<void>;
+    setFollowerCount: (count: number) => void;
+    setFollowingCount: (count: number) => void;
+};

package/lib/typescript/ui/hooks/useFollow.types.d.ts

@@ -0,0 +1,32 @@
+export type SingleFollowResult = {
+    isFollowing: boolean;
+    isLoading: boolean;
+    error: string | null;
+    toggleFollow: () => Promise<void>;
+    setFollowStatus: (following: boolean) => void;
+    fetchStatus: () => Promise<void>;
+    clearError: () => void;
+    followerCount: number | null;
+    followingCount: number | null;
+    isLoadingCounts: boolean;
+    fetchUserCounts: () => Promise<void>;
+    setFollowerCount: (count: number) => void;
+    setFollowingCount: (count: number) => void;
+};
+export type MultiFollowResult = {
+    followData: Record<string, {
+        isFollowing: boolean;
+        isLoading: boolean;
+        error: string | null;
+    }>;
+    toggleFollowForUser: (userId: string) => Promise<void>;
+    setFollowStatusForUser: (userId: string, following: boolean) => void;
+    fetchStatusForUser: (userId: string) => Promise<void>;
+    fetchAllStatuses: () => Promise<void>;
+    clearErrorForUser: (userId: string) => void;
+    isAnyLoading: boolean;
+    hasAnyError: boolean;
+    allFollowing: boolean;
+    allNotFollowing: boolean;
+};
+export type UseFollowHook = (userId?: string | string[]) => SingleFollowResult | MultiFollowResult;

package/lib/typescript/ui/hooks/useI18n.d.ts

@@ -0,0 +1,4 @@
+export declare function useI18n(): {
+    t: (key: string, vars?: Record<string, string | number>) => any;
+    locale: string;
+};

package/lib/typescript/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/lib/typescript/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/lib/typescript/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;