@oxyhq/auth 1.0.0

package/dist/types/hooks/mutations/mutationFactory.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Mutation Factory - Creates standardized mutations with optimistic updates
+ *
+ * This factory reduces boilerplate code for mutations that follow the common pattern:
+ * 1. Cancel outgoing queries
+ * 2. Snapshot previous data
+ * 3. Apply optimistic update
+ * 4. On error: rollback and show toast
+ * 5. On success: update cache, stores, and invalidate queries
+ */
+import { QueryClient, UseMutationOptions } from '@tanstack/react-query';
+import type { User } from '@oxyhq/core';
+/**
+ * Configuration for creating a standard profile mutation
+ */
+export interface ProfileMutationConfig<TData, TVariables> {
+    /** The mutation function that makes the API call */
+    mutationFn: (variables: TVariables) => Promise<TData>;
+    /** Query keys to cancel before mutation */
+    cancelQueryKeys?: unknown[][];
+    /** Function to apply optimistic update to the user data */
+    optimisticUpdate?: (previousUser: User, variables: TVariables) => Partial<User>;
+    /** Error message to show on failure */
+    errorMessage?: string | ((error: Error) => string);
+    /** Success message to show (optional) */
+    successMessage?: string;
+    /** Whether to update authStore on success (default: true) */
+    updateAuthStore?: boolean;
+    /** Whether to invalidate user queries on success (default: true) */
+    invalidateUserQueries?: boolean;
+    /** Whether to invalidate account queries on success (default: true) */
+    invalidateAccountQueries?: boolean;
+    /** Custom onSuccess handler */
+    onSuccess?: (data: TData, variables: TVariables, queryClient: QueryClient) => void;
+}
+/**
+ * Creates a standard profile mutation with optimistic updates
+ *
+ * @example
+ * ```ts
+ * const updateProfile = createProfileMutation({
+ *   mutationFn: (updates) => oxyServices.updateProfile(updates),
+ *   optimisticUpdate: (user, updates) => updates,
+ *   errorMessage: 'Failed to update profile',
+ * });
+ * ```
+ */
+export declare function createProfileMutation<TVariables>(config: ProfileMutationConfig<User, TVariables>, queryClient: QueryClient, activeSessionId: string | null): UseMutationOptions<User, Error, TVariables, {
+    previousUser?: User;
+}>;
+/**
+ * Configuration for creating a generic mutation (non-profile)
+ */
+export interface GenericMutationConfig<TData, TVariables, TContext> {
+    /** The mutation function */
+    mutationFn: (variables: TVariables) => Promise<TData>;
+    /** Query key for optimistic data */
+    queryKey: unknown[];
+    /** Function to create optimistic data */
+    optimisticData?: (previous: TData | undefined, variables: TVariables) => TData;
+    /** Error message */
+    errorMessage?: string;
+    /** Success message */
+    successMessage?: string;
+    /** Additional queries to invalidate on success */
+    invalidateQueries?: unknown[][];
+}
+/**
+ * Creates a generic mutation with optimistic updates
+ */
+export declare function createGenericMutation<TData, TVariables>(config: GenericMutationConfig<TData, TVariables, {
+    previous?: TData;
+}>, queryClient: QueryClient): UseMutationOptions<TData, Error, TVariables, {
+    previous?: TData;
+}>;

package/dist/types/hooks/mutations/useAccountMutations.d.ts

@@ -0,0 +1,68 @@
+import type { User } from '@oxyhq/core';
+/**
+ * Update user profile with optimistic updates and offline queue support
+ */
+export declare const useUpdateProfile: () => import("@tanstack/react-query").UseMutationResult<User, Error, Partial<User>, {
+    previousUser: User | undefined;
+}>;
+/**
+ * Upload avatar with progress tracking and offline queue support
+ */
+export declare const useUploadAvatar: () => import("@tanstack/react-query").UseMutationResult<User, Error, {
+    uri: string;
+    type?: string;
+    name?: string;
+    size?: number;
+}, {
+    previousUser: User | undefined;
+}>;
+/**
+ * Update account settings
+ */
+export declare const useUpdateAccountSettings: () => import("@tanstack/react-query").UseMutationResult<any, Error, Record<string, any>, {
+    previousUser: User | undefined;
+}>;
+/**
+ * Update privacy settings with optimistic updates and authentication handling
+ */
+export declare const useUpdatePrivacySettings: () => import("@tanstack/react-query").UseMutationResult<Record<string, unknown>, Error, {
+    settings: Record<string, any>;
+    userId?: string;
+}, {
+    previousPrivacySettings: unknown;
+    previousUser: User | undefined;
+} | undefined>;
+/** Uploaded file data structure from API */
+interface UploadedFile {
+    id: string;
+    originalName?: string;
+    sha256?: string;
+    mime?: string;
+    size?: number;
+    createdAt?: string;
+    metadata?: Record<string, unknown>;
+    variants?: Array<{
+        type: string;
+        key: string;
+        width?: number;
+        height?: number;
+        readyAt?: string;
+        metadata?: Record<string, unknown>;
+    }>;
+}
+/** Upload result type that supports both single file and batch responses */
+interface UploadResult {
+    file?: UploadedFile;
+    files?: UploadedFile[];
+    id?: string;
+}
+/**
+ * Upload file with authentication handling and progress tracking
+ */
+export declare const useUploadFile: () => import("@tanstack/react-query").UseMutationResult<UploadResult, Error, {
+    file: File;
+    visibility?: "private" | "public" | "unlisted";
+    metadata?: Record<string, any>;
+    onProgress?: (progress: number) => void;
+}, unknown>;
+export {};

