@oxyhq/services 5.26.4 → 5.27.0

package/dist/web/types/ui/styles/spacing.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Shared spacing constants for authentication screens
+ * These values ensure consistent vertical spacing across all step components
+ * All gaps between elements (illustration, title, description, textfield, buttons, etc.) use this value
+ */
+export declare const STEP_GAP = 12;
+export declare const STEP_INNER_GAP = 12;
+/**
+ * Re-export screen spacing constants from constants/spacing.ts
+ * This allows importing all spacing constants from a single location
+ */
+export { SCREEN_PADDING_HORIZONTAL, SCREEN_PADDING_VERTICAL, SECTION_GAP, SECTION_GAP_LARGE, COMPONENT_GAP, COMPONENT_GAP_SMALL, HEADER_PADDING_TOP_OVERVIEW, HEADER_PADDING_TOP_SETTINGS, } from '../constants/spacing';
+/**
+ * Reusable stylesheet for step components
+ * NOTE: Layout styles (container, sectionSpacing) removed - all layout is handled by BottomSheetRouter
+ * Step components should NOT use these for layout, only for content-specific styling
+ */
+export declare const stepStyles: {
+    container: {
+        width: "100%";
+        maxWidth: number;
+        alignSelf: "center";
+    };
+    sectionSpacing: {
+        marginBottom: number;
+    };
+    header: {
+        alignItems: "flex-start";
+        width: "100%";
+        gap: number;
+    };
+    title: {
+        textAlign: "left";
+        marginBottom: number;
+        marginTop: number;
+    };
+    subtitle: {
+        textAlign: "left";
+        maxWidth: number;
+        alignSelf: "flex-start";
+        marginBottom: number;
+        marginTop: number;
+    };
+    buttonContainer: {
+        marginTop: number;
+        marginBottom: number;
+    };
+};

package/dist/web/types/ui/styles/theme.d.ts

@@ -0,0 +1,67 @@
+import { type TextStyle } from 'react-native';
+export interface ThemeColors {
+    text: string;
+    background: string;
+    inputBackground: string;
+    placeholder: string;
+    primary: string;
+    border: string;
+    error: string;
+    success: string;
+    warning: string;
+    secondaryText: string;
+}
+export interface Theme {
+    colors: ThemeColors;
+    fonts: {
+        title: TextStyle;
+        body: TextStyle;
+        button: TextStyle;
+        label: TextStyle;
+    };
+}
+export declare const getTheme: (theme: "light" | "dark") => Theme;
+export declare const useThemeColors: (theme: "light" | "dark") => ThemeColors;
+export declare const createCommonStyles: (theme: "light" | "dark") => {
+    container: {
+        backgroundColor: string;
+    };
+    scrollContainer: {
+        padding: number;
+    };
+    input: {
+        height: number;
+        borderRadius: number;
+        paddingHorizontal: number;
+        borderWidth: number;
+        fontSize: number;
+        backgroundColor: string;
+        borderColor: string;
+        color: string;
+    };
+    button: {
+        backgroundColor: string;
+        height: number;
+        borderRadius: number;
+        alignItems: "center";
+        justifyContent: "center";
+        marginTop: number;
+    };
+    buttonText: {
+        fontFamily: string;
+        fontSize: number;
+        fontWeight: "600";
+        color: string;
+    };
+    errorContainer: {
+        backgroundColor: string;
+        padding: number;
+        borderRadius: number;
+        marginBottom: number;
+    };
+    errorText: {
+        fontSize: number;
+        fontWeight: "500";
+        color: string;
+    };
+};

package/dist/web/types/ui/types/fileManagement.d.ts

