Types

const user = await Rovenue.currentUser();

if (user.appUserId) {
  console.log(`Known user: ${user.appUserId}`);
} else {
  console.log(`Anonymous install: ${user.rovenueId}`);
}

let user = await Rovenue.shared.currentUser()

if let appUserId = user.appUserId {
    print("Known user: \(appUserId)")
} else {
    print("Anonymous install: \(user.rovenueId)")
}

val user = Rovenue.shared.currentUser()

if (user.appUserId != null) {
    Log.d("App", "Known user: ${user.appUserId}")
} else {
    Log.d("App", "Anonymous install: ${user.rovenueId}")
}

const ent = await Rovenue.entitlement('pro');

if (ent?.isActive) {
  // Grant Pro access
  const expiresAt = ent.expiresIso
    ? new Date(ent.expiresIso)
    : null; // null = lifetime
}

let ent = await Rovenue.shared.entitlement(id: "pro")

if ent?.isActive == true {
    // Grant Pro access
    let expiresAt = ent?.expiresIso.flatMap { ISO8601DateFormatter().date(from: $0) }
}

val ent = Rovenue.shared.entitlement(id = "pro")

if (ent?.isActive == true) {
    // Grant Pro access
    val expiresAt = ent.expiresIso?.let { Instant.parse(it) } // null = lifetime
}

const pkg = offerings.current?.packages[0];
if (pkg) {
  const {
    displayName, priceString, type, description, subscriptionPeriod,
    pricePerMonthString, isEligibleForIntroOffer
  } = pkg.product;
  
  console.log(`${displayName} — ${priceString}`);
  console.log(`Description: ${description}`);
  
  if (subscriptionPeriod) {
    console.log(`Billing: every ${subscriptionPeriod.value} ${subscriptionPeriod.unit}`);
    console.log(`~${pricePerMonthString}/month`);
  }
  
  if (isEligibleForIntroOffer) {
    console.log('Eligible for intro offer');
  }
}

let pkg = offerings.current?.packages.first
if let product = pkg?.product {
  print("\(product.displayName) — \(product.priceString ?? "N/A")")
  
  if let period = product.subscriptionPeriod {
    print("Billing: every \(period.value) \(period.unit)")
    print("~\(product.pricePerMonthString ?? "N/A")/month")
  }
  
  if let intro = product.introPrice {
    print("Intro: \(intro.priceString ?? "free") for \(intro.cycles) cycles")
  }
  
  // Access promotional offers (iOS-specific)
  for discount in product.discounts {
    print("Promo: \(discount.priceString ?? "free")")
  }
  
  // Access native StoreKit.Product if needed
  if let native = product.rawStoreProduct {
    print("Native product: \(native.id)")
  }
}

val pkg = offerings.current?.packages.firstOrNull()
pkg?.product?.let { product ->
  println("${product.displayName} — ${product.priceString ?: "N/A"}")
  
  product.subscriptionPeriod?.let { period ->
    println("Billing: every ${period.value} ${period.unit}")
    println("~${product.pricePerMonthString ?: "N/A"}/month")
  }
  
  product.introPrice?.let { intro ->
    println("Intro: ${intro.priceString ?: "free"} for ${intro.cycles} cycles")
  }
  
  // Access Android subscription options
  product.subscriptionOptions?.forEach { option ->
    println("Option: ${option.id}")
    option.pricingPhases.forEach { phase ->
      println("  Phase: ${phase.priceString} (${phase.recurrenceMode})")
    }
  }
  
  // Access native ProductDetails if needed
  product.rawStoreProduct?.let { native ->
    println("Native product: ${native.productId}")
  }
}

const offerings = await Rovenue.getOfferings();
const offering = offerings.current;

// Find by packageType
const monthly = offering?.packages.find(p => p.packageType === 'monthly');

// Find by identifier
const annual = offering?.packages.find(p => p.identifier === 'annual');

let offering = offerings.current

// Access by PackageType enum
let monthly = offering?.monthly    // Package? matching .monthly
let annual = offering?.annual      // Package? matching .annual
let weekly = offering?.weekly      // Package? matching .weekly
let sixMonth = offering?.sixMonth
let threeMonth = offering?.threeMonth
let twoMonth = offering?.twoMonth
let lifetime = offering?.lifetime

