@umituz/react-native-subscription 2.27.95 → 2.27.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.95",
+  "version": "2.27.97",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/credits/core/Credits.ts

@@ -6,6 +6,7 @@
  */
 
 import type { SubscriptionPackageType } from "../../../utils/packageTypeDetector";
+// Types imported from SubscriptionConstants are used directly in UserCredits interface
 import type {
   SubscriptionStatusType,
   PeriodType,
@@ -15,15 +16,6 @@ import type {
   PurchaseType
 } from "../../subscription/core/SubscriptionConstants";
 
-export type {
-  SubscriptionStatusType,
-  PeriodType,
-  PackageType,
-  Platform,
-  PurchaseSource,
-  PurchaseType
-};
-
 export type CreditType = "text" | "image";
 
 /** Single Source of Truth for user subscription + credits data */
@@ -67,10 +59,10 @@ export interface CreditAllocation {
   credits: number;
 }
 
-export type PackageAllocationMap = Record<
+export type PackageAllocationMap = Partial<Record<
   Exclude<SubscriptionPackageType, "unknown">,
   CreditAllocation
->;
+>>;
 
 export interface CreditsConfig {
   collectionName: string;

package/src/domains/credits/infrastructure/CreditsRepository.ts

@@ -12,6 +12,8 @@ import { CreditsMapper } from "../core/CreditsMapper";
 import type { RevenueCatData } from "../../subscription/core/RevenueCatData";
 import { DeductCreditsCommand } from "../application/DeductCreditsCommand";
 import { CreditLimitCalculator } from "../application/CreditLimitCalculator";
+import { PURCHASE_TYPE, type PurchaseType } from "../../subscription/core/SubscriptionConstants";
+import { updateDoc } from "firebase/firestore";
 
 export class CreditsRepository extends BaseRepository {
   private deductCommand: DeductCreditsCommand;
@@ -47,7 +49,8 @@ export class CreditsRepository extends BaseRepository {
     purchaseId: string,
     productId: string,
     source: PurchaseSource,
-    revenueCatData: RevenueCatData
+    revenueCatData: RevenueCatData,
+    type: PurchaseType = PURCHASE_TYPE.INITIAL
   ): Promise<CreditsResult> {
     const db = getFirestore();
     if (!db) {
@@ -70,6 +73,7 @@ export class CreditsRepository extends BaseRepository {
         originalTransactionId: revenueCatData.originalTransactionId,
         isPremium: revenueCatData.isPremium,
         periodType: revenueCatData.periodType,
+        type,
       }
     );
 
@@ -86,4 +90,27 @@ export class CreditsRepository extends BaseRepository {
   async deductCredit(userId: string, cost: number): Promise<DeductCreditsResult> {
     return this.deductCommand.execute(userId, cost);
   }
+
+  async hasCredits(userId: string, cost: number): Promise<boolean> {
+    const result = await this.getCredits(userId);
+    if (!result.success || !result.data) return false;
+    return result.data.credits >= cost;
+  }
+
+  async syncExpiredStatus(userId: string): Promise<void> {
+    const db = getFirestore();
+    if (!db) throw new Error("Firestore instance is not available");
+
+    const ref = this.getRef(db, userId);
+    await updateDoc(ref, {
+      isPremium: false,
+      status: "expired",
+      willRenew: false,
+      expirationDate: new Date().toISOString()
+    });
+  }
+}
+
+export function createCreditsRepository(config: CreditsConfig): CreditsRepository {
+  return new CreditsRepository(config);
 }

package/src/domains/paywall/components/PaywallContainer.tsx

@@ -49,9 +49,25 @@ export const PaywallContainer: React.FC<PaywallContainerProps> = (props) => {
   });
 
   // Check trial eligibility only if trialConfig is enabled
+  // Use ref to track if we've already checked for these packages to avoid redundant calls
+  const checkedPackagesRef = React.useRef<string[]>([]);
+
   useEffect(() => {
     if (!trialConfig?.enabled) return;
     if (packages.length === 0) return;
+    if (isLoading) return; // Wait for packages to fully load
+
+    // Get current package identifiers
+    const currentPackageIds = packages.map((pkg) => pkg.product.identifier);
+    const sortedIds = [...currentPackageIds].sort().join(",");
+
+    // Skip if we've already checked these exact packages
+    if (checkedPackagesRef.current.join(",") === sortedIds) {
+      return;
+    }
+
+    // Update ref
+    checkedPackagesRef.current = currentPackageIds;
 
     // Get all actual product IDs from packages
     const allProductIds = packages.map((pkg) => pkg.product.identifier);
@@ -72,7 +88,7 @@ export const PaywallContainer: React.FC<PaywallContainerProps> = (props) => {
     if (productIdsToCheck.length > 0) {
       checkEligibility(productIdsToCheck);
     }
-  }, [packages, checkEligibility, trialConfig?.enabled, trialConfig?.eligibleProductIds]);
+  }, [packages, isLoading, checkEligibility, trialConfig?.enabled, trialConfig?.eligibleProductIds]);
 
   // Convert eligibility map to format expected by PaywallModal
   // Only process if trial is enabled

package/src/domains/paywall/components/PaywallContainer.types.ts

@@ -5,7 +5,8 @@
 
 import type { ImageSourcePropType } from "react-native";
 import type { PaywallTranslations, PaywallLegalUrls, SubscriptionFeature } from "../entities/types";
-import type { PurchaseSource, PackageAllocationMap } from "../../credits/core/Credits";
+import type { PurchaseSource } from "../../subscription/core/SubscriptionConstants";
+import type { PackageAllocationMap } from "../../credits/core/Credits";
 
 /**
  * Trial display configuration

package/src/domains/paywall/hooks/usePaywallActions.ts

@@ -2,7 +2,7 @@ import { useCallback } from "react";
 import type { PurchasesPackage } from "react-native-purchases";
 import { useRestorePurchase } from "../../subscription/infrastructure/hooks/useRestorePurchase";
 import { useAuthAwarePurchase } from "../../subscription/presentation/useAuthAwarePurchase";
-import type { PurchaseSource } from "../../credits/core/Credits";
+import type { PurchaseSource } from "../../subscription/core/SubscriptionConstants";
 
 interface UsePaywallActionsProps {
   source?: PurchaseSource;

package/src/domains/subscription/application/SubscriptionInitializer.ts

@@ -92,7 +92,7 @@ export const initializeSubscription = async (config: SubscriptionInitConfig): Pr
     showAuthModal,
   });
 
-  const initializeInBackground = async (userId: string): Promise<void> => {
+  const initializeInBackground = async (userId?: string): Promise<void> => {
     await SubscriptionManager.initialize(userId);
     if (__DEV__) {
       console.log('[SubscriptionInitializer] Background init complete');

package/src/domains/subscription/application/SubscriptionSyncService.ts

@@ -1,6 +1,6 @@
 import type { CustomerInfo } from "react-native-purchases";
 import type { RevenueCatData } from "../core/RevenueCatData";
-import { type PeriodType, type PurchaseSource } from "../core/SubscriptionConstants";
+import { type PeriodType, type PurchaseSource, PURCHASE_SOURCE, PURCHASE_TYPE } from "../core/SubscriptionConstants";
 import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryProvider";
 import { extractRevenueCatData } from "./SubscriptionSyncUtils";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
@@ -19,7 +19,14 @@ export class SubscriptionSyncService {
         ? `purchase_${revenueCatData.originalTransactionId}`
         : `purchase_${productId}_${Date.now()}`;
 
-      await getCreditsRepository().initializeCredits(userId, purchaseId, productId, source, revenueCatData);
+      await getCreditsRepository().initializeCredits(
+        userId, 
+        purchaseId, 
+        productId, 
+        source ?? PURCHASE_SOURCE.SETTINGS, // Default to settings if source unknown
+        revenueCatData,
+        PURCHASE_TYPE.INITIAL // Default to INITIAL
+      );
       
       // Notify listeners via Event Bus
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
@@ -37,7 +44,14 @@ export class SubscriptionSyncService {
         ? `renewal_${revenueCatData.originalTransactionId}_${newExpirationDate}`
         : `renewal_${productId}_${Date.now()}`;
 
-      await getCreditsRepository().initializeCredits(userId, purchaseId, productId, "renewal", revenueCatData);
+      await getCreditsRepository().initializeCredits(
+        userId, 
+        purchaseId, 
+        productId, 
+        PURCHASE_SOURCE.RENEWAL, 
+        revenueCatData,
+        PURCHASE_TYPE.RENEWAL
+      );
       
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.RENEWAL_DETECTED, { userId, productId });
@@ -61,14 +75,27 @@ export class SubscriptionSyncService {
         return;
       }
 
+      // If productId is missing, we can't initialize credits fully, 
+      // but if isPremium is true, we should have it.
+      // Fallback to 'unknown' if missing, but this might throw in CreditLimitCalculator.
+      const validProductId = productId ?? 'unknown_product';
+
       const revenueCatData: RevenueCatData = { 
         expirationDate: expiresAt ?? null, 
         willRenew: willRenew ?? false, 
         isPremium, 
-        periodType 
+        periodType: periodType ?? null, // Fix undefined vs null
+        originalTransactionId: null // Initialize with null as we might not have it here
       };
       
-      await getCreditsRepository().initializeCredits(userId, `status_sync_${Date.now()}`, productId, "settings", revenueCatData);
+      await getCreditsRepository().initializeCredits(
+        userId, 
+        `status_sync_${Date.now()}`, 
+        validProductId, 
+        PURCHASE_SOURCE.SETTINGS, 
+        revenueCatData,
+        PURCHASE_TYPE.INITIAL // Status sync treated as Initial or Update
+      );
       
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED, { userId, isPremium });

package/src/domains/subscription/application/SubscriptionSyncUtils.ts

@@ -12,7 +12,7 @@ export const extractRevenueCatData = (customerInfo: CustomerInfo, entitlementId:
     willRenew: entitlement?.willRenew ?? false,
     // Use latestPurchaseDate if originalPurchaseDate is missing, or a combine id
     originalTransactionId: entitlement?.originalPurchaseDate || customerInfo.firstSeen, 
-    periodType: entitlement?.periodType as PeriodType | undefined,
+    periodType: (entitlement?.periodType as PeriodType) ?? null,
     isPremium: !!customerInfo.entitlements.active[entitlementId],
   };
 };

package/src/domains/subscription/infrastructure/handlers/PackageHandler.ts

@@ -25,21 +25,41 @@ export class PackageHandler {
 
   async fetchPackages(): Promise<PurchasesPackage[]> {
     if (!this.service.isInitialized()) {
-      throw new Error("Service not initialized");
+      throw new Error("Service not initialized. Please initialize before fetching packages.");
     }
 
-    const offering = await this.service.fetchOfferings();
-
-    if (!offering) {
-      throw new Error("No offerings available");
+    try {
+      const offering = await this.service.fetchOfferings();
+
+      if (!offering) {
+        if (__DEV__) {
+          console.warn("[PackageHandler] No offerings available from RevenueCat");
+        }
+        // Return empty array instead of throwing - allows graceful degradation
+        return [];
+      }
+
+      const packages = offering.availablePackages;
+      if (!packages || packages.length === 0) {
+        if (__DEV__) {
+          console.warn("[PackageHandler] No packages available in offering");
+        }
+        // Return empty array instead of throwing - allows graceful degradation
+        return [];
+      }
+
+      return packages;
+    } catch (error) {
+      if (__DEV__) {
+        console.error("[PackageHandler] Failed to fetch packages:", error);
+      }
+      // Re-throw with more context
+      throw new Error(
+        `Failed to fetch subscription packages. ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`
+      );
     }
-
-    const packages = offering.availablePackages;
-    if (!packages) {
-      throw new Error("No packages available in offering");
-    }
-
-    return packages;
   }
 
   async purchase(pkg: PurchasesPackage, userId: string): Promise<boolean> {

package/src/domains/subscription/infrastructure/hooks/subscriptionQueryKeys.ts

@@ -3,6 +3,9 @@
  * TanStack Query keys and constants for subscription state
  */
 
+/** Query cache time constants */
+
+
 /**
  * Query keys for TanStack Query
  */
@@ -12,7 +15,4 @@ export const SUBSCRIPTION_QUERY_KEYS = {
     ["subscription", "initialized", userId] as const,
 } as const;
 
-// No cache - always fetch fresh data for subscription packages
-// This ensures users always see real-time subscription status
-export const STALE_TIME = 0; // Always stale - refetch immediately
-export const GC_TIME = 0; // Don't cache - garbage collect immediately
+

package/src/domains/subscription/infrastructure/hooks/useSubscriptionPackages.ts

@@ -12,8 +12,6 @@ import {
 import { SubscriptionManager } from '../../infrastructure/managers/SubscriptionManager';
 import {
   SUBSCRIPTION_QUERY_KEYS,
-  STALE_TIME,
-  GC_TIME,
 } from "./subscriptionQueryKeys";
 
 /**
@@ -41,11 +39,7 @@ export const useSubscriptionPackages = () => {
 
       return SubscriptionManager.getPackages();
     },
-    staleTime: STALE_TIME,
-    gcTime: GC_TIME,
     enabled: isConfigured,
-    refetchOnMount: true,
-    refetchOnWindowFocus: true, // Refetch when app becomes active
-    refetchOnReconnect: true, // Refetch when network reconnects
+
   });
 };

package/src/domains/subscription/infrastructure/hooks/useSubscriptionQueries.ts

@@ -6,8 +6,6 @@
 
 export {
   SUBSCRIPTION_QUERY_KEYS,
-  STALE_TIME,
-  GC_TIME,
 } from "./subscriptionQueryKeys";
 export { useInitializeSubscription } from "./useInitializeSubscription";
 export { useSubscriptionPackages } from "./useSubscriptionPackages";

package/src/domains/subscription/infrastructure/managers/SubscriptionManager.ts

@@ -53,10 +53,11 @@ class SubscriptionManagerImpl {
     }
   }
 
-  async initialize(userId: string): Promise<boolean> {
+  async initialize(userId?: string): Promise<boolean> {
     this.ensureConfigured();
 
-    const { shouldInit, existingPromise } = this.state.initCache.tryAcquireInitialization(userId);
+    const actualUserId = userId ?? (await this.managerConfig!.getAnonymousUserId());
+    const { shouldInit, existingPromise } = this.state.initCache.tryAcquireInitialization(actualUserId);
 
     if (!shouldInit && existingPromise) {
       return existingPromise;
@@ -71,11 +72,11 @@ class SubscriptionManagerImpl {
         }
 
         this.ensurePackageHandlerInitialized();
-        const result = await this.serviceInstance.initialize(userId);
+        const result = await this.serviceInstance.initialize(actualUserId);
         return result.success;
     })();
 
-    this.state.initCache.setPromise(promise, userId);
+    this.state.initCache.setPromise(promise, actualUserId);
     return promise;
   }
 

package/src/domains/subscription/infrastructure/utils/InitializationCache.ts

@@ -11,6 +11,8 @@ export class InitializationCache {
     private initializationInProgress = false;
     // Track which userId the promise is for (separate from currentUserId which is set after completion)
     private promiseUserId: string | null = null;
+    // Track promise completion state to avoid returning failed promises
+    private promiseCompleted = true;
 
     /**
      * Atomically check if reinitialization is needed AND reserve the slot
@@ -22,17 +24,24 @@ export class InitializationCache {
             return { shouldInit: false, existingPromise: this.initPromise };
         }
 
-        // If already initialized for this user and promise resolved successfully, return it
-        if (this.initPromise && this.currentUserId === userId && !this.initializationInProgress) {
+        // If already initialized for this user and promise completed successfully, return it
+        // Only return cached promise if it completed AND it's for the same user
+        if (this.initPromise && this.currentUserId === userId && !this.initializationInProgress && this.promiseCompleted) {
             return { shouldInit: false, existingPromise: this.initPromise };
         }
 
-        // Different user or no initialization - need to reinitialize
-        // Atomically set the flag
-        this.initializationInProgress = true;
-        this.promiseUserId = userId;
+        // Different user, no initialization, or failed promise - need to reinitialize
+        // Atomically set the flag and clear previous state if needed
+        if (!this.initializationInProgress) {
+            this.initializationInProgress = true;
+            this.promiseUserId = userId;
+            this.promiseCompleted = false;
+            return { shouldInit: true, existingPromise: null };
+        }
 
-        return { shouldInit: true, existingPromise: null };
+        // If we reach here, initialization is in progress for a different user
+        // Wait for current initialization to complete
+        return { shouldInit: false, existingPromise: this.initPromise };
     }
 
     setPromise(promise: Promise<boolean>, userId: string): void {
@@ -45,6 +54,7 @@ export class InitializationCache {
                 if (result && this.promiseUserId === userId) {
                     this.currentUserId = userId;
                 }
+                this.promiseCompleted = true;
                 return result;
             })
             .catch(() => {
@@ -52,7 +62,9 @@ export class InitializationCache {
                 if (this.promiseUserId === userId) {
                     this.initPromise = null;
                     this.promiseUserId = null;
+                    this.currentUserId = null; // Clear user on failure
                 }
+                this.promiseCompleted = true;
             })
             .finally(() => {
                 // Always release the mutex
@@ -71,5 +83,6 @@ export class InitializationCache {
         this.currentUserId = null;
         this.initializationInProgress = false;
         this.promiseUserId = null;
+        this.promiseCompleted = true;
     }
 }

package/src/domains/subscription/infrastructure/utils/PremiumStatusSyncer.ts

@@ -5,7 +5,7 @@
 
 import type { CustomerInfo } from "react-native-purchases";
 import type { RevenueCatConfig } from "../../core/RevenueCatConfig";
-import type { PurchaseSource } from "../../../credits/core/Credits";
+import type { PurchaseSource } from "../../../subscription/core/SubscriptionConstants";
 import { getPremiumEntitlement } from "../../core/RevenueCatTypes";
 
 export async function syncPremiumStatus(

package/src/domains/subscription/presentation/screens/SubscriptionDetailScreen.tsx

@@ -11,22 +11,61 @@ import {
     ScreenLayout,
 } from "@umituz/react-native-design-system";
 import { SubscriptionHeader } from "./components/SubscriptionHeader";
-import { CreditsList } from "./components/CreditsList";
-import { UpgradePrompt } from "./components/UpgradePrompt";
-import { DevTestSection } from "./components/DevTestSection";
-import type { SubscriptionDetailScreenProps } from "../types/SubscriptionDetailTypes";
+import { CreditsList, type CreditItem } from "./components/CreditsList";
+import { UpgradePrompt, type Benefit } from "./components/UpgradePrompt";
+import { DevTestSection, type DevTestActions } from "./components/DevTestSection";
 
-export type {
-  SubscriptionDisplayFlags,
-  SubscriptionDetailTranslations,
-  SubscriptionDetailConfig,
-  SubscriptionDetailScreenProps,
-  DevTestActions,
-  DevToolsConfig,
-  UpgradeBenefit,
-  UpgradePromptConfig,
-  UpgradePromptProps,
-} from "../types/SubscriptionDetailTypes";
+export interface SubscriptionDisplayFlags {
+  showHeader: boolean;
+  showCredits: boolean;
+  showUpgradePrompt: boolean;
+  showExpirationDate: boolean;
+}
+
+export interface SubscriptionDetailTranslations {
+  title: string;
+  statusActive: string;
+  statusExpired: string;
+  statusFree: string;
+  statusCanceled: string;
+  statusLabel: string;
+  lifetimeLabel: string;
+  expiresLabel: string;
+  purchasedLabel: string;
+  usageTitle?: string;
+  creditsTitle: string;
+  creditsResetInfo?: string;
+  remainingLabel?: string;
+  upgradeButton: string;
+}
+
+export interface DevToolsConfig {
+  actions: DevTestActions;
+  title?: string;
+}
+
+export interface UpgradePromptConfig {
+  title: string;
+  subtitle?: string;
+  benefits?: readonly Benefit[];
+}
+
+export interface SubscriptionDetailConfig {
+  display: SubscriptionDisplayFlags;
+  statusType: "active" | "expired" | "none" | "canceled";
+  isLifetime: boolean;
+  expirationDate?: string;
+  purchaseDate?: string;
+  daysRemaining?: number | null;
+  credits?: readonly CreditItem[];
+  translations: SubscriptionDetailTranslations;
+  upgradePrompt?: UpgradePromptConfig & { onUpgrade?: () => void };
+  devTools?: DevToolsConfig;
+}
+
+export interface SubscriptionDetailScreenProps {
+  config: SubscriptionDetailConfig;
+}
 
 export const SubscriptionDetailScreen: React.FC<
   SubscriptionDetailScreenProps
@@ -98,7 +137,7 @@ export const SubscriptionDetailScreen: React.FC<
             subtitle={config.upgradePrompt.subtitle}
             benefits={config.upgradePrompt.benefits}
             upgradeButtonLabel={config.translations.upgradeButton}
-            onUpgrade={config.onUpgrade}
+            onUpgrade={config.upgradePrompt.onUpgrade ?? (() => {})}
           />
         )}
       </View>

package/src/domains/subscription/presentation/screens/components/CreditsList.tsx

@@ -7,7 +7,20 @@ import React, { useMemo } from "react";
 import { View, StyleSheet } from "react-native";
 import { useAppDesignTokens, AtomicText } from "@umituz/react-native-design-system";
 import { CreditRow } from "../../components/details/CreditRow";
-import type { CreditsListProps } from "../../types/SubscriptionDetailTypes";
+
+export interface CreditItem {
+  id: string;
+  label: string;
+  current: number;
+  total: number;
+}
+
+export interface CreditsListProps {
+  credits: readonly CreditItem[];
+  title?: string;
+  description?: string;
+  remainingLabel?: string;
+}
 
 export const CreditsList: React.FC<CreditsListProps> = ({
   credits,

package/src/domains/subscription/presentation/screens/components/DevTestSection.tsx

@@ -7,9 +7,17 @@
 import React, { useMemo } from "react";
 import { View, TouchableOpacity, StyleSheet } from "react-native";
 import { AtomicText, useAppDesignTokens } from "@umituz/react-native-design-system";
-import type { DevTestSectionProps } from "../../types/SubscriptionDetailTypes";
 
-export type { DevTestActions, DevTestSectionProps } from "../../types/SubscriptionDetailTypes";
+export interface DevTestActions {
+  onTestRenewal: () => void;
+  onCheckCredits: () => void;
+  onTestDuplicate: () => void;
+}
+
+export interface DevTestSectionProps {
+  actions: DevTestActions;
+  title?: string;
+}
 
 /** Dev test button translations */
 export interface DevTestTranslations {

package/src/domains/subscription/presentation/screens/components/SubscriptionActions.tsx

@@ -6,7 +6,12 @@
 import React, { useMemo } from "react";
 import { View, StyleSheet, TouchableOpacity } from "react-native";
 import { useAppDesignTokens, AtomicText } from "@umituz/react-native-design-system";
-import type { SubscriptionActionsProps } from "../../types/SubscriptionDetailTypes";
+
+export interface SubscriptionActionsProps {
+  isPremium: boolean;
+  upgradeButtonLabel?: string;
+  onUpgrade?: () => void;
+}
 
 export const SubscriptionActions: React.FC<SubscriptionActionsProps> = ({
   isPremium,

package/src/domains/subscription/presentation/screens/components/SubscriptionHeader.tsx

@@ -8,7 +8,26 @@ import { View, StyleSheet } from "react-native";
 import { useAppDesignTokens, AtomicText } from "@umituz/react-native-design-system";
 import { PremiumStatusBadge } from "../../components/details/PremiumStatusBadge";
 import { DetailRow } from "../../components/details/DetailRow";
-import type { SubscriptionHeaderProps } from "../../types/SubscriptionDetailTypes";
+
+export interface SubscriptionHeaderProps {
+  statusType: "active" | "expired" | "none" | "canceled";
+  showExpirationDate: boolean;
+  isLifetime: boolean;
+  expirationDate?: string;
+  purchaseDate?: string;
+  daysRemaining?: number | null;
+  translations: {
+    title: string;
+    statusActive: string;
+    statusExpired: string;
+    statusFree: string;
+    statusCanceled: string;
+    statusLabel: string;
+    lifetimeLabel: string;
+    expiresLabel: string;
+    purchasedLabel: string;
+  };
+}
 
 export const SubscriptionHeader: React.FC<SubscriptionHeaderProps> = ({
   statusType,

package/src/domains/subscription/presentation/screens/components/UpgradePrompt.tsx

@@ -10,7 +10,19 @@ import {
     AtomicText,
     AtomicIcon,
 } from "@umituz/react-native-design-system";
-import type { UpgradePromptProps } from "../../types/SubscriptionDetailTypes";
+
+export interface Benefit {
+  icon?: string;
+  text: string;
+}
+
+export interface UpgradePromptProps {
+  title: string;
+  subtitle?: string;
+  benefits?: readonly Benefit[];
+  upgradeButtonLabel: string;
+  onUpgrade: () => void;
+}
 
 export const UpgradePrompt: React.FC<UpgradePromptProps> = ({
   title,

package/src/domains/subscription/presentation/useAuthAwarePurchase.ts

@@ -6,7 +6,7 @@
 import { useCallback } from "react";
 import type { PurchasesPackage } from "react-native-purchases";
 import { usePremium } from "./usePremium";
-import type { PurchaseSource } from "../../credits/core/Credits";
+import type { PurchaseSource } from "../core/SubscriptionConstants";
 
 export interface PurchaseAuthProvider {
   isAuthenticated: () => boolean;