@@ -0,0 +1,40 @@
+import type { BaseScreenProps } from './navigation';
+import type { FileMetadata } from '../../models/interfaces';
+export type OnConfirmFileSelection = (files: FileMetadata[]) => void;
+export interface FileManagementScreenProps extends BaseScreenProps {
+    userId?: string;
+    containerWidth?: number;
+    selectMode?: boolean;
+    multiSelect?: boolean;
+    onSelect?: (file: FileMetadata) => void;
+    onConfirmSelection?: OnConfirmFileSelection;
+    initialSelectedIds?: string[];
+    maxSelection?: number;
+    disabledMimeTypes?: string[];
+    /**
+     * What to do after a single selection (non-multiSelect) is made.
+     * 'close' (default) will dismiss the bottom sheet via onClose.
+     * 'back' will navigate back to the previous screen (e.g., return to AccountSettings without closing sheet).
+     * 'none' will keep the picker open (caller can manually close or navigate).
+     */
+    afterSelect?: 'close' | 'back' | 'none';
+    allowUploadInSelectMode?: boolean;
+    /**
+     * Default visibility for uploaded files in this screen
+     * Useful for third-party apps that want files to be public (e.g., GIF selector)
+     */
+    defaultVisibility?: 'private' | 'public' | 'unlisted';
+    /**
+     * Link context for tracking file usage by third-party apps
+     * When provided, selected files will be linked to this entity
+     */
+    linkContext?: {
+        app: string;
+        entityType: string;
+        entityId: string;
+        webhookUrl?: string;
+    };
+}
+export type ViewMode = 'all' | 'photos' | 'videos' | 'documents' | 'audio';
+export type SortBy = 'date' | 'size' | 'name' | 'type';
+export type SortOrder = 'asc' | 'desc';

package/dist/web/types/ui/types/navigation.d.ts

@@ -0,0 +1,36 @@
+import type { ReactNode, RefObject } from 'react';
+import type { QueryClient } from '@tanstack/react-query';
+import type { RouteName } from '../navigation/routes';
+export type { RouteName };
+export interface StepController {
+    canGoBack: () => boolean;
+    goBack: () => void;
+}
+export interface BaseScreenProps {
+    navigate?: (screen: RouteName, props?: Record<string, unknown>) => void;
+    goBack?: () => void;
+    onClose?: () => void;
+    onAuthenticated?: (payload?: unknown) => void;
+    theme?: 'light' | 'dark' | string;
+    initialStep?: number;
+    stepControllerRef?: RefObject<StepController | null>;
+    onStepChange?: (currentStep: number, totalSteps: number) => void;
+    currentScreen?: RouteName;
+    scrollTo?: (y: number, animated?: boolean) => void;
+    username?: string;
+    email?: string;
+    password?: string;
+    confirmPassword?: string;
+    userProfile?: unknown;
+    [key: string]: unknown;
+}
+export interface OxyProviderProps {
+    oxyServices?: unknown;
+    children?: ReactNode;
+    onAuthStateChange?: (user: unknown) => void;
+    storageKeyPrefix?: string;
+    baseURL?: string;
+    authWebUrl?: string;
+    authRedirectUri?: string;
+    queryClient?: QueryClient;
+}

package/dist/web/types/ui/utils/authHelpers.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Authentication helper utilities to reduce code duplication across hooks and utilities.
+ * These functions handle common token validation and authentication error patterns.
+ */
+import type { OxyServices } from '../../core';
+/**
+ * Error thrown when session sync is required
+ */
+export declare class SessionSyncRequiredError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Error thrown when authentication fails
+ */
+export declare class AuthenticationFailedError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Ensures a valid token exists before making authenticated API calls.
+ * If no valid token exists and an active session ID is available,
+ * attempts to refresh the token using the session.
+ *
+ * @param oxyServices - The OxyServices instance
+ * @param activeSessionId - The active session ID (if available)
+ * @throws {SessionSyncRequiredError} If the session needs to be synced (offline session)
+ * @throws {Error} If token refresh fails for other reasons
+ *
+ * @example
+ * ```ts
+ * // In a mutation or query function:
+ * await ensureValidToken(oxyServices, activeSessionId);
+ * return await oxyServices.updateProfile(updates);
+ * ```
+ */
+export declare function ensureValidToken(oxyServices: OxyServices, activeSessionId: string | null | undefined): Promise<void>;
+/**
+ * Options for handling API authentication errors
+ */
+export interface HandleApiErrorOptions {
+    /** Optional callback to attempt session sync and retry */
+    syncSession?: () => Promise<unknown>;
+    /** The active session ID for retry attempts */
+    activeSessionId?: string | null;
+    /** The OxyServices instance for retry attempts */
+    oxyServices?: OxyServices;
+}
+/**
+ * Checks if an error is an authentication error (401 or auth-related message)
+ *
+ * @param error - The error to check
+ * @returns True if the error is an authentication error
+ */
+export declare function isAuthenticationError(error: unknown): boolean;
+/**
+ * Wraps an API call with authentication error handling.
+ * If an authentication error occurs, it can optionally attempt to sync the session and retry.
+ *
+ * @param apiCall - The API call function to execute
+ * @param options - Optional error handling configuration
+ * @returns The result of the API call
+ * @throws {AuthenticationFailedError} If authentication fails and cannot be recovered
+ * @throws {Error} If the API call fails for non-auth reasons
+ *
+ * @example
+ * ```ts
+ * // Simple usage:
+ * const result = await withAuthErrorHandling(
+ *   () => oxyServices.updateProfile(updates)
+ * );
+ *
+ * // With retry on auth failure:
+ * const result = await withAuthErrorHandling(
+ *   () => oxyServices.updateProfile(updates),
+ *   { syncSession, activeSessionId, oxyServices }
+ * );
+ * ```
+ */
+export declare function withAuthErrorHandling<T>(apiCall: () => Promise<T>, options?: HandleApiErrorOptions): Promise<T>;
+/**
+ * Combines token validation and auth error handling for a complete authenticated API call.
+ * This is the recommended helper for most authenticated API operations.
+ *
+ * @param oxyServices - The OxyServices instance
+ * @param activeSessionId - The active session ID
+ * @param apiCall - The API call function to execute
+ * @param syncSession - Optional callback to sync session on auth failure
+ * @returns The result of the API call
+ *
+ * @example
+ * ```ts
+ * return await authenticatedApiCall(
+ *   oxyServices,
+ *   activeSessionId,
+ *   () => oxyServices.updateProfile(updates)
+ * );
+ * ```
+ */
+export declare function authenticatedApiCall<T>(oxyServices: OxyServices, activeSessionId: string | null | undefined, apiCall: () => Promise<T>, syncSession?: () => Promise<unknown>): Promise<T>;