package/dist/types/hooks/mutations/useServicesMutations.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Switch active session
+ */
+export declare const useSwitchSession: () => import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+/**
+ * Logout from a session
+ */
+export declare const useLogoutSession: () => import("@tanstack/react-query").UseMutationResult<string, Error, string | undefined, {
+    previousSessions: unknown;
+}>;
+/**
+ * Logout from all sessions
+ */
+export declare const useLogoutAll: () => import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+/**
+ * Update device name
+ */
+export declare const useUpdateDeviceName: () => import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
+/**
+ * Remove a device
+ */
+export declare const useRemoveDevice: () => import("@tanstack/react-query").UseMutationResult<string, Error, string, unknown>;

package/dist/types/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/dist/types/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/dist/types/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<unknown, Error>;

package/dist/types/hooks/queries/useSecurityQueries.d.ts

@@ -0,0 +1,14 @@
+import type { SecurityActivity, 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/dist/types/hooks/queries/useServicesQueries.d.ts

@@ -0,0 +1,31 @@
+import type { ClientSession } from '@oxyhq/core';
+/**
+ * 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<unknown, Error>;
+/**
+ * Get security information
+ */
+export declare const useSecurityInfo: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;

package/dist/types/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/dist/types/hooks/useAssets.d.ts

@@ -0,0 +1,34 @@
+import { OxyServices } from '@oxyhq/core';
+import { Asset, AssetUploadProgress } 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/dist/types/hooks/useFileDownloadUrl.d.ts

@@ -0,0 +1,18 @@
+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 `getFileDownloadUrlAsync` and falls back to the synchronous
+ * `getFileDownloadUrl` helper if the async call fails.
+ */
+export declare const useFileDownloadUrl: (fileId?: string | null, options?: UseFileDownloadUrlOptions) => UseFileDownloadUrlResult;

package/dist/types/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/dist/types/hooks/useFollow.d.ts

@@ -0,0 +1,61 @@
+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;
+};
+export declare const useFollowerCounts: (userId: string) => {
+    followerCount: number;
+    followingCount: number;
+    isLoadingCounts: boolean;
+    fetchUserCounts: () => Promise<void>;
+    setFollowerCount: (count: number) => void;
+    setFollowingCount: (count: number) => void;
+};

package/dist/types/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/dist/types/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/dist/types/hooks/useSessionSocket.d.ts

@@ -0,0 +1,13 @@
+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;
+    onRemoteSignOut?: () => void;
+    onSessionRemoved?: (sessionId: string) => void;
+}
+export declare function useSessionSocket({ userId, activeSessionId, currentDeviceId, refreshSessions, logout, clearSessionState, baseURL, onRemoteSignOut, onSessionRemoved }: UseSessionSocketProps): void;
+export {};

