react-native-iap 14.3.5-rc.1 → 14.3.6

package/nitrogen/generated/android/kotlin/com/margelo/nitro/iap/Variant_PurchaseAndroid_PurchaseIOS.kt

@@ -0,0 +1,42 @@
+///
+/// Variant_PurchaseAndroid_PurchaseIOS.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.iap
+
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the TypeScript variant "PurchaseAndroid|PurchaseIOS".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class Variant_PurchaseAndroid_PurchaseIOS {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: PurchaseAndroid): Variant_PurchaseAndroid_PurchaseIOS()
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: PurchaseIOS): Variant_PurchaseAndroid_PurchaseIOS()
+
+  inline fun <reified T> getAs(): T? = when (this) {
+    is First -> value as? T
+    is Second -> value as? T
+  }
+
+  val isFirst: Boolean
+    get() = this is First
+  val isSecond: Boolean
+    get() = this is Second
+
+  companion object {
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: PurchaseAndroid): Variant_PurchaseAndroid_PurchaseIOS = First(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: PurchaseIOS): Variant_PurchaseAndroid_PurchaseIOS = Second(value)
+  }
+}

package/nitrogen/generated/ios/NitroIap-Swift-Cxx-Bridge.cpp

@@ -37,11 +37,11 @@ namespace margelo::nitro::iap::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void()>
-  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper) noexcept {
-    auto swiftClosure = NitroIap::Func_void::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
-      swiftClosure.call();
+  // pragma MARK: std::function<void(const RequestPurchaseResult& /* result */)>
+  Func_void_RequestPurchaseResult create_Func_void_RequestPurchaseResult(void* _Nonnull swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroIap::Func_void_RequestPurchaseResult::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const RequestPurchaseResult& result) mutable -> void {
+      swiftClosure.call(result);
     };
   }
   