// Or look up by identifier
let custom = offering?.package(identifier: "pro_custom")

val offering = offerings.current

// Access by PackageType enum
val monthly = offering?.monthly    // Package? matching MONTHLY
val annual = offering?.annual      // Package? matching ANNUAL
val weekly = offering?.weekly      // Package? matching WEEKLY
val sixMonth = offering?.sixMonth
val threeMonth = offering?.threeMonth
val twoMonth = offering?.twoMonth
val lifetime = offering?.lifetime

// Or look up by identifier
val custom = offering?.packageBy("\$rov_monthly")

const offerings = await Rovenue.getOfferings();
const pkg = offerings.current?.packages.find(p => p.identifier === 'annual');

if (pkg) {
  console.log(`Annual plan: ${pkg.product.priceString}`);
  console.log(`Type: ${pkg.packageType}`);
  const result = await Rovenue.purchase(pkg);
}

let offerings = try await Rovenue.shared.getOfferings()
let pkg = offerings.current?.packages.first { $0.identifier == "annual" }

if let pkg = pkg {
  print("Annual plan: \(pkg.product.priceString ?? "N/A")")
  print("Type: \(pkg.packageType)")
  let result = try await Rovenue.shared.purchase(pkg)
}

val offerings = Rovenue.shared.getOfferings()
val pkg = offerings.current?.packages?.find { it.identifier == "annual" }

pkg?.let {
  println("Annual plan: ${it.product.priceString}")
  println("Type: ${it.packageType}")
  val result = Rovenue.shared.purchase(it)
}

const offerings = await Rovenue.getOfferings();

// Show the default paywall:
const packages = offerings.current?.packages ?? [];

// Or show a specific named offering (e.g. for an A/B test):
const saleOffering = offerings.all['sale_q4'];

let offerings = try await Rovenue.shared.getOfferings()

// Show the default paywall:
let packages = offerings.current?.packages ?? []

// Or show a specific offering:
let saleOffering = offerings.all["sale_q4"]

val offerings = Rovenue.shared.getOfferings()

// Show the default paywall:
val packages = offerings.current?.packages ?: emptyList()

// Or show a specific offering:
val saleOffering = offerings.all["sale_q4"]

const unsub = Rovenue.addChangeListener(async (event) => {
  if (event === 'ENTITLEMENTS_CHANGED') {
    const ent = await Rovenue.entitlement('pro');
    setHasPro(ent?.isActive ?? false);
  }
  if (event === 'VIRTUAL_CURRENCIES_CHANGED') {
    const balances = Rovenue.virtualCurrencies();
    setCoins(balances['COINS'] ?? 0);
  }
});

return () => unsub(); // cleanup on unmount

Task {
  for await event in Rovenue.shared.changes {
    switch event {
    case .entitlementsChanged:
      let ent = await Rovenue.shared.entitlement(id: "pro")
      await MainActor.run { hasPro = ent?.isActive ?? false }
    case .virtualCurrenciesChanged:
      let balances = await Rovenue.shared.virtualCurrencyBalances()
      await MainActor.run { self.coins = balances["COINS"] ?? 0 }
    case .identityChanged:
      break
    case .remoteConfigChanged:
      break
    }
  }
}

Rovenue.shared.changes
    .onEach { event ->
        when (event) {
            ChangeEvent.ENTITLEMENTS_CHANGED -> {
                val ent = Rovenue.shared.entitlement(id = "pro")
                _hasPro.value = ent?.isActive == true
            }
            ChangeEvent.VIRTUAL_CURRENCIES_CHANGED -> {
                val balances = Rovenue.shared.virtualCurrencyBalances()
                _coins.value = balances["COINS"] ?: 0
            }
            ChangeEvent.IDENTITY_CHANGED -> { /* re-read user if needed */ }
            ChangeEvent.REMOTE_CONFIG_CHANGED -> { /* re-read flags/experiments */ }
        }
    }
    .launchIn(viewModelScope)