package/dist/web/types/ui/utils/avatarUtils.d.ts

@@ -0,0 +1,33 @@
+import type { OxyServices } from '../../core';
+import type { User } from '../../models/interfaces';
+import { QueryClient } from '@tanstack/react-query';
+/**
+ * Updates file visibility to public for avatar use.
+ * Handles errors gracefully, only logging non-404 errors.
+ *
+ * @param fileId - The file ID to update visibility for
+ * @param oxyServices - OxyServices instance
+ * @param contextName - Optional context name for logging
+ * @returns Promise that resolves when visibility is updated (or skipped)
+ */
+export declare function updateAvatarVisibility(fileId: string | undefined, oxyServices: OxyServices, contextName?: string): Promise<void>;
+/**
+ * Refreshes avatar in accountStore with cache-busted URL to force image reload.
+ *
+ * @param sessionId - The session ID for the account to update
+ * @param avatarFileId - The new avatar file ID
+ * @param oxyServices - OxyServices instance to generate download URL
+ */
+export declare function refreshAvatarInStore(sessionId: string, avatarFileId: string, oxyServices: OxyServices): void;
+/**
+ * Updates user profile with avatar and handles all side effects (query invalidation, accountStore update).
+ * This function can be used from within OxyContext provider without requiring useOxy hook.
+ *
+ * @param updates - Profile updates including avatar
+ * @param oxyServices - OxyServices instance
+ * @param activeSessionId - Active session ID
+ * @param queryClient - TanStack Query client
+ * @param syncSession - Optional function to sync session/refresh token when auth errors occur
+ * @returns Promise that resolves with updated user data
+ */
+export declare function updateProfileWithAvatar(updates: Partial<User>, oxyServices: OxyServices, activeSessionId: string | null, queryClient: QueryClient, syncSession?: () => Promise<User>): Promise<User>;

package/dist/web/types/ui/utils/colorUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Color Utility Functions
+ *
+ * Re-exports from shared module for cleaner internal imports.
+ * External consumers should use '@oxyhq/services/shared' directly.
+ *
+ * @module ui/utils/colorUtils
+ */
+export { darkenColor, lightenColor, hexToRgb, rgbToHex, withOpacity, isLightColor, getContrastTextColor, } from '../../shared/utils/colorUtils';

package/dist/web/types/ui/utils/confirmAction.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cross-platform confirm dialog. Uses window.confirm on web, Alert.alert on native.
+ * @param message The message to display
+ * @param onConfirm Callback if user confirms
+ */
+export declare function confirmAction(message: string, onConfirm: () => void): void;