package/dist/types/hooks/useWebSSO.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Web SSO Hook
+ *
+ * Handles cross-domain SSO for web apps using FedCM (Federated Credential Management).
+ *
+ * FedCM is the modern, privacy-preserving standard for cross-domain identity federation.
+ * It works across completely different TLDs (alia.onl, mention.earth, homiio.com, etc.)
+ * without relying on third-party cookies.
+ *
+ * For browsers without FedCM support, users will need to click a sign-in button
+ * which triggers a popup-based authentication flow.
+ *
+ * This is called automatically by OxyContext on web platforms.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/FedCM_API
+ */
+import type { OxyServices } from '@oxyhq/core';
+import type { SessionLoginResponse } from '@oxyhq/core';
+interface UseWebSSOOptions {
+    oxyServices: OxyServices;
+    onSessionFound: (session: SessionLoginResponse) => Promise<void>;
+    onSSOUnavailable?: () => void;
+    onError?: (error: Error) => void;
+    enabled?: boolean;
+}
+interface UseWebSSOResult {
+    /** Manually trigger SSO check */
+    checkSSO: () => Promise<SessionLoginResponse | null>;
+    /** Trigger interactive FedCM sign-in (shows browser UI) */
+    signInWithFedCM: () => Promise<SessionLoginResponse | null>;
+    /** Whether SSO check is in progress */
+    isChecking: boolean;
+    /** Whether FedCM is supported in this browser */
+    isFedCMSupported: boolean;
+}
+/**
+ * Check if we're running in a web browser environment (not React Native)
+ */
+declare function isWebBrowser(): boolean;
+/**
+ * Hook for automatic cross-domain web SSO
+ *
+ * Uses FedCM (Federated Credential Management) - the modern browser-native
+ * identity federation API. This is the same technology that powers
+ * Google's cross-domain SSO (YouTube, Gmail, Maps, etc.).
+ *
+ * Key benefits:
+ * - Works across different TLDs (alia.onl ↔ mention.earth ↔ homiio.com)
+ * - No third-party cookies required
+ * - Privacy-preserving (browser mediates identity, IdP can't track)
+ * - Automatic silent sign-in after initial authentication
+ *
+ * For browsers without FedCM (Firefox, older browsers), automatic SSO
+ * is not possible. Users will see a sign-in button instead.
+ */
+export declare function useWebSSO({ oxyServices, onSessionFound, onSSOUnavailable, onError, enabled, }: UseWebSSOOptions): UseWebSSOResult;
+export { isWebBrowser };

package/dist/types/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @oxyhq/auth — OxyHQ Web Authentication SDK
+ *
+ * Headless authentication for React web apps (Next.js, Vite, CRA).
+ * Zero React Native / Expo dependencies.
+ *
+ * @example
+ * ```tsx
+ * import { WebOxyProvider, useAuth } from '@oxyhq/auth';
+ *
+ * function App() {
+ *   return (
+ *     <WebOxyProvider baseURL="https://api.oxy.so">
+ *       <YourApp />
+ *     </WebOxyProvider>
+ *   );
+ * }
+ *
+ * function YourApp() {
+ *   const { user, isAuthenticated, signIn, signOut } = useAuth();
+ *   // ...
+ * }
+ * ```
+ */
+export { WebOxyProvider, useWebOxy, useAuth } from './WebOxyProvider';
+export type { WebOxyProviderProps, WebAuthState, WebAuthActions, WebOxyContextValue, } from './WebOxyProvider';
+export { useAuthStore } from './stores/authStore';
+export { useAssetStore, useAssets as useAssetsStore, useAsset, useUploadProgress, useAssetLoading, useAssetErrors, useAssetsByApp, useAssetsByEntity, useAssetUsageCount, useIsAssetLinked, } from './stores/assetStore';
+export { useUserProfile, useUserProfiles, useCurrentUser, useUserById, useUserByUsername, useUsersBySessions, usePrivacySettings, useSessions, useSession, useDeviceSessions, useUserDevices, useSecurityInfo, useSecurityActivity, useRecentSecurityActivity, } from './hooks/queries';
+export { useUpdateProfile, useUploadAvatar, useUpdateAccountSettings, useUpdatePrivacySettings, useUploadFile, useSwitchSession, useLogoutSession, useLogoutAll, useUpdateDeviceName, useRemoveDevice, } from './hooks/mutations';
+export { createProfileMutation, createGenericMutation, } from './hooks/mutations/mutationFactory';
+export type { ProfileMutationConfig, GenericMutationConfig, } from './hooks/mutations/mutationFactory';
+export { useSessionSocket } from './hooks/useSessionSocket';
+export { useAssets, setOxyAssetInstance } from './hooks/useAssets';
+export { useFileDownloadUrl, setOxyFileUrlInstance } from './hooks/useFileDownloadUrl';
+export { useFollow, useFollowerCounts } from './hooks/useFollow';
+export { useFileFiltering } from './hooks/useFileFiltering';
+export type { ViewMode, SortBy, SortOrder } from './hooks/useFileFiltering';
+export { ensureValidToken, withAuthErrorHandling, authenticatedApiCall, isAuthenticationError, SessionSyncRequiredError, AuthenticationFailedError, } from './utils/authHelpers';
+export type { HandleApiErrorOptions } from './utils/authHelpers';
+export { handleAuthError, isInvalidSessionError, isTimeoutOrNetworkError, extractErrorMessage, } from './utils/errorHandlers';
+export type { HandleAuthErrorOptions } from './utils/errorHandlers';
+export { OxyServices, CrossDomainAuth, AuthManager, createAuthManager, createCrossDomainAuth, } from '@oxyhq/core';
+export type { User, LoginResponse, ApiError, SessionLoginResponse, ClientSession, MinimalUserData, OxyConfig, StorageAdapter, AuthStateChangeCallback, AuthMethod, AuthManagerConfig, CrossDomainAuthOptions, } from '@oxyhq/core';
+import { WebOxyProvider as _WebOxyProvider } from './WebOxyProvider';
+export default _WebOxyProvider;