@oxyhq/services 5.11.12 → 5.12.1

package/src/ui/context/OxyContext.tsx

@@ -9,6 +9,8 @@ import { DeviceManager } from '../../utils/deviceManager';
 import { useSessionSocket } from '../hooks/useSessionSocket';
 import { toast } from '../../lib/sonner';
 import { useAuthStore } from '../stores/authStore';
+import type { BottomSheetController } from '../navigation/types';
+import type { RouteName } from '../navigation/routes';
 
 // Define the context shape
 // NOTE: We intentionally avoid importing useFollow here to prevent a require cycle.
@@ -32,6 +34,7 @@ export interface OxyContextState {
   logout: (targetSessionId?: string) => Promise<void>;
   logoutAll: () => Promise<void>;
   signUp: (username: string, email: string, password: string) => Promise<User>;
+  completeMfaLogin?: (mfaToken: string, code: string) => Promise<User>;
 
   // Multi-session methods
   switchSession: (sessionId: string) => Promise<void>;
@@ -48,10 +51,10 @@ export interface OxyContextState {
 
   // Access to services
   oxyServices: OxyServices;
-  bottomSheetRef?: React.RefObject<any>;
+  bottomSheetRef?: React.RefObject<BottomSheetController | null>;
 
   // Methods to directly control the bottom sheet
-  showBottomSheet?: (screenOrConfig?: string | { screen: string; props?: Record<string, any> }) => void;
+  showBottomSheet?: (screenOrConfig?: RouteName | string | { screen: RouteName | string; props?: Record<string, any> }) => void;
   hideBottomSheet?: () => void;
 
   /**
@@ -72,7 +75,7 @@ export interface OxyContextProviderProps {
   storageKeyPrefix?: string;
   onAuthStateChange?: (user: User | null) => void;
   onError?: (error: ApiError) => void; // New: Error callback
-  bottomSheetRef?: React.RefObject<any>;
+  bottomSheetRef?: React.RefObject<BottomSheetController | null>;
 }
 
 // Platform storage implementation
@@ -172,7 +175,18 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   const [sessions, setSessions] = useState<ClientSession[]>([]);
   const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
   const [storage, setStorage] = useState<StorageInterface | null>(null);
-  const [currentLanguage, setCurrentLanguage] = useState<string>('en');
+  const [currentLanguage, setCurrentLanguage] = useState<string>('en-US');
+
+  // Normalize language codes to BCP-47 (e.g., en-US)
+  const normalizeLanguageCode = useCallback((lang?: string | null): string | null => {
+    if (!lang) return null;
+    if (lang.includes('-')) return lang;
+    const map: Record<string, string> = {
+      en: 'en-US', es: 'es-ES', ca: 'ca-ES', fr: 'fr-FR', de: 'de-DE', it: 'it-IT', pt: 'pt-PT',
+      ja: 'ja-JP', ko: 'ko-KR', zh: 'zh-CN', ar: 'ar-SA'
+    };
+    return map[lang] || lang;
+  }, []);
   // Add a new state to track token restoration
   const [tokenReady, setTokenReady] = useState(false);
 
@@ -212,7 +226,8 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         setTokenReady(false);
 
         // Load saved language preference
-        const savedLanguage = await storage.getItem(keys.language);
+        const savedLanguageRaw = await storage.getItem(keys.language);
+        const savedLanguage = normalizeLanguageCode(savedLanguageRaw) || savedLanguageRaw;
         if (savedLanguage) {
           setCurrentLanguage(savedLanguage);
         }
@@ -228,6 +243,16 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
               const fullUser = await oxyServices.getUserBySession(storedActiveSessionId);
               loginSuccess(fullUser);
               setMinimalUser({ id: fullUser.id, username: fullUser.username, avatar: fullUser.avatar });
+              // Apply server language if present
+              if ((fullUser as any)?.language) {
+                try {
+                  const serverLang = normalizeLanguageCode((fullUser as any).language) || (fullUser as any).language;
+                  await storage.setItem(keys.language, serverLang);
+                  setCurrentLanguage(serverLang);
+                } catch (e) {
+                  console.warn('Failed to apply server language preference', e);
+                }
+              }
               const serverSessions = await oxyServices.getSessionsBySessionId(storedActiveSessionId);
               const clientSessions: ClientSession[] = serverSessions.map(s => ({
                 sessionId: s.sessionId,
@@ -307,6 +332,16 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
       });
 
       await saveActiveSessionId(sessionId);
+      // Apply server language if present
+      if ((fullUser as any)?.language) {
+        try {
+          const serverLang = normalizeLanguageCode((fullUser as any).language) || (fullUser as any).language;
+          await storage?.setItem(keys.language, serverLang);
+          setCurrentLanguage(serverLang);
+        } catch (e) {
+          console.warn('Failed to apply server language after switch', e);
+        }
+      }
 
       if (onAuthStateChange) {
         onAuthStateChange(fullUser);
@@ -334,27 +369,36 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
       console.log('Auth - Using device fingerprint:', deviceFingerprint);
       console.log('Auth - Using device ID:', deviceInfo.deviceId);
 
-      const response: SessionLoginResponse = await oxyServices.signIn(
+      const response: any = await oxyServices.signIn(
         username,
         password,
         deviceName || deviceInfo.deviceName || DeviceManager.getDefaultDeviceName(),
         deviceFingerprint
       );
 
+      // Handle MFA requirement
+      if (response && response.mfaRequired) {
+        const err: any = new Error('Multi-factor authentication required');
+        err.code = 'MFA_REQUIRED';
+        err.mfaToken = response.mfaToken;
+        err.expiresAt = response.expiresAt;
+        throw err;
+      }
+
       // Set as active session (only store session ID)
-      setActiveSessionId(response.sessionId);
-      await saveActiveSessionId(response.sessionId);
+      setActiveSessionId((response as SessionLoginResponse).sessionId);
+      await saveActiveSessionId((response as SessionLoginResponse).sessionId);
 
       // Get access token for API calls
       await oxyServices.getTokenBySession(response.sessionId);
 
       // Load full user data from backend
-      const fullUser = await oxyServices.getUserBySession(response.sessionId);
+      const fullUser = await oxyServices.getUserBySession((response as SessionLoginResponse).sessionId);
       loginSuccess(fullUser);
       setMinimalUser(response.user);
 
       // Load sessions from backend
-      const serverSessions = await oxyServices.getSessionsBySessionId(response.sessionId);
+      const serverSessions = await oxyServices.getSessionsBySessionId((response as SessionLoginResponse).sessionId);
       const clientSessions: ClientSession[] = serverSessions.map(serverSession => ({
         sessionId: serverSession.sessionId,
         deviceId: serverSession.deviceId,
@@ -497,6 +541,63 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     }
   }, [storage, oxyServices, login, loginFailure]);
 
+  // Complete MFA login by verifying TOTP
+  const completeMfaLogin = useCallback(async (mfaToken: string, code: string): Promise<User> => {
+    if (!storage) throw new Error('Storage not initialized');
+    useAuthStore.setState({ isLoading: true, error: null });
+    try {
+      const response = await oxyServices.verifyTotpLogin(mfaToken, code);
+
+      // Set as active session
+      setActiveSessionId(response.sessionId);
+      await saveActiveSessionId(response.sessionId);
+
+      // Fetch access token and user data
+      await oxyServices.getTokenBySession(response.sessionId);
+      const fullUser = await oxyServices.getUserBySession(response.sessionId);
+      loginSuccess(fullUser);
+      setMinimalUser({ id: fullUser.id, username: fullUser.username, avatar: fullUser.avatar });
+      // Apply server language if present
+      if ((fullUser as any)?.language) {
+        try {
+          const serverLang = normalizeLanguageCode((fullUser as any).language) || (fullUser as any).language;
+          await storage.setItem(keys.language, serverLang);
+          setCurrentLanguage(serverLang);
+        } catch (e) {
+          console.warn('Failed to apply server language on MFA login', e);
+        }
+      }
+
+      // Load sessions list
+      const serverSessions = await oxyServices.getSessionsBySessionId(response.sessionId);
+      const clientSessions: ClientSession[] = serverSessions.map(s => ({
+        sessionId: s.sessionId,
+        deviceId: s.deviceId,
+        expiresAt: s.expiresAt || new Date().toISOString(),
+        lastActive: s.lastActive || new Date().toISOString(),
+        userId: s.userId || fullUser.id
+      }));
+      setSessions(clientSessions);
+      // Apply server language if present
+      if ((fullUser as any)?.language) {
+        try {
+          await storage.setItem(keys.language, (fullUser as any).language);
+          setCurrentLanguage((fullUser as any).language);
+        } catch (e) {
+          console.warn('Failed to apply server language on MFA login', e);
+        }
+      }
+
+      if (onAuthStateChange) onAuthStateChange(fullUser);
+      return fullUser;
+    } catch (error: any) {
+      loginFailure(error.message || 'MFA verification failed');
+      throw error;
+    } finally {
+      useAuthStore.setState({ isLoading: false });
+    }
+  }, [storage, oxyServices, loginSuccess, loginFailure, saveActiveSessionId, onAuthStateChange]);
+
   // Switch session method
   const switchSession = useCallback(async (sessionId: string): Promise<void> => {
     await switchToSession(sessionId);
@@ -640,22 +741,22 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   }, [storage, keys.language]);
 
   // Bottom sheet control methods
-  const showBottomSheet = useCallback((screenOrConfig?: string | { screen: string; props?: Record<string, any> }) => {
-    console.log('showBottomSheet called with:', screenOrConfig);
+  const showBottomSheet = useCallback((screenOrConfig?: RouteName | string | { screen: RouteName | string; props?: Record<string, any> }) => {
+    if (__DEV__) console.log('showBottomSheet called with:', screenOrConfig);
 
     if (bottomSheetRef?.current) {
-      console.log('bottomSheetRef is available');
+      if (__DEV__) console.log('bottomSheetRef is available');
 
       // First, show the bottom sheet
       if (bottomSheetRef.current.expand) {
-        console.log('Expanding bottom sheet');
+        if (__DEV__) console.log('Expanding bottom sheet');
         bottomSheetRef.current.expand();
       } else if (bottomSheetRef.current.present) {
-        console.log('Presenting bottom sheet');
+        if (__DEV__) console.log('Presenting bottom sheet');
         bottomSheetRef.current.present();
       } else {
         console.warn('No expand or present method available on bottomSheetRef');
-        console.log('Available methods on bottomSheetRef.current:', Object.keys(bottomSheetRef.current));
+        if (__DEV__) console.log('Available methods on bottomSheetRef.current:', Object.keys(bottomSheetRef.current as any));
       }
 
       // Then navigate to the specified screen if provided
@@ -664,12 +765,12 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         setTimeout(() => {
           if (typeof screenOrConfig === 'string') {
             // Simple screen name
-            console.log('Navigating to screen:', screenOrConfig);
-            bottomSheetRef.current?._navigateToScreen?.(screenOrConfig);
+            if (__DEV__) console.log('Navigating to screen:', screenOrConfig);
+            bottomSheetRef.current?.navigate?.(screenOrConfig);
           } else {
             // Screen with props
-            console.log('Navigating to screen with props:', screenOrConfig.screen, screenOrConfig.props);
-            bottomSheetRef.current?._navigateToScreen?.(screenOrConfig.screen, screenOrConfig.props);
+            if (__DEV__) console.log('Navigating to screen with props:', screenOrConfig.screen, screenOrConfig.props);
+            bottomSheetRef.current?.navigate?.(screenOrConfig.screen, screenOrConfig.props);
           }
         }, 100);
       }
@@ -731,6 +832,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     logout,
     logoutAll,
     signUp,
+    completeMfaLogin,
     switchSession,
     removeSession,
     refreshSessions,
@@ -756,6 +858,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     logout,
     logoutAll,
     signUp,
+    completeMfaLogin,
     switchSession,
     removeSession,
     refreshSessions,

package/src/ui/hooks/useI18n.ts

@@ -0,0 +1,12 @@
+import { useMemo } from 'react';
+import { useOxy } from '../context/OxyContext';
+import { translate } from '../../i18n';
+
+export function useI18n() {
+  const { currentLanguage } = useOxy();
+  const t = useMemo(() => {
+    return (key: string, vars?: Record<string, string | number>) => translate(currentLanguage, key, vars);
+  }, [currentLanguage]);
+  return { t, locale: currentLanguage };
+}
+

package/src/ui/navigation/OxyRouter.tsx

@@ -3,129 +3,10 @@ import { useState, useEffect, useCallback } from 'react';
 import { View, StyleSheet } from 'react-native';
 import { OxyServices } from '../../core';
 
-// Import screens
-import SignInScreen from '../screens/SignInScreen';
-import SignUpScreen from '../screens/SignUpScreen';
-import AccountCenterScreen from '../screens/AccountCenterScreen';
-import AccountSwitcherScreen from '../screens/AccountSwitcherScreen';
-import SessionManagementScreen from '../screens/SessionManagementScreen';
-import AccountOverviewScreen from '../screens/AccountOverviewScreen';
-import AccountSettingsScreen from '../screens/AccountSettingsScreen';
-import PremiumSubscriptionScreen from '../screens/PremiumSubscriptionScreen';
-import AppInfoScreen from '../screens/AppInfoScreen';
-import FeedbackScreen from '../screens/FeedbackScreen';
-import KarmaCenterScreen from '../screens/karma/KarmaCenterScreen';
-import KarmaLeaderboardScreen from '../screens/karma/KarmaLeaderboardScreen';
-import KarmaRulesScreen from '../screens/karma/KarmaRulesScreen';
-import KarmaAboutScreen from '../screens/karma/KarmaAboutScreen';
-import KarmaRewardsScreen from '../screens/karma/KarmaRewardsScreen';
-import KarmaFAQScreen from '../screens/karma/KarmaFAQScreen';
-import ProfileScreen from '../screens/ProfileScreen';
-import UserLinksScreen from '../screens/UserLinksScreen';
-import FileManagementScreen from '../screens/FileManagementScreen';
-import RecoverAccountScreen from '../screens/RecoverAccountScreen';
-import PaymentGatewayScreen from '../screens/PaymentGatewayScreen';
-import WelcomeNewUserScreen from '../screens/WelcomeNewUserScreen';
-import LanguageSelectorScreen from '../screens/LanguageSelectorScreen';
-
-// Import types
-import type { OxyRouterProps, RouteConfig } from './types';
-
-// Define route configuration with screen components and default snap points
-const routes: Record<string, RouteConfig> = {
-    SignIn: {
-        component: SignInScreen,
-        snapPoints: ['10%', '80%'],
-    },
-    SignUp: {
-        component: SignUpScreen,
-        snapPoints: ['10%', '90%'],
-    },
-    RecoverAccount: {
-        component: RecoverAccountScreen,
-        snapPoints: ['10%', '80%'],
-    },
-    AccountCenter: {
-        component: AccountCenterScreen,
-        snapPoints: ['60%', '100%'],
-    },
-    AccountSwitcher: {
-        component: AccountSwitcherScreen,
-        snapPoints: ['70%', '100%'],
-    },
-    SessionManagement: {
-        component: SessionManagementScreen,
-        snapPoints: ['70%', '100%'],
-    },
-    AccountOverview: {
-        component: AccountOverviewScreen,
-        snapPoints: ['60%', '85%'],
-    },
-    EditProfile: {
-        component: AccountSettingsScreen,
-        snapPoints: ['60%', '100%'],
-    },
-    PremiumSubscription: {
-        component: PremiumSubscriptionScreen,
-        snapPoints: ['70%', '100%'],
-    },
-    AppInfo: {
-        component: AppInfoScreen,
-        snapPoints: ['60%', '90%'],
-    },
-    Feedback: {
-        component: FeedbackScreen,
-        snapPoints: ['70%', '100%'],
-    },
-    KarmaCenter: {
-        component: KarmaCenterScreen,
-        snapPoints: ['60%', '100%'],
-    },
-    KarmaLeaderboard: {
-        component: KarmaLeaderboardScreen,
-        snapPoints: ['60%', '100%'],
-    },
-    KarmaRules: {
-        component: KarmaRulesScreen,
-        snapPoints: ['60%', '90%'],
-    },
-    AboutKarma: {
-        component: KarmaAboutScreen,
-        snapPoints: ['60%', '90%'],
-    },
-    KarmaRewards: {
-        component: KarmaRewardsScreen,
-        snapPoints: ['60%', '90%'],
-    },
-    KarmaFAQ: {
-        component: KarmaFAQScreen,
-        snapPoints: ['60%', '90%'],
-    },
-    Profile: {
-        component: ProfileScreen,
-        snapPoints: ['60%', '90%'],
-    },
-    UserLinks: {
-        component: UserLinksScreen,
-        snapPoints: ['60%', '90%'],
-    },
-    FileManagement: {
-        component: FileManagementScreen,
-        snapPoints: ['70%', '100%'],
-    },
-    PaymentGateway: {
-        component: PaymentGatewayScreen,
-        snapPoints: ['60%', '90%'],
-    },
-    WelcomeNewUser: {
-        component: WelcomeNewUserScreen,
-        snapPoints: ['65%', '90%'],
-    },
-    LanguageSelector: {
-        component: LanguageSelectorScreen,
-        snapPoints: ['70%', '100%'],
-    },
-};
+// Import types and route registry
+import type { OxyRouterProps } from './types';
+import { routes } from './routes';
+import type { RouteName } from './routes';
 
 const OxyRouter: React.FC<OxyRouterProps> = ({
     oxyServices,
@@ -137,23 +18,23 @@ const OxyRouter: React.FC<OxyRouterProps> = ({
     navigationRef,
     containerWidth,
 }) => {
-    const [currentScreen, setCurrentScreen] = useState<string>(initialScreen);
-    const [screenHistory, setScreenHistory] = useState<string[]>([initialScreen]);
+    const [currentScreen, setCurrentScreen] = useState<RouteName>(initialScreen);
+    const [screenHistory, setScreenHistory] = useState<RouteName[]>([initialScreen]);
     // Store props per screen for correct restoration on back
-    const [screenPropsMap, setScreenPropsMap] = useState<Record<string, any>>({ [initialScreen]: {} });
+    const [screenPropsMap, setScreenPropsMap] = useState<Partial<Record<RouteName, any>>>({ [initialScreen]: {} });
 
     // Update snap points when the screen changes
     useEffect(() => {
-        if (routes[currentScreen] && typeof adjustSnapPoints === 'function') {
-            adjustSnapPoints(routes[currentScreen].snapPoints);
+        if ((routes as any)[currentScreen] && typeof adjustSnapPoints === 'function') {
+            adjustSnapPoints((routes as any)[currentScreen].snapPoints);
         }
     }, [currentScreen, adjustSnapPoints]);
 
     // Memoized navigation methods
-    const navigate = useCallback((screen: string, props: Record<string, any> = {}) => {
-        console.log('OxyRouter: navigate called with screen:', screen, 'props:', props);
+    const navigate = useCallback((screen: RouteName, props: Record<string, any> = {}) => {
+        if (__DEV__) console.log('OxyRouter: navigate called', screen, props);
         if (routes[screen]) {
-            console.log('OxyRouter: screen found in routes, navigating to:', screen);
+            if (__DEV__) console.log('OxyRouter: screen found in routes');
             setCurrentScreen(screen);
             setScreenHistory(prev => [...prev, screen]);
             setScreenPropsMap(prev => ({ ...prev, [screen]: props }));
@@ -184,12 +65,12 @@ const OxyRouter: React.FC<OxyRouterProps> = ({
     useEffect(() => {
         if (navigationRef) {
             navigationRef.current = navigate;
-            console.log('OxyRouter: navigationRef.current set to navigate function');
+            if (__DEV__) console.log('OxyRouter: navigationRef set');
         }
         return () => {
             if (navigationRef) {
                 navigationRef.current = null;
-                console.log('OxyRouter: navigationRef.current cleared');
+                if (__DEV__) console.log('OxyRouter: navigationRef cleared');
             }
         };
     }, [navigate, navigationRef]);
@@ -231,7 +112,7 @@ const OxyRouter: React.FC<OxyRouterProps> = ({
 
     // Render the current screen component
     const renderScreen = () => {
-        const CurrentScreen = routes[currentScreen]?.component;
+        const CurrentScreen = (routes as any)[currentScreen]?.component;
         if (!CurrentScreen) {
             if (process.env.NODE_ENV !== 'production') {
                 console.error(`Screen "${currentScreen}" not found`);

package/src/ui/navigation/routes.ts

@@ -0,0 +1,153 @@
+import type { ComponentType } from 'react';
+import SignInScreen from '../screens/SignInScreen';
+import SignUpScreen from '../screens/SignUpScreen';
+import AccountCenterScreen from '../screens/AccountCenterScreen';
+import AccountSwitcherScreen from '../screens/AccountSwitcherScreen';
+import SessionManagementScreen from '../screens/SessionManagementScreen';
+import AccountOverviewScreen from '../screens/AccountOverviewScreen';
+import AccountSettingsScreen from '../screens/AccountSettingsScreen';
+import PremiumSubscriptionScreen from '../screens/PremiumSubscriptionScreen';
+import AppInfoScreen from '../screens/AppInfoScreen';
+import FeedbackScreen from '../screens/FeedbackScreen';
+import KarmaCenterScreen from '../screens/karma/KarmaCenterScreen';
+import KarmaLeaderboardScreen from '../screens/karma/KarmaLeaderboardScreen';
+import KarmaRulesScreen from '../screens/karma/KarmaRulesScreen';
+import KarmaAboutScreen from '../screens/karma/KarmaAboutScreen';
+import KarmaRewardsScreen from '../screens/karma/KarmaRewardsScreen';
+import KarmaFAQScreen from '../screens/karma/KarmaFAQScreen';
+import ProfileScreen from '../screens/ProfileScreen';
+import UserLinksScreen from '../screens/UserLinksScreen';
+import FileManagementScreen from '../screens/FileManagementScreen';
+import RecoverAccountScreen from '../screens/RecoverAccountScreen';
+import PaymentGatewayScreen from '../screens/PaymentGatewayScreen';
+import WelcomeNewUserScreen from '../screens/WelcomeNewUserScreen';
+import LanguageSelectorScreen from '../screens/LanguageSelectorScreen';
+
+export interface RouteConfig {
+  component: ComponentType<any>;
+  snapPoints: string[];
+}
+
+// Keep a literal list of route names for a precise union type
+export const routeNames = [
+  'SignIn',
+  'SignUp',
+  'RecoverAccount',
+  'AccountCenter',
+  'AccountSwitcher',
+  'SessionManagement',
+  'AccountOverview',
+  'EditProfile',
+  'PremiumSubscription',
+  'AppInfo',
+  'Feedback',
+  'KarmaCenter',
+  'KarmaLeaderboard',
+  'KarmaRules',
+  'AboutKarma',
+  'KarmaRewards',
+  'KarmaFAQ',
+  'Profile',
+  'UserLinks',
+  'FileManagement',
+  'PaymentGateway',
+  'WelcomeNewUser',
+  'LanguageSelector',
+] as const;
+
+export type RouteName = typeof routeNames[number];
+
+export const routes: Record<RouteName, RouteConfig> = {
+  SignIn: {
+    component: SignInScreen as unknown as ComponentType<any>,
+    snapPoints: ['10%', '80%'],
+  },
+  SignUp: {
+    component: SignUpScreen as unknown as ComponentType<any>,
+    snapPoints: ['10%', '90%'],
+  },
+  RecoverAccount: {
+    component: RecoverAccountScreen as unknown as ComponentType<any>,
+    snapPoints: ['10%', '80%'],
+  },
+  AccountCenter: {
+    component: AccountCenterScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '100%'],
+  },
+  AccountSwitcher: {
+    component: AccountSwitcherScreen as unknown as ComponentType<any>,
+    snapPoints: ['70%', '100%'],
+  },
+  SessionManagement: {
+    component: SessionManagementScreen as unknown as ComponentType<any>,
+    snapPoints: ['70%', '100%'],
+  },
+  AccountOverview: {
+    component: AccountOverviewScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '85%'],
+  },
+  EditProfile: {
+    component: AccountSettingsScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '100%'],
+  },
+  PremiumSubscription: {
+    component: PremiumSubscriptionScreen as unknown as ComponentType<any>,
+    snapPoints: ['70%', '100%'],
+  },
+  AppInfo: {
+    component: AppInfoScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '90%'],
+  },
+  Feedback: {
+    component: FeedbackScreen as unknown as ComponentType<any>,
+    snapPoints: ['70%', '100%'],
+  },
+  KarmaCenter: {
+    component: KarmaCenterScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '100%'],
+  },
+  KarmaLeaderboard: {
+    component: KarmaLeaderboardScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '100%'],
+  },
+  KarmaRules: {
+    component: KarmaRulesScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '90%'],
+  },
+  AboutKarma: {
+    component: KarmaAboutScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '90%'],
+  },
+  KarmaRewards: {
+    component: KarmaRewardsScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '90%'],
+  },
+  KarmaFAQ: {
+    component: KarmaFAQScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '90%'],
+  },
+  Profile: {
+    component: ProfileScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '90%'],
+  },
+  UserLinks: {
+    component: UserLinksScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '90%'],
+  },
+  FileManagement: {
+    component: FileManagementScreen as unknown as ComponentType<any>,
+    snapPoints: ['70%', '100%'],
+  },
+  PaymentGateway: {
+    component: PaymentGatewayScreen as unknown as ComponentType<any>,
+    snapPoints: ['60%', '90%'],
+  },
+  WelcomeNewUser: {
+    component: WelcomeNewUserScreen as unknown as ComponentType<any>,
+    snapPoints: ['65%', '90%'],
+  },
+  LanguageSelector: {
+    component: LanguageSelectorScreen as unknown as ComponentType<any>,
+    snapPoints: ['70%', '100%'],
+  },
+};