package/dist/web/types/ui/utils/errorHandlers.d.ts

@@ -0,0 +1,34 @@
+import type { ApiError } from '../../models/interfaces';
+export interface HandleAuthErrorOptions {
+    defaultMessage: string;
+    code: string;
+    status?: number;
+    onError?: (error: ApiError) => void;
+    setAuthError?: (message: string) => void;
+    logger?: (message: string, error?: unknown) => void;
+}
+/**
+ * Determine whether the error represents an invalid session condition.
+ * This centralizes 401 detection across different fetch clients.
+ */
+export declare const isInvalidSessionError: (error: unknown) => boolean;
+/**
+ * Determine whether the error represents a timeout or network error.
+ * These are expected when the device is offline or has poor connectivity.
+ */
+export declare const isTimeoutOrNetworkError: (error: unknown) => boolean;
+/**
+ * Extract a consistent error message from unknown error shapes.
+ *
+ * @param error - The unknown error payload
+ * @param fallbackMessage - Message to return when no concrete message is available
+ */
+export declare const extractErrorMessage: (error: unknown, fallbackMessage?: string) => string;
+/**
+ * Centralized error handler for auth-related operations.
+ *
+ * @param error - Unknown error object
+ * @param options - Error handling configuration
+ * @returns Resolved error message
+ */
+export declare const handleAuthError: (error: unknown, { defaultMessage, code, status, onError, setAuthError, logger, }: HandleAuthErrorOptions) => string;

package/dist/web/types/ui/utils/fileManagement.d.ts

@@ -0,0 +1,86 @@
+import type { FileMetadata } from '../../models/interfaces';
+import type { RouteName } from '../navigation/routes';
+/**
+ * Format file size in bytes to human-readable string
+ */
+export declare function formatFileSize(bytes: number): string;
+/**
+ * Get icon name for file based on content type
+ */
+export declare function getFileIcon(contentType: string): string;
+/**
+ * Unified confirmation dialog - uses Alert.alert for all platforms
+ */
+export declare function confirmAction(message: string, title?: string, confirmText?: string, cancelText?: string): Promise<boolean>;
+/**
+ * Convert DocumentPicker asset to File object
+ * Handles both web (native File API) and mobile (URI-based) file sources
+ * Expo 54 compatible - works across all platforms
+ */
+export declare function convertDocumentPickerAssetToFile(doc: {
+    file?: File | Blob;
+    uri?: string;
+    name?: string | null;
+    mimeType?: string | null;
+    size?: number | null;
+}, index: number): Promise<File | null>;
+/**
+ * Helper to safely request a thumbnail variant only for image mime types.
+ * Prevents backend warnings: "Variant thumb not supported for mime application/pdf".
+ *
+ * @param file - File metadata
+ * @param variant - Variant type (default: 'thumb')
+ * @param getFileDownloadUrl - Function to get download URL from oxyServices
+ */
+export declare function getSafeDownloadUrl(file: FileMetadata, variant: string | undefined, getFileDownloadUrl: (fileId: string, variant?: string) => string): string;
+/**
+ * Upload file raw - helper function for file uploads
+ */
+export declare function uploadFileRaw(file: File | Blob, userId: string, oxyServices: any, visibility?: 'private' | 'public' | 'unlisted'): Promise<any>;
+/**
+ * Configuration for creating an avatar picker handler
+ */
+export interface AvatarPickerConfig {
+    /** Navigation function from BaseScreenProps */
+    navigate?: (screen: RouteName, props?: Record<string, unknown>) => void;
+    /** OxyServices instance */
+    oxyServices: any;
+    /** TanStack Query mutation for updating profile */
+    updateProfileMutation: {
+        mutateAsync: (updates: {
+            avatar: string;
+        }) => Promise<any>;
+    };
+    /** Callback to update local avatar state */
+    onAvatarSelected?: (fileId: string) => void;
+    /** i18n translation function */
+    t: (key: string) => string | undefined;
+    /** Optional context name for logging (e.g., 'AccountSettings', 'WelcomeNewUser') */
+    contextName?: string;
+}
+/**
+ * Creates a reusable avatar picker handler function.
+ *
+ * This function navigates to the FileManagement screen and handles:
+ * - Image file validation
+ * - File visibility update to public
+ * - Profile avatar update via mutation
+ * - Success/error toast notifications
+ *
+ * @example
+ * ```tsx
+ * const openAvatarPicker = createAvatarPickerHandler({
+ *   navigate,
+ *   oxyServices,
+ *   updateProfileMutation,
+ *   onAvatarSelected: setAvatarFileId,
+ *   t,
+ *   contextName: 'AccountSettings'
+ * });
+ *
+ * <TouchableOpacity onPress={openAvatarPicker}>
+ *   <Text>Change Avatar</Text>
+ * </TouchableOpacity>
+ * ```
+ */
+export declare function createAvatarPickerHandler(config: AvatarPickerConfig): () => void;

