@umituz/react-native-settings 5.2.19 → 5.2.21

package/src/domains/notifications/quietHours/infrastructure/hooks/useQuietHoursActions.ts

@@ -4,28 +4,28 @@
  */
 
 import { useCallback } from 'react';
-import { usePreferencesStore, useQuietHours } from '../../../reminders/infrastructure/storage/RemindersStore';
+import { useNotificationStore, useQuietHours } from '../../../infrastructure/storage/UnifiedNotificationStore';
 import type { QuietHoursConfig } from '../../../infrastructure/services/types';
 
 export const useQuietHoursActions = () => {
   const quietHours = useQuietHours();
-  const { updateQuietHours } = usePreferencesStore();
+  const { updateQuietHours } = useNotificationStore();
 
   const setQuietHoursEnabled = useCallback(async (enabled: boolean): Promise<void> => {
     // Use getState() to avoid stale closure and race conditions
-    const currentQuietHours = usePreferencesStore.getState().preferences.quietHours;
+    const currentQuietHours = useNotificationStore.getState().preferences.quietHours;
     await updateQuietHours({ ...currentQuietHours, enabled });
   }, [updateQuietHours]);
 
   const setStartTime = useCallback(async (hour: number, minute: number): Promise<void> => {
     // Use getState() to avoid stale closure and race conditions
-    const currentQuietHours = usePreferencesStore.getState().preferences.quietHours;
+    const currentQuietHours = useNotificationStore.getState().preferences.quietHours;
     await updateQuietHours({ ...currentQuietHours, startHour: hour, startMinute: minute });
   }, [updateQuietHours]);
 
   const setEndTime = useCallback(async (hour: number, minute: number): Promise<void> => {
     // Use getState() to avoid stale closure and race conditions
-    const currentQuietHours = usePreferencesStore.getState().preferences.quietHours;
+    const currentQuietHours = useNotificationStore.getState().preferences.quietHours;
     await updateQuietHours({ ...currentQuietHours, endHour: hour, endMinute: minute });
   }, [updateQuietHours]);
 
@@ -35,7 +35,7 @@ export const useQuietHoursActions = () => {
 
   const isInQuietHours = useCallback((): boolean => {
     // Use getState() to get current quietHours for consistency
-    const currentQuietHours = usePreferencesStore.getState().preferences.quietHours;
+    const currentQuietHours = useNotificationStore.getState().preferences.quietHours;
 
     if (!currentQuietHours.enabled) return false;
 

package/src/domains/notifications/reminders/infrastructure/hooks/useReminderActions.ts

@@ -4,14 +4,14 @@
  */
 
 import { useCallback, useMemo } from 'react';
-import { useRemindersStore } from '../storage/RemindersStore';
+import { useNotificationStore } from '../../../infrastructure/storage/UnifiedNotificationStore';
 import { NotificationScheduler } from '../../../infrastructure/services/NotificationScheduler';
 import { generateReminderId } from '../../../infrastructure/utils/idGenerator';
 import { buildTrigger } from '../../../infrastructure/utils/triggerBuilder';
 import type { Reminder, CreateReminderInput, UpdateReminderInput } from '../../../infrastructure/services/types';
 
 export const useReminderActions = () => {
-  const { addReminder, updateReminder, deleteReminder, toggleReminder: _toggleReminder } = useRemindersStore();
+  const { addReminder, updateReminder, deleteReminder, toggleReminder: _toggleReminder } = useNotificationStore();
 
   // Lazy initialization of scheduler
   const scheduler = useMemo(() => new NotificationScheduler(), []);
@@ -47,7 +47,7 @@ export const useReminderActions = () => {
 
   const editReminder = useCallback(async (id: string, input: UpdateReminderInput): Promise<void> => {
     // Get current state BEFORE async operations to prevent race condition
-    const existing = useRemindersStore.getState().reminders.find(r => r.id === id);
+    const existing = useNotificationStore.getState().reminders.find(r => r.id === id);
 
     if (!existing) {
       throw new Error(`Reminder with id ${id} not found`);
@@ -86,7 +86,7 @@ export const useReminderActions = () => {
 
   const removeReminder = useCallback(async (id: string): Promise<void> => {
     // Get current state BEFORE async operations to prevent race condition
-    const reminder = useRemindersStore.getState().reminders.find(r => r.id === id);
+    const reminder = useNotificationStore.getState().reminders.find(r => r.id === id);
 
     if (!reminder) {
       throw new Error(`Reminder with id ${id} not found`);
@@ -105,7 +105,7 @@ export const useReminderActions = () => {
 
   const toggleReminderEnabled = useCallback(async (id: string): Promise<void> => {
     // Get current state BEFORE async operations to prevent race condition
-    const reminder = useRemindersStore.getState().reminders.find(r => r.id === id);
+    const reminder = useNotificationStore.getState().reminders.find(r => r.id === id);
 
     if (!reminder) {
       throw new Error(`Reminder with id ${id} not found`);

package/src/domains/notifications/reminders/presentation/screens/ReminderListScreen.tsx

@@ -15,7 +15,7 @@ import {
   useAppDesignTokens
 } from '@umituz/react-native-design-system';
 import { ReminderItem } from '../components/ReminderItem';
-import { useReminders, useRemindersLoading } from '../../infrastructure/storage/RemindersStore';
+import { useReminders, useRemindersLoading } from '../../../infrastructure/storage/UnifiedNotificationStore';
 import { useReminderActions } from '../../infrastructure/hooks/useReminderActions';
 import type { Reminder, ReminderTranslations } from '../../../infrastructure/services/types';
 import { devError } from '../../../../../utils/devUtils';

package/src/domains/rating/presentation/hooks/useAppRating.tsx

@@ -13,6 +13,7 @@ import type {
 import { DEFAULT_RATING_CONFIG } from "../../domain/entities/RatingConfig";
 import * as RatingService from "../../application/services/RatingService";
 import { RatingPromptModal } from "../components/RatingPromptModal";
+import { isDev } from "../../../../utils/devUtils";
 
 /**
  * App rating hook with 2-step prompt flow
@@ -72,7 +73,7 @@ export function useAppRating(config: RatingConfig): UseAppRatingResult {
         await StoreReview.requestReview();
       }
     } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
+      if (isDev()) {
         console.error('[useAppRating] Failed to request review:', error);
       }
     }

package/src/infrastructure/storage/storeConfig.ts

@@ -0,0 +1,114 @@
+/**
+ * Store Configuration Standards
+ * Standardized patterns for all Zustand stores
+ *
+ * Provides consistent configuration for:
+ * - Persistence settings
+ * - Version management
+ * - State partializing (excluding transient state)
+ * - Storage service integration
+ */
+
+import type { StateStorage } from 'zustand/middleware';
+import { storageService } from '@umituz/react-native-design-system';
+
+/**
+ * Standard store configuration interface
+ */
+export interface StandardStoreConfig<T> {
+  /** Unique storage key name */
+  name: string;
+  /** Store version for migrations */
+  version: number;
+  /** Enable persistence */
+  persist: boolean;
+  /** Custom partialize function to control what gets persisted */
+  partialize?: (state: T) => Partial<T>;
+  /** Storage service (defaults to design-system's storageService) */
+  storage?: StateStorage;
+}
+
+/**
+ * Create standardized store configuration
+ *
+ * @param config - Store configuration
+ * @returns Complete store config with defaults
+ *
+ * @example
+ * ```typescript
+ * const config = createStoreConfig({
+ *   name: 'my-store',
+ *   version: 1,
+ *   persist: true,
+ *   partialize: excludeTransientState,
+ * });
+ * ```
+ */
+export const createStoreConfig = <T extends object>(
+  config: StandardStoreConfig<T>
+): Required<StandardStoreConfig<T>> => {
+  return {
+    name: config.name,
+    version: config.version,
+    persist: config.persist,
+    partialize: config.partialize || ((state) => state),
+    storage: config.storage || storageService,
+  };
+};
+
+/**
+ * Base interface for store state with transient flags
+ */
+export interface BaseStoreState {
+  /** Loading state (never persisted) */
+  isLoading?: boolean;
+  /** Initialization state (never persisted) */
+  isInitialized?: boolean;
+}
+
+/**
+ * Standard partialize function that excludes loading/initialization flags
+ * These flags are runtime state and should never be persisted
+ *
+ * @param state - Store state
+ * @returns State with transient flags excluded
+ *
+ * @example
+ * ```typescript
+ * const config = createStoreConfig({
+ *   name: 'my-store',
+ *   version: 1,
+ *   persist: true,
+ *   partialize: excludeTransientState,
+ * });
+ * ```
+ */
+export const excludeTransientState = <T extends BaseStoreState>(
+  state: T
+): Partial<T> => {
+  const { isLoading, isInitialized, ...persistedState } = state;
+  return persistedState as Partial<T>;
+};
+
+/**
+ * Create partialize function that excludes specific keys
+ *
+ * @param excludeKeys - Keys to exclude from persistence
+ * @returns Partialize function
+ *
+ * @example
+ * ```typescript
+ * const partialize = createPartializeExcluding(['isLoading', 'error', 'tempData']);
+ * ```
+ */
+export const createPartializeExcluding = <T extends object>(
+  excludeKeys: (keyof T)[]
+) => {
+  return (state: T): Partial<T> => {
+    const result = { ...state };
+    excludeKeys.forEach((key) => {
+      delete result[key];
+    });
+    return result;
+  };
+};

package/src/infrastructure/utils/async/core.ts

@@ -4,6 +4,7 @@
  */
 
 import type { ValidationResult } from "../validation";
+import { isDev } from '../../../utils/devUtils';
 
 /**
  * Result type for async operations
@@ -58,7 +59,7 @@ export const createAsyncHandler = <T extends unknown[], R>(
         onSuccess?.(result);
       } catch (callbackError) {
         // Log callback error but don't treat it as handler error
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
+        if (isDev()) {
           console.error("[createAsyncHandler] onSuccess callback error:", callbackError);
         }
       }
@@ -72,7 +73,7 @@ export const createAsyncHandler = <T extends unknown[], R>(
           onLoadingEnd?.();
         } catch (callbackError) {
           // Log callback error but don't throw
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
+          if (isDev()) {
             console.error("[createAsyncHandler] onLoadingEnd callback error:", callbackError);
           }
         }

package/src/infrastructure/utils/errorHandlers.ts

@@ -4,6 +4,8 @@
  * FIXED: Added safety checks for showToast and proper error handling
  */
 
+import { isDev } from '../../utils/devUtils';
+
 /**
  * Error types for better error classification
  */
@@ -182,7 +184,7 @@ export const logError = (
   };
 
   // Log errors in development mode
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
+  if (isDev()) {
     console.error("[Error]", logData);
   }
 
@@ -216,7 +218,7 @@ export const handleError = (
       }
     } catch (toastError) {
       // Log toast error but don't crash error handling
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
+      if (isDev()) {
         console.error("[ErrorHandlers] showToast failed:", toastError);
       }
     }

package/src/infrastructure/utils/index.ts

@@ -3,7 +3,7 @@
  * Centralized utility functions for common operations
  */
 
-export * from './styleUtils';
+export * from './styles';
 export * from './memoUtils';
 export * from './styleTokens';
 export * from './configFactory';

package/src/presentation/components/SettingsNavigationItem.tsx

@@ -0,0 +1,109 @@
+/**
+ * Generic Settings Navigation Item
+ * Consolidates VideoTutorialSettingsItem, GamificationSettingsItem,
+ * WalletSettingsItem, and SubscriptionSettingsItem into one reusable component
+ */
+
+import React from "react";
+import type { IconName } from "@umituz/react-native-design-system";
+import { SettingsItemCard } from "./SettingsItemCard";
+import { useSettingsNavigation } from "../navigation/hooks/useSettingsNavigation";
+import { createRouteOrPressHandler } from "../navigation/utils/navigationHelpers";
+import type { SettingsStackParamList } from "../navigation/types";
+
+/**
+ * Base configuration for navigation items
+ */
+export interface SettingsNavigationItemConfig {
+  title?: string;
+  description?: string;
+  icon?: string;
+  sectionTitle?: string;
+  route?: keyof SettingsStackParamList;
+  onPress?: () => void;
+}
+
+/**
+ * Props for generic settings navigation item
+ */
+export interface SettingsNavigationItemProps<T extends SettingsNavigationItemConfig = SettingsNavigationItemConfig> {
+  /** Item configuration */
+  config: T;
+  /** Default icon if not specified in config */
+  defaultIcon?: IconName;
+  /** Default route if not specified in config */
+  defaultRoute?: keyof SettingsStackParamList;
+  /** Function to render custom description */
+  renderDescription?: (config: T) => string | undefined;
+  /** Remove background styling */
+  noBackground?: boolean;
+  /** Remove margin */
+  hideMargin?: boolean;
+}
+
+/**
+ * Generic Settings Navigation Item Component
+ *
+ * @example
+ * ```tsx
+ * <SettingsNavigationItem
+ *   config={videoConfig}
+ *   defaultIcon="play-circle-outline"
+ *   defaultRoute="VideoTutorial"
+ * />
+ * ```
+ *
+ * @example With custom description
+ * ```tsx
+ * <SettingsNavigationItem
+ *   config={gamificationConfig}
+ *   defaultIcon="trophy-outline"
+ *   defaultRoute="Gamification"
+ *   renderDescription={(cfg) => `${level} • ${points}`}
+ * />
+ * ```
+ */
+const SettingsNavigationItemComponent = <T extends SettingsNavigationItemConfig>({
+  config,
+  defaultIcon = "apps-outline",
+  defaultRoute,
+  renderDescription,
+  noBackground,
+  hideMargin,
+}: SettingsNavigationItemProps<T>) => {
+  const navigation = useSettingsNavigation();
+
+  const handlePress = React.useMemo(
+    () => createRouteOrPressHandler(navigation.navigate, {
+      route: config.route,
+      onPress: config.onPress,
+      fallback: defaultRoute,
+    }),
+    [navigation, config.route, config.onPress, defaultRoute]
+  );
+
+  const icon = (config.icon || defaultIcon) as IconName;
+  const description = renderDescription ? renderDescription(config) : config.description;
+
+  return (
+    <SettingsItemCard
+      title={config.title}
+      description={description}
+      icon={icon}
+      onPress={handlePress}
+      sectionTitle={config.sectionTitle}
+      noBackground={noBackground}
+      hideMargin={hideMargin}
+    />
+  );
+};
+
+/**
+ * Memoized Settings Navigation Item
+ * Uses shallow comparison by default
+ */
+export const SettingsNavigationItem = React.memo(
+  SettingsNavigationItemComponent
+) as typeof SettingsNavigationItemComponent & { displayName?: string };
+
+SettingsNavigationItem.displayName = "SettingsNavigationItem";

package/src/presentation/navigation/utils/index.ts

@@ -1,4 +1,11 @@
 /**
  * Navigation Utilities
  */
-export * from './navigationTranslations';
+export {
+  createNavigationHandler,
+  createRouteOrPressHandler,
+  createNavigationHandlerWithParams,
+} from './navigationHelpers';
+export type { NavigateFunction, RouteOrPressConfig } from './navigationHelpers';
+
+export { createNotificationTranslations, createQuietHoursTranslations, createLegalScreenProps } from './navigationTranslations';

package/src/presentation/navigation/utils/navigationHelpers.ts

@@ -0,0 +1,118 @@
+/**
+ * Navigation Helper Utilities
+ * Type-safe navigation handling to eliminate type casting
+ */
+
+import type { SettingsStackParamList } from '../types';
+
+/**
+ * Type for navigation function
+ */
+export type NavigateFunction = <RouteName extends keyof SettingsStackParamList>(
+  route: RouteName,
+  params?: SettingsStackParamList[RouteName]
+) => void;
+
+/**
+ * Create a type-safe navigation handler
+ *
+ * @param navigate - Navigation function from useNavigation
+ * @param route - Target route name
+ * @param fallback - Optional fallback route if primary route is undefined
+ * @returns Navigation handler function
+ *
+ * @example
+ * ```typescript
+ * const navigation = useSettingsNavigation();
+ * const handlePress = createNavigationHandler(
+ *   navigation.navigate,
+ *   config.route,
+ *   'Appearance'
+ * );
+ * ```
+ */
+export const createNavigationHandler = <T extends keyof SettingsStackParamList>(
+  navigate: NavigateFunction,
+  route: T | undefined,
+  fallback?: T
+) => {
+  return () => {
+    const targetRoute = route || fallback;
+    if (targetRoute) {
+      navigate(targetRoute);
+    }
+  };
+};
+
+/**
+ * Configuration for route or press handler
+ */
+export interface RouteOrPressConfig<T extends keyof SettingsStackParamList = keyof SettingsStackParamList> {
+  /** Route to navigate to */
+  route?: T;
+  /** Custom onPress handler */
+  onPress?: () => void;
+  /** Fallback route if primary route is undefined */
+  fallback?: T;
+}
+
+/**
+ * Create a handler that supports both route navigation and custom onPress
+ * Prioritizes onPress if provided, otherwise navigates to route
+ *
+ * @param navigate - Navigation function from useNavigation
+ * @param config - Configuration with route and/or onPress
+ * @returns Handler function
+ *
+ * @example
+ * ```typescript
+ * const navigation = useSettingsNavigation();
+ * const handlePress = createRouteOrPressHandler(
+ *   navigation.navigate,
+ *   { route: config.route, onPress: config.onPress, fallback: 'Appearance' }
+ * );
+ * ```
+ */
+export const createRouteOrPressHandler = <T extends keyof SettingsStackParamList>(
+  navigate: NavigateFunction,
+  config: RouteOrPressConfig<T>
+) => {
+  return () => {
+    if (config.onPress) {
+      config.onPress();
+    } else {
+      const targetRoute = config.route || config.fallback;
+      if (targetRoute) {
+        navigate(targetRoute);
+      }
+    }
+  };
+};
+
+/**
+ * Create a navigation handler with parameters
+ *
+ * @param navigate - Navigation function from useNavigation
+ * @param route - Target route name
+ * @param params - Navigation parameters for the route
+ * @returns Navigation handler function
+ *
+ * @example
+ * ```typescript
+ * const navigation = useSettingsNavigation();
+ * const handlePress = createNavigationHandlerWithParams(
+ *   navigation.navigate,
+ *   'LegalDetail',
+ *   { document: 'privacy' }
+ * );
+ * ```
+ */
+export const createNavigationHandlerWithParams = <T extends keyof SettingsStackParamList>(
+  navigate: NavigateFunction,
+  route: T,
+  params: SettingsStackParamList[T]
+) => {
+  return () => {
+    navigate(route, params);
+  };
+};

package/src/presentation/screens/components/SettingsContent.tsx

@@ -1,7 +1,8 @@
-import React, { useMemo } from "react";
+import React, { useMemo, useCallback } from "react";
 import { View, StyleSheet } from "react-native";
 import { SettingsFooter } from "../../components/SettingsFooter";
 import { SettingsSection } from "../../components/SettingsSection";
+import { SettingsNavigationItem } from "../../components/SettingsNavigationItem";
 import { DevSettingsSection } from "../../../domains/dev";
 import { DisclaimerSetting } from "../../../domains/disclaimer";
 import { ProfileSectionLoader } from "./sections/ProfileSectionLoader";
@@ -10,13 +11,9 @@ import { IdentitySettingsSection } from "./sections/IdentitySettingsSection";
 import { SupportSettingsSection } from "./sections/SupportSettingsSection";
 import { CustomSettingsList } from "./sections/CustomSettingsList";
 import { hasAnyFeaturesEnabled } from "./utils/featureChecker";
+import { useGamification } from "../../../domains/gamification";
 import type { SettingsContentProps } from "./types/SettingsContentProps";
 
-// Extracted Item Components
-import { SubscriptionSettingsItem } from "./SubscriptionSettingsItem";
-import { WalletSettingsItem } from "./WalletSettingsItem";
-import { GamificationSettingsItem } from "./GamificationSettingsItem";
-
 export const SettingsContent: React.FC<SettingsContentProps> = ({
   normalizedConfig,
   features,
@@ -31,11 +28,20 @@ export const SettingsContent: React.FC<SettingsContentProps> = ({
   gamificationConfig,
 }) => {
   const translations = normalizedConfig.translations;
+  const { level } = useGamification(gamificationConfig);
+
   const hasAnyFeatures = useMemo(
     () => hasAnyFeaturesEnabled(features, customSections),
     [features, customSections]
   );
 
+  const renderGamificationDescription = useCallback(
+    (cfg: typeof normalizedConfig.gamification.config) => {
+      return cfg?.description || `${level.currentLevel} • ${level.currentPoints}`;
+    },
+    [level.currentLevel, level.currentPoints]
+  );
+
   return (
     <View style={styles.container}>
       {showUserProfile && (
@@ -49,15 +55,17 @@ export const SettingsContent: React.FC<SettingsContentProps> = ({
 
       {features.subscription && (normalizedConfig.subscription.config?.route || normalizedConfig.subscription.config?.onPress) && (
         <SettingsSection title={translations?.sections?.subscription}>
-          <SubscriptionSettingsItem 
-            config={normalizedConfig.subscription.config} 
+          <SettingsNavigationItem
+            config={normalizedConfig.subscription.config}
+            defaultIcon="star"
           />
         </SettingsSection>
       )}
 
       {features.wallet && normalizedConfig.wallet.config?.route && (
-        <WalletSettingsItem
+        <SettingsNavigationItem
           config={normalizedConfig.wallet.config}
+          defaultIcon="wallet"
         />
       )}
 
@@ -65,9 +73,11 @@ export const SettingsContent: React.FC<SettingsContentProps> = ({
 
       {features.gamification && (
         <SettingsSection title={translations?.sections?.progress}>
-          <GamificationSettingsItem
+          <SettingsNavigationItem
             config={normalizedConfig.gamification.config || {}}
-            gamificationConfig={gamificationConfig}
+            defaultIcon="trophy-outline"
+            defaultRoute="Gamification"
+            renderDescription={renderGamificationDescription}
             noBackground={true}
             hideMargin={true}
           />

package/src/presentation/screens/components/sections/SupportSettingsSection.tsx

@@ -2,7 +2,7 @@ import React, { useCallback } from "react";
 import { SupportSection } from "../../../../domains/feedback/presentation/components/SupportSection";
 import { SettingsSection } from "../../../components/SettingsSection";
 import { SettingsItemCard } from "../../../components/SettingsItemCard";
-import { VideoTutorialSettingsItem } from "../VideoTutorialSettingsItem";
+import { SettingsNavigationItem } from "../../../components/SettingsNavigationItem";
 import type { NormalizedConfig } from "../../utils/normalizeConfig";
 import { compareConfigAndFeatures } from "../../../../infrastructure/utils/memoComparisonUtils";
 import { useSettingsNavigation } from "../../../navigation/hooks/useSettingsNavigation";
@@ -97,8 +97,10 @@ export const SupportSettingsSection: React.FC<SupportSettingsSectionProps> = ({
             )}
 
             {features.videoTutorial && (
-                <VideoTutorialSettingsItem
+                <SettingsNavigationItem
                     config={normalizedConfig.videoTutorial.config || {}}
+                    defaultIcon="play-circle-outline"
+                    defaultRoute="VideoTutorial"
                     noBackground={true}
                     hideMargin={true}
                 />

package/src/presentation/screens/types/UserFeatureConfig.ts

@@ -6,6 +6,7 @@
 import type { FeatureVisibility } from "./BaseTypes";
 import type { FeedbackType } from "../../../domains/feedback/domain/entities/FeedbackEntity";
 import type { FAQCategory } from "../../../domains/faqs/domain/entities/FAQEntity";
+import type { SettingsStackParamList } from "../../navigation/types";
 
 /**
  * User Profile Settings Configuration
@@ -114,7 +115,7 @@ export interface SubscriptionConfig {
   /** Custom section title for grouping */
   sectionTitle?: string;
   /** Navigation route for subscription screen (preferred over onPress) */
-  route?: string;
+  route?: keyof SettingsStackParamList;
   /** Handler to open subscription screen (use route instead for stack navigation) */
   onPress?: () => void;
   /** Whether user is premium (to show active status) */
@@ -136,7 +137,7 @@ export interface WalletConfig {
   /** Custom section title for grouping */
   sectionTitle?: string;
   /** Navigation route for wallet screen */
-  route?: string;
+  route?: keyof SettingsStackParamList;
   /** Current balance to display */
   balance?: number;
 }
@@ -156,7 +157,7 @@ export interface GamificationItemConfig {
   /** Custom section title for grouping */
   sectionTitle?: string;
   /** Navigation route for gamification screen */
-  route?: string;
+  route?: keyof SettingsStackParamList;
   /** Achievements to display */
   achievementsCount?: number;
 }
@@ -178,6 +179,6 @@ export interface VideoTutorialConfig {
   /** Handler to open video tutorial screen */
   onPress?: () => void;
   /** Navigation route for video tutorial screen */
-  route?: string;
+  route?: keyof SettingsStackParamList;
 }