@@ -109,6 +109,14 @@ namespace margelo::nitro::iap::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void()>
+  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroIap::Func_void::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
+      swiftClosure.call();
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::optional<std::vector<NitroSubscriptionStatus>>& /* result */)>
   Func_void_std__optional_std__vector_NitroSubscriptionStatus__ create_Func_void_std__optional_std__vector_NitroSubscriptionStatus__(void* _Nonnull swiftClosureWrapper) noexcept {
     auto swiftClosure = NitroIap::Func_void_std__optional_std__vector_NitroSubscriptionStatus__::fromUnsafe(swiftClosureWrapper);

package/nitrogen/generated/ios/NitroIap-Swift-Cxx-Bridge.hpp

@@ -10,6 +10,8 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `HybridRnIapSpec` to properly resolve imports.
 namespace margelo::nitro::iap { class HybridRnIapSpec; }
+// Forward declaration of `IapPlatform` to properly resolve imports.
+namespace margelo::nitro::iap { enum class IapPlatform; }
 // Forward declaration of `NitroAvailablePurchasesAndroidOptions` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroAvailablePurchasesAndroidOptions; }
 // Forward declaration of `NitroAvailablePurchasesIosOptions` to properly resolve imports.
@@ -42,6 +44,16 @@ namespace margelo::nitro::iap { struct NitroSubscriptionOffer; }
 namespace margelo::nitro::iap { struct NitroSubscriptionRenewalInfo; }
 // Forward declaration of `NitroSubscriptionStatus` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroSubscriptionStatus; }
+// Forward declaration of `PurchaseAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { struct PurchaseAndroid; }
+// Forward declaration of `PurchaseIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct PurchaseIOS; }
+// Forward declaration of `PurchaseOfferIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct PurchaseOfferIOS; }
+// Forward declaration of `PurchaseState` to properly resolve imports.
+namespace margelo::nitro::iap { enum class PurchaseState; }
+// Forward declaration of `RequestPurchaseResult` to properly resolve imports.
+namespace margelo::nitro::iap { struct RequestPurchaseResult; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridRnIapSpec_cxx` to properly resolve imports.
@@ -49,6 +61,7 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 
 // Include C++ defined types
 #include "HybridRnIapSpec.hpp"
+#include "IapPlatform.hpp"
 #include "NitroAvailablePurchasesAndroidOptions.hpp"
 #include "NitroAvailablePurchasesIosOptions.hpp"
 #include "NitroAvailablePurchasesOptions.hpp"
@@ -65,6 +78,11 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "NitroSubscriptionOffer.hpp"
 #include "NitroSubscriptionRenewalInfo.hpp"
 #include "NitroSubscriptionStatus.hpp"
+#include "PurchaseAndroid.hpp"
+#include "PurchaseIOS.hpp"
+#include "PurchaseOfferIOS.hpp"
+#include "PurchaseState.hpp"
+#include "RequestPurchaseResult.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -240,38 +258,138 @@ namespace margelo::nitro::iap::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::shared_ptr<Promise<void>>
+  // pragma MARK: std::optional<std::vector<std::string>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   * Specialized version of `std::optional<std::vector<std::string>>`.
    */
-  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
-  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
-    return Promise<void>::create();
+  using std__optional_std__vector_std__string__ = std::optional<std::vector<std::string>>;
+  inline std::optional<std::vector<std::string>> create_std__optional_std__vector_std__string__(const std::vector<std::string>& value) noexcept {
+    return std::optional<std::vector<std::string>>(value);
   }
-  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
-    return PromiseHolder<void>(std::move(promise));
+  inline bool has_value_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<std::string> get_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return *optional;
   }
   
-  // pragma MARK: std::function<void()>
+  // pragma MARK: std::optional<PurchaseOfferIOS>
   /**
-   * Specialized version of `std::function<void()>`.
+   * Specialized version of `std::optional<PurchaseOfferIOS>`.
    */
-  using Func_void = std::function<void()>;
+  using std__optional_PurchaseOfferIOS_ = std::optional<PurchaseOfferIOS>;
+  inline std::optional<PurchaseOfferIOS> create_std__optional_PurchaseOfferIOS_(const PurchaseOfferIOS& value) noexcept {
+    return std::optional<PurchaseOfferIOS>(value);
+  }
+  inline bool has_value_std__optional_PurchaseOfferIOS_(const std::optional<PurchaseOfferIOS>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline PurchaseOfferIOS get_std__optional_PurchaseOfferIOS_(const std::optional<PurchaseOfferIOS>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::variant<PurchaseAndroid, PurchaseIOS>
   /**
-   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   * Wrapper struct for `std::variant<PurchaseAndroid, PurchaseIOS>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  class Func_void_Wrapper final {
+  struct std__variant_PurchaseAndroid__PurchaseIOS_ {
+    std::variant<PurchaseAndroid, PurchaseIOS> variant;
+    std__variant_PurchaseAndroid__PurchaseIOS_(std::variant<PurchaseAndroid, PurchaseIOS> variant): variant(variant) { }
+    operator std::variant<PurchaseAndroid, PurchaseIOS>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline PurchaseAndroid get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline PurchaseIOS get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_PurchaseAndroid__PurchaseIOS_ create_std__variant_PurchaseAndroid__PurchaseIOS_(const PurchaseAndroid& value) noexcept {
+    return std__variant_PurchaseAndroid__PurchaseIOS_(value);
+  }
+  inline std__variant_PurchaseAndroid__PurchaseIOS_ create_std__variant_PurchaseAndroid__PurchaseIOS_(const PurchaseIOS& value) noexcept {
+    return std__variant_PurchaseAndroid__PurchaseIOS_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<PurchaseAndroid, PurchaseIOS>>
+  /**
+   * Specialized version of `std::optional<std::variant<PurchaseAndroid, PurchaseIOS>>`.
+   */
+  using std__optional_std__variant_PurchaseAndroid__PurchaseIOS__ = std::optional<std::variant<PurchaseAndroid, PurchaseIOS>>;
+  inline std::optional<std::variant<PurchaseAndroid, PurchaseIOS>> create_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__(const std::variant<PurchaseAndroid, PurchaseIOS>& value) noexcept {
+    return std::optional<std::variant<PurchaseAndroid, PurchaseIOS>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<PurchaseAndroid, PurchaseIOS> get_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>
+  /**
+   * Specialized version of `std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>`.
+   */
+  using std__vector_std__variant_PurchaseAndroid__PurchaseIOS__ = std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>;
+  inline std::vector<std::variant<PurchaseAndroid, PurchaseIOS>> create_std__vector_std__variant_PurchaseAndroid__PurchaseIOS__(size_t size) noexcept {
+    std::vector<std::variant<PurchaseAndroid, PurchaseIOS>> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>
+  /**
+   * Specialized version of `std::optional<std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>`.
+   */
+  using std__optional_std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ = std::optional<std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>;
+  inline std::optional<std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>> create_std__optional_std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>& value) noexcept {
+    return std::optional<std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const std::optional<std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<std::variant<PurchaseAndroid, PurchaseIOS>> get_std__optional_std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const std::optional<std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<RequestPurchaseResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<RequestPurchaseResult>>`.
+   */
+  using std__shared_ptr_Promise_RequestPurchaseResult__ = std::shared_ptr<Promise<RequestPurchaseResult>>;
+  inline std::shared_ptr<Promise<RequestPurchaseResult>> create_std__shared_ptr_Promise_RequestPurchaseResult__() noexcept {
+    return Promise<RequestPurchaseResult>::create();
+  }
+  inline PromiseHolder<RequestPurchaseResult> wrap_std__shared_ptr_Promise_RequestPurchaseResult__(std::shared_ptr<Promise<RequestPurchaseResult>> promise) noexcept {
+    return PromiseHolder<RequestPurchaseResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const RequestPurchaseResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const RequestPurchaseResult&)>`.
+   */
+  using Func_void_RequestPurchaseResult = std::function<void(const RequestPurchaseResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RequestPurchaseResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_RequestPurchaseResult_Wrapper final {
   public:
-    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
-    inline void call() const noexcept {
-      _function->operator()();
+    explicit Func_void_RequestPurchaseResult_Wrapper(std::function<void(const RequestPurchaseResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const RequestPurchaseResult& /* result */)>>(std::move(func))) {}
+    inline void call(RequestPurchaseResult result) const noexcept {
+      _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void()>> _function;
+    std::unique_ptr<std::function<void(const RequestPurchaseResult& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper) noexcept;
-  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
-    return Func_void_Wrapper(std::move(value));
+  Func_void_RequestPurchaseResult create_Func_void_RequestPurchaseResult(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_RequestPurchaseResult_Wrapper wrap_Func_void_RequestPurchaseResult(Func_void_RequestPurchaseResult value) noexcept {
+    return Func_void_RequestPurchaseResult_Wrapper(std::move(value));
   }
   
   // pragma MARK: std::unordered_map<std::string, std::string>
@@ -736,6 +854,40 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__optional_NitroProduct__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<void>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   */
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
+    return Promise<void>::create();
+  }
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
+    }
+  private:
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::optional<NitroSubscriptionRenewalInfo>
   /**
    * Specialized version of `std::optional<NitroSubscriptionRenewalInfo>`.
@@ -968,13 +1120,13 @@ namespace margelo::nitro::iap::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<NitroProduct>>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<void>>>
-  using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
-  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<RequestPurchaseResult>>>
+  using Result_std__shared_ptr_Promise_RequestPurchaseResult___ = Result<std::shared_ptr<Promise<RequestPurchaseResult>>>;
+  inline Result_std__shared_ptr_Promise_RequestPurchaseResult___ create_Result_std__shared_ptr_Promise_RequestPurchaseResult___(const std::shared_ptr<Promise<RequestPurchaseResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<RequestPurchaseResult>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<void>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_RequestPurchaseResult___ create_Result_std__shared_ptr_Promise_RequestPurchaseResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<RequestPurchaseResult>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NitroPurchase>>>>
@@ -1031,6 +1183,15 @@ namespace margelo::nitro::iap::bridge::swift {
     return Result<std::shared_ptr<Promise<std::optional<NitroProduct>>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<void>>>
+  using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>>
   using Result_std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus_____ = Result<std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>>;
   inline Result_std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus_____ create_Result_std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus_____(const std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>& value) noexcept {

package/nitrogen/generated/ios/NitroIap-Swift-Cxx-Umbrella.hpp

@@ -10,6 +10,8 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `HybridRnIapSpec` to properly resolve imports.
 namespace margelo::nitro::iap { class HybridRnIapSpec; }
+// Forward declaration of `IapPlatform` to properly resolve imports.
+namespace margelo::nitro::iap { enum class IapPlatform; }
 // Forward declaration of `NitroAvailablePurchasesAndroidOptions` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroAvailablePurchasesAndroidOptions; }
 // Forward declaration of `NitroAvailablePurchasesIosOptions` to properly resolve imports.
@@ -50,9 +52,20 @@ namespace margelo::nitro::iap { struct NitroSubscriptionOffer; }
 namespace margelo::nitro::iap { struct NitroSubscriptionRenewalInfo; }
 // Forward declaration of `NitroSubscriptionStatus` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroSubscriptionStatus; }
+// Forward declaration of `PurchaseAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { struct PurchaseAndroid; }
+// Forward declaration of `PurchaseIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct PurchaseIOS; }
+// Forward declaration of `PurchaseOfferIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct PurchaseOfferIOS; }
+// Forward declaration of `PurchaseState` to properly resolve imports.
+namespace margelo::nitro::iap { enum class PurchaseState; }
+// Forward declaration of `RequestPurchaseResult` to properly resolve imports.
+namespace margelo::nitro::iap { struct RequestPurchaseResult; }
 
 // Include C++ defined types
 #include "HybridRnIapSpec.hpp"
+#include "IapPlatform.hpp"
 #include "NitroAvailablePurchasesAndroidOptions.hpp"
 #include "NitroAvailablePurchasesIosOptions.hpp"
 #include "NitroAvailablePurchasesOptions.hpp"
@@ -73,6 +86,11 @@ namespace margelo::nitro::iap { struct NitroSubscriptionStatus; }
 #include "NitroSubscriptionOffer.hpp"
 #include "NitroSubscriptionRenewalInfo.hpp"
 #include "NitroSubscriptionStatus.hpp"
+#include "PurchaseAndroid.hpp"
+#include "PurchaseIOS.hpp"
+#include "PurchaseOfferIOS.hpp"
+#include "PurchaseState.hpp"
+#include "RequestPurchaseResult.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>

package/nitrogen/generated/ios/c++/HybridRnIapSpecSwift.hpp

@@ -14,6 +14,18 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 
 // Forward declaration of `NitroProduct` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroProduct; }
+// Forward declaration of `RequestPurchaseResult` to properly resolve imports.
+namespace margelo::nitro::iap { struct RequestPurchaseResult; }
+// Forward declaration of `PurchaseAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { struct PurchaseAndroid; }
+// Forward declaration of `PurchaseIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct PurchaseIOS; }
+// Forward declaration of `IapPlatform` to properly resolve imports.
+namespace margelo::nitro::iap { enum class IapPlatform; }
+// Forward declaration of `PurchaseState` to properly resolve imports.
+namespace margelo::nitro::iap { enum class PurchaseState; }
+// Forward declaration of `PurchaseOfferIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct PurchaseOfferIOS; }
 // Forward declaration of `NitroPurchaseRequest` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroPurchaseRequest; }
 // Forward declaration of `NitroRequestPurchaseIos` to properly resolve imports.
@@ -58,6 +70,13 @@ namespace margelo::nitro::iap { struct NitroDeepLinkOptionsAndroid; }
 #include <vector>
 #include <string>
 #include <optional>
+#include "RequestPurchaseResult.hpp"
+#include "PurchaseAndroid.hpp"
+#include "PurchaseIOS.hpp"
+#include <variant>
+#include "IapPlatform.hpp"
+#include "PurchaseState.hpp"
+#include "PurchaseOfferIOS.hpp"
 #include "NitroPurchaseRequest.hpp"
 #include "NitroRequestPurchaseIos.hpp"
 #include <unordered_map>
@@ -68,7 +87,6 @@ namespace margelo::nitro::iap { struct NitroDeepLinkOptionsAndroid; }
 #include "NitroAvailablePurchasesIosOptions.hpp"
 #include "NitroAvailablePurchasesAndroidOptions.hpp"
 #include "NitroPurchaseResult.hpp"
-#include <variant>
 #include "NitroFinishTransactionParams.hpp"
 #include "NitroFinishTransactionIosParams.hpp"
 #include "NitroFinishTransactionAndroidParams.hpp"
@@ -146,7 +164,7 @@ namespace margelo::nitro::iap {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<void>> requestPurchase(const NitroPurchaseRequest& request) override {
+    inline std::shared_ptr<Promise<RequestPurchaseResult>> requestPurchase(const NitroPurchaseRequest& request) override {
       auto __result = _swiftPart.requestPurchase(request);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/Func_void_RequestPurchaseResult.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_RequestPurchaseResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+
+/**
+ * Wraps a Swift `(_ value: RequestPurchaseResult) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_RequestPurchaseResult {
+  public typealias bridge = margelo.nitro.iap.bridge.swift
+
+  private let closure: (_ value: RequestPurchaseResult) -> Void
+
+  public init(_ closure: @escaping (_ value: RequestPurchaseResult) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: RequestPurchaseResult) -> Void {
+    self.closure(value)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_RequestPurchaseResult`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_RequestPurchaseResult>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_RequestPurchaseResult {
+    return Unmanaged<Func_void_RequestPurchaseResult>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridRnIapSpec.swift

@@ -17,7 +17,7 @@ public protocol HybridRnIapSpec_protocol: HybridObject {
   func initConnection() throws -> Promise<Bool>
   func endConnection() throws -> Promise<Bool>
   func fetchProducts(skus: [String], type: String) throws -> Promise<[NitroProduct]>
-  func requestPurchase(request: NitroPurchaseRequest) throws -> Promise<Void>
+  func requestPurchase(request: NitroPurchaseRequest) throws -> Promise<RequestPurchaseResult>
   func getAvailablePurchases(options: NitroAvailablePurchasesOptions?) throws -> Promise<[NitroPurchase]>
   func finishTransaction(params: NitroFinishTransactionParams) throws -> Promise<Variant_Bool_NitroPurchaseResult>
   func addPurchaseUpdatedListener(listener: @escaping (_ purchase: NitroPurchase) -> Void) throws -> Void

package/nitrogen/generated/ios/swift/HybridRnIapSpec_cxx.swift

@@ -173,21 +173,21 @@ open class HybridRnIapSpec_cxx {
   }
   
   @inline(__always)
-  public final func requestPurchase(request: NitroPurchaseRequest) -> bridge.Result_std__shared_ptr_Promise_void___ {
+  public final func requestPurchase(request: NitroPurchaseRequest) -> bridge.Result_std__shared_ptr_Promise_RequestPurchaseResult___ {
     do {
       let __result = try self.__implementation.requestPurchase(request: request)
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
-        let __promise = bridge.create_std__shared_ptr_Promise_void__()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_RequestPurchaseResult__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_RequestPurchaseResult__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_RequestPurchaseResult__(__promise)
         __result
-          .then({ __result in __promiseHolder.resolve() })
+          .then({ __result in __promiseHolder.resolve(__result) })
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_RequestPurchaseResult___(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_RequestPurchaseResult___(__exceptionPtr)
     }
   }
   

package/nitrogen/generated/ios/swift/IapPlatform.swift

@@ -0,0 +1,40 @@
+///
+/// IapPlatform.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `IapPlatform`, backed by a C++ enum.
+ */
+public typealias IapPlatform = margelo.nitro.iap.IapPlatform
+
+public extension IapPlatform {
+  /**
+   * Get a IapPlatform for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "android":
+        self = .android
+      case "ios":
+        self = .ios
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this IapPlatform represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .android:
+        return "android"
+      case .ios:
+        return "ios"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Purchase.swift

@@ -0,0 +1,18 @@
+///
+/// Purchase.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+
+
+/**
+ * An Swift enum with associated values representing a Variant/Union type.
+ * JS type: `struct | struct`
+ */
+@frozen
+public indirect enum Purchase {
+  case first(PurchaseAndroid)
+  case second(PurchaseIOS)
+}