package/dist/web/types/ui/utils/iconNames.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Type-safe icon name utilities
+ *
+ * Provides centralized, typed icon name mappings to eliminate `as any` casts
+ * when using dynamic icon names with @expo/vector-icons.
+ */
+/**
+ * Profile field icons (MaterialCommunityIcons)
+ */
+export declare const PROFILE_FIELD_ICONS: {
+    readonly displayName: "account-outline";
+    readonly username: "at";
+    readonly email: "email-outline";
+    readonly bio: "text-box-outline";
+    readonly location: "map-marker-outline";
+    readonly links: "link-variant";
+    readonly website: "web";
+    readonly phone: "phone-outline";
+    readonly birthday: "cake-variant-outline";
+};
+export type ProfileFieldIconKey = keyof typeof PROFILE_FIELD_ICONS;
+/**
+ * Get icon name for a profile field
+ */
+export declare function getProfileFieldIcon(field: string): string;
+/**
+ * Settings section icons (MaterialCommunityIcons)
+ */
+export declare const SETTINGS_ICONS: {
+    readonly account: "account-cog-outline";
+    readonly privacy: "shield-account-outline";
+    readonly security: "lock-outline";
+    readonly notifications: "bell-outline";
+    readonly language: "translate";
+    readonly appearance: "palette-outline";
+    readonly storage: "folder-outline";
+    readonly help: "help-circle-outline";
+    readonly about: "information-outline";
+    readonly logout: "logout";
+};
+export type SettingsIconKey = keyof typeof SETTINGS_ICONS;
+/**
+ * Get icon name for a settings section
+ */
+export declare function getSettingsIcon(section: string): string;
+/**
+ * File type icons (MaterialCommunityIcons)
+ */
+export declare const FILE_TYPE_ICONS: {
+    readonly image: "image-outline";
+    readonly video: "video-outline";
+    readonly audio: "music-note-outline";
+    readonly document: "file-document-outline";
+    readonly pdf: "file-pdf-box";
+    readonly archive: "folder-zip-outline";
+    readonly code: "code-tags";
+    readonly spreadsheet: "file-excel-outline";
+    readonly presentation: "file-presentation-outline";
+    readonly text: "file-document-edit-outline";
+    readonly unknown: "file-outline";
+};
+export type FileTypeIconKey = keyof typeof FILE_TYPE_ICONS;
+/**
+ * Get icon name for a file type
+ */
+export declare function getFileTypeIcon(type: string): string;
+/**
+ * Action icons (Ionicons)
+ */
+export declare const ACTION_ICONS: {
+    readonly close: "close";
+    readonly back: "chevron-back";
+    readonly forward: "chevron-forward";
+    readonly add: "add";
+    readonly remove: "remove";
+    readonly delete: "trash-outline";
+    readonly edit: "pencil-outline";
+    readonly save: "checkmark";
+    readonly cancel: "close";
+    readonly search: "search-outline";
+    readonly filter: "filter-outline";
+    readonly sort: "swap-vertical-outline";
+    readonly refresh: "refresh-outline";
+    readonly share: "share-outline";
+    readonly copy: "copy-outline";
+    readonly download: "download-outline";
+    readonly upload: "cloud-upload-outline";
+};
+export type ActionIconKey = keyof typeof ACTION_ICONS;
+/**
+ * Get icon name for an action
+ */
+export declare function getActionIcon(action: string): string;
+/**
+ * Status icons (Ionicons)
+ */
+export declare const STATUS_ICONS: {
+    readonly success: "checkmark-circle";
+    readonly error: "alert-circle";
+    readonly warning: "warning";
+    readonly info: "information-circle";
+    readonly loading: "hourglass-outline";
+    readonly pending: "time-outline";
+    readonly online: "ellipse";
+    readonly offline: "ellipse-outline";
+};
+export type StatusIconKey = keyof typeof STATUS_ICONS;
+/**
+ * Get icon name for a status
+ */
+export declare function getStatusIcon(status: string): string;

package/dist/web/types/ui/utils/sessionHelpers.d.ts

@@ -0,0 +1,63 @@
+import type { ClientSession } from '../../models/session';
+interface DeviceSession {
+    sessionId: string;
+    deviceId?: string;
+    deviceName?: string;
+    expiresAt?: string;
+    lastActive?: string;
+    user?: {
+        id?: string;
+        _id?: {
+            toString(): string;
+        };
+    };
+    userId?: string;
+    isCurrent?: boolean;
+}
+/**
+ * Service type for session helpers.
+ * Uses 'any' to work around TypeScript mixin composition type inference issues.
+ * The OxyServices class has these methods but TypeScript can't see them due to the mixin pattern.
+ */
+type OxyServicesAny = any;
+export interface FetchSessionsWithFallbackOptions {
+    fallbackDeviceId?: string;
+    fallbackUserId?: string;
+    logger?: (message: string, error?: unknown) => void;
+}
+export interface ValidateSessionBatchOptions {
+    useHeaderValidation?: boolean;
+    maxConcurrency?: number;
+}
+export interface SessionValidationResult {
+    sessionId: string;
+    valid: boolean;
+    user?: unknown;
+    raw?: unknown;
+    error?: unknown;
+}
+/**
+ * Normalize backend session payloads into `ClientSession` objects.
+ *
+ * @param sessions - Raw session array returned from the API
+ * @param fallbackDeviceId - Device identifier to use when missing from payload
+ * @param fallbackUserId - User identifier to use when missing from payload
+ */
+export declare const mapSessionsToClient: (sessions: DeviceSession[], fallbackDeviceId?: string, fallbackUserId?: string) => ClientSession[];
+/**
+ * Fetch device sessions with fallback to the legacy session endpoint when needed.
+ *
+ * @param oxyServices - Oxy service instance
+ * @param sessionId - Session identifier to fetch
+ * @param options - Optional fallback options
+ */
+export declare const fetchSessionsWithFallback: (oxyServices: OxyServicesAny, sessionId: string, { fallbackDeviceId, fallbackUserId, logger, }?: FetchSessionsWithFallbackOptions) => Promise<ClientSession[]>;
+/**
+ * Validate multiple sessions concurrently with configurable concurrency.
+ *
+ * @param oxyServices - Oxy service instance
+ * @param sessionIds - Session identifiers to validate
+ * @param options - Validation options
+ */
+export declare const validateSessionBatch: (oxyServices: OxyServicesAny, sessionIds: string[], { useHeaderValidation, maxConcurrency }?: ValidateSessionBatchOptions) => Promise<SessionValidationResult[]>;
+export {};

package/dist/web/types/ui/utils/storageHelpers.d.ts

@@ -0,0 +1,27 @@
+export interface StorageInterface {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+}
+export interface SessionStorageKeys {
+    activeSessionId: string;
+    sessionIds: string;
+    language: string;
+}
+/**
+ * Detect whether the current runtime is React Native.
+ */
+export declare const isReactNative: () => boolean;
+/**
+ * Create a platform-appropriate storage implementation.
+ * Defaults to in-memory storage when no platform storage is available.
+ */
+export declare const createPlatformStorage: () => Promise<StorageInterface>;
+export declare const STORAGE_KEY_PREFIX = "oxy_session";
+/**
+ * Produce strongly typed storage key names for the supplied prefix.
+ *
+ * @param prefix - Storage key prefix
+ */
+export declare const getStorageKeys: (prefix?: string) => SessionStorageKeys;

package/dist/web/types/ui/utils/themeUtils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Theme Utility Functions
+ *
+ * Re-exports from shared module for cleaner internal imports.
+ * External consumers should use '@oxyhq/services/shared' directly.
+ *
+ * @module ui/utils/themeUtils
+ */
+export { normalizeTheme, normalizeColorScheme, getOppositeTheme, systemPrefersDarkMode, getSystemColorScheme, } from '../../shared/utils/themeUtils';
+export type { ThemeValue } from '../../shared/utils/themeUtils';