react-native-iap 14.3.6 → 14.3.8

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

@@ -8,12 +8,16 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AndroidSubscriptionOfferInput` to properly resolve imports.
+namespace margelo::nitro::iap { struct AndroidSubscriptionOfferInput; }
 // 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 `NitroAvailablePurchasesAndroidType` to properly resolve imports.
+namespace margelo::nitro::iap { enum class NitroAvailablePurchasesAndroidType; }
 // Forward declaration of `NitroAvailablePurchasesIosOptions` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroAvailablePurchasesIosOptions; }
 // Forward declaration of `NitroAvailablePurchasesOptions` to properly resolve imports.
@@ -38,8 +42,6 @@ namespace margelo::nitro::iap { struct NitroReceiptValidationResultIOS; }
 namespace margelo::nitro::iap { struct NitroRequestPurchaseAndroid; }
 // Forward declaration of `NitroRequestPurchaseIos` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroRequestPurchaseIos; }
-// Forward declaration of `NitroSubscriptionOffer` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroSubscriptionOffer; }
 // Forward declaration of `NitroSubscriptionRenewalInfo` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroSubscriptionRenewalInfo; }
 // Forward declaration of `NitroSubscriptionStatus` to properly resolve imports.
@@ -52,17 +54,17 @@ namespace margelo::nitro::iap { struct PurchaseIOS; }
 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.
 namespace NitroIap { class HybridRnIapSpec_cxx; }
 
 // Include C++ defined types
+#include "AndroidSubscriptionOfferInput.hpp"
 #include "HybridRnIapSpec.hpp"
 #include "IapPlatform.hpp"
 #include "NitroAvailablePurchasesAndroidOptions.hpp"
+#include "NitroAvailablePurchasesAndroidType.hpp"
 #include "NitroAvailablePurchasesIosOptions.hpp"
 #include "NitroAvailablePurchasesOptions.hpp"
 #include "NitroFinishTransactionAndroidParams.hpp"
@@ -75,14 +77,12 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "NitroReceiptValidationResultIOS.hpp"
 #include "NitroRequestPurchaseAndroid.hpp"
 #include "NitroRequestPurchaseIos.hpp"
-#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>
@@ -317,21 +317,6 @@ namespace margelo::nitro::iap::bridge::swift {
     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>>`.
@@ -343,53 +328,88 @@ namespace margelo::nitro::iap::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>
+  // pragma MARK: std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>
   /**
-   * Specialized version of `std::optional<std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>`.
+   * Wrapper struct for `std::variant<PurchaseAndroid, PurchaseIOS, std::vector<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.
    */
-  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);
+  struct std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ {
+    std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>> variant;
+    std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>> variant): variant(variant) { }
+    operator std::variant<PurchaseAndroid, PurchaseIOS, std::vector<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::vector<std::variant<PurchaseAndroid, PurchaseIOS>> get_2() const noexcept {
+      return std::get<2>(variant);
+    }
+  };
+  inline std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const PurchaseAndroid& value) noexcept {
+    return std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(value);
+  }
+  inline std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const PurchaseIOS& value) noexcept {
+    return std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(value);
+  }
+  inline std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>& value) noexcept {
+    return std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>
+  /**
+   * Specialized version of `std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>`.
+   */
+  using std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ = std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>;
+  inline std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>> create_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(const std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>& value) noexcept {
+    return std::optional<std::variant<PurchaseAndroid, PurchaseIOS, 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 {
+  inline bool has_value_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, 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 {
+  inline std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>> get_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& optional) noexcept {
     return *optional;
   }
   
-  // pragma MARK: std::shared_ptr<Promise<RequestPurchaseResult>>
+  // pragma MARK: std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<RequestPurchaseResult>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>`.
    */
-  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();
+  using std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______ = std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>;
+  inline std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>> create_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______() noexcept {
+    return Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>::create();
   }
-  inline PromiseHolder<RequestPurchaseResult> wrap_std__shared_ptr_Promise_RequestPurchaseResult__(std::shared_ptr<Promise<RequestPurchaseResult>> promise) noexcept {
-    return PromiseHolder<RequestPurchaseResult>(std::move(promise));
+  inline PromiseHolder<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>> wrap_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______(std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>> promise) noexcept {
+    return PromiseHolder<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const RequestPurchaseResult& /* result */)>
+  // pragma MARK: std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const RequestPurchaseResult&)>`.
+   * Specialized version of `std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>&)>`.
    */
-  using Func_void_RequestPurchaseResult = std::function<void(const RequestPurchaseResult& /* result */)>;
+  using Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ = std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const RequestPurchaseResult& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_RequestPurchaseResult_Wrapper final {
+  class Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____Wrapper final {
   public:
-    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 {
+    explicit Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____Wrapper(std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const RequestPurchaseResult& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  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));
+  Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ create_Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____Wrapper wrap_Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ value) noexcept {
+    return Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____Wrapper(std::move(value));
   }
   
   // pragma MARK: std::unordered_map<std::string, std::string>
@@ -447,29 +467,29 @@ namespace margelo::nitro::iap::bridge::swift {
     return *optional;
   }
   
-  // pragma MARK: std::vector<NitroSubscriptionOffer>
+  // pragma MARK: std::vector<AndroidSubscriptionOfferInput>
   /**
-   * Specialized version of `std::vector<NitroSubscriptionOffer>`.
+   * Specialized version of `std::vector<AndroidSubscriptionOfferInput>`.
    */
-  using std__vector_NitroSubscriptionOffer_ = std::vector<NitroSubscriptionOffer>;
-  inline std::vector<NitroSubscriptionOffer> create_std__vector_NitroSubscriptionOffer_(size_t size) noexcept {
-    std::vector<NitroSubscriptionOffer> vector;
+  using std__vector_AndroidSubscriptionOfferInput_ = std::vector<AndroidSubscriptionOfferInput>;
+  inline std::vector<AndroidSubscriptionOfferInput> create_std__vector_AndroidSubscriptionOfferInput_(size_t size) noexcept {
+    std::vector<AndroidSubscriptionOfferInput> vector;
     vector.reserve(size);
     return vector;
   }
   
-  // pragma MARK: std::optional<std::vector<NitroSubscriptionOffer>>
+  // pragma MARK: std::optional<std::vector<AndroidSubscriptionOfferInput>>
   /**
-   * Specialized version of `std::optional<std::vector<NitroSubscriptionOffer>>`.
+   * Specialized version of `std::optional<std::vector<AndroidSubscriptionOfferInput>>`.
    */
-  using std__optional_std__vector_NitroSubscriptionOffer__ = std::optional<std::vector<NitroSubscriptionOffer>>;
-  inline std::optional<std::vector<NitroSubscriptionOffer>> create_std__optional_std__vector_NitroSubscriptionOffer__(const std::vector<NitroSubscriptionOffer>& value) noexcept {
-    return std::optional<std::vector<NitroSubscriptionOffer>>(value);
+  using std__optional_std__vector_AndroidSubscriptionOfferInput__ = std::optional<std::vector<AndroidSubscriptionOfferInput>>;
+  inline std::optional<std::vector<AndroidSubscriptionOfferInput>> create_std__optional_std__vector_AndroidSubscriptionOfferInput__(const std::vector<AndroidSubscriptionOfferInput>& value) noexcept {
+    return std::optional<std::vector<AndroidSubscriptionOfferInput>>(value);
   }
-  inline bool has_value_std__optional_std__vector_NitroSubscriptionOffer__(const std::optional<std::vector<NitroSubscriptionOffer>>& optional) noexcept {
+  inline bool has_value_std__optional_std__vector_AndroidSubscriptionOfferInput__(const std::optional<std::vector<AndroidSubscriptionOfferInput>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::vector<NitroSubscriptionOffer> get_std__optional_std__vector_NitroSubscriptionOffer__(const std::optional<std::vector<NitroSubscriptionOffer>>& optional) noexcept {
+  inline std::vector<AndroidSubscriptionOfferInput> get_std__optional_std__vector_AndroidSubscriptionOfferInput__(const std::optional<std::vector<AndroidSubscriptionOfferInput>>& optional) noexcept {
     return *optional;
   }
   
@@ -548,6 +568,21 @@ namespace margelo::nitro::iap::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::optional<NitroAvailablePurchasesAndroidType>
+  /**
+   * Specialized version of `std::optional<NitroAvailablePurchasesAndroidType>`.
+   */
+  using std__optional_NitroAvailablePurchasesAndroidType_ = std::optional<NitroAvailablePurchasesAndroidType>;
+  inline std::optional<NitroAvailablePurchasesAndroidType> create_std__optional_NitroAvailablePurchasesAndroidType_(const NitroAvailablePurchasesAndroidType& value) noexcept {
+    return std::optional<NitroAvailablePurchasesAndroidType>(value);
+  }
+  inline bool has_value_std__optional_NitroAvailablePurchasesAndroidType_(const std::optional<NitroAvailablePurchasesAndroidType>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline NitroAvailablePurchasesAndroidType get_std__optional_NitroAvailablePurchasesAndroidType_(const std::optional<NitroAvailablePurchasesAndroidType>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::optional<NitroAvailablePurchasesAndroidOptions>
   /**
    * Specialized version of `std::optional<NitroAvailablePurchasesAndroidOptions>`.
@@ -1120,13 +1155,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<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);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>>
+  using Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______ = Result<std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______ create_Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______(const std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>>::withValue(value);
   }
-  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);
+  inline Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______ create_Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NitroPurchase>>>>

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

@@ -8,12 +8,16 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AndroidSubscriptionOfferInput` to properly resolve imports.
+namespace margelo::nitro::iap { struct AndroidSubscriptionOfferInput; }
 // 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 `NitroAvailablePurchasesAndroidType` to properly resolve imports.
+namespace margelo::nitro::iap { enum class NitroAvailablePurchasesAndroidType; }
 // Forward declaration of `NitroAvailablePurchasesIosOptions` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroAvailablePurchasesIosOptions; }
 // Forward declaration of `NitroAvailablePurchasesOptions` to properly resolve imports.
@@ -46,8 +50,6 @@ namespace margelo::nitro::iap { struct NitroReceiptValidationResultIOS; }
 namespace margelo::nitro::iap { struct NitroRequestPurchaseAndroid; }
 // Forward declaration of `NitroRequestPurchaseIos` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroRequestPurchaseIos; }
-// Forward declaration of `NitroSubscriptionOffer` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroSubscriptionOffer; }
 // Forward declaration of `NitroSubscriptionRenewalInfo` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroSubscriptionRenewalInfo; }
 // Forward declaration of `NitroSubscriptionStatus` to properly resolve imports.
@@ -60,13 +62,13 @@ namespace margelo::nitro::iap { struct PurchaseIOS; }
 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 "AndroidSubscriptionOfferInput.hpp"
 #include "HybridRnIapSpec.hpp"
 #include "IapPlatform.hpp"
 #include "NitroAvailablePurchasesAndroidOptions.hpp"
+#include "NitroAvailablePurchasesAndroidType.hpp"
 #include "NitroAvailablePurchasesIosOptions.hpp"
 #include "NitroAvailablePurchasesOptions.hpp"
 #include "NitroDeepLinkOptionsAndroid.hpp"
@@ -83,14 +85,12 @@ namespace margelo::nitro::iap { struct RequestPurchaseResult; }
 #include "NitroReceiptValidationResultIOS.hpp"
 #include "NitroRequestPurchaseAndroid.hpp"
 #include "NitroRequestPurchaseIos.hpp"
-#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,14 +14,12 @@ 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 `IapPlatform` to properly resolve imports.
+namespace margelo::nitro::iap { enum class IapPlatform; }
 // 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.
@@ -32,8 +30,8 @@ namespace margelo::nitro::iap { struct NitroPurchaseRequest; }
 namespace margelo::nitro::iap { struct NitroRequestPurchaseIos; }
 // Forward declaration of `NitroRequestPurchaseAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroRequestPurchaseAndroid; }
-// Forward declaration of `NitroSubscriptionOffer` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroSubscriptionOffer; }
+// Forward declaration of `AndroidSubscriptionOfferInput` to properly resolve imports.
+namespace margelo::nitro::iap { struct AndroidSubscriptionOfferInput; }
 // Forward declaration of `NitroPurchase` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroPurchase; }
 // Forward declaration of `NitroAvailablePurchasesOptions` to properly resolve imports.
@@ -42,6 +40,8 @@ namespace margelo::nitro::iap { struct NitroAvailablePurchasesOptions; }
 namespace margelo::nitro::iap { struct NitroAvailablePurchasesIosOptions; }
 // Forward declaration of `NitroAvailablePurchasesAndroidOptions` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroAvailablePurchasesAndroidOptions; }
+// Forward declaration of `NitroAvailablePurchasesAndroidType` to properly resolve imports.
+namespace margelo::nitro::iap { enum class NitroAvailablePurchasesAndroidType; }
 // Forward declaration of `NitroPurchaseResult` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroPurchaseResult; }
 // Forward declaration of `NitroFinishTransactionParams` to properly resolve imports.
@@ -70,22 +70,22 @@ namespace margelo::nitro::iap { struct NitroDeepLinkOptionsAndroid; }
 #include <vector>
 #include <string>
 #include <optional>
-#include "RequestPurchaseResult.hpp"
+#include "IapPlatform.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>
 #include "NitroRequestPurchaseAndroid.hpp"
-#include "NitroSubscriptionOffer.hpp"
+#include "AndroidSubscriptionOfferInput.hpp"
 #include "NitroPurchase.hpp"
 #include "NitroAvailablePurchasesOptions.hpp"
 #include "NitroAvailablePurchasesIosOptions.hpp"
 #include "NitroAvailablePurchasesAndroidOptions.hpp"
+#include "NitroAvailablePurchasesAndroidType.hpp"
 #include "NitroPurchaseResult.hpp"
 #include "NitroFinishTransactionParams.hpp"
 #include "NitroFinishTransactionIosParams.hpp"
@@ -164,7 +164,7 @@ namespace margelo::nitro::iap {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<RequestPurchaseResult>> requestPurchase(const NitroPurchaseRequest& request) override {
+    inline std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>> requestPurchase(const NitroPurchaseRequest& request) override {
       auto __result = _swiftPart.requestPurchase(request);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/{NitroSubscriptionOffer.swift → AndroidSubscriptionOfferInput.swift}

@@ -1,5 +1,5 @@
 ///
-/// NitroSubscriptionOffer.swift
+/// AndroidSubscriptionOfferInput.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -8,39 +8,39 @@
 import NitroModules
 
 /**
- * Represents an instance of `NitroSubscriptionOffer`, backed by a C++ struct.
+ * Represents an instance of `AndroidSubscriptionOfferInput`, backed by a C++ struct.
  */
-public typealias NitroSubscriptionOffer = margelo.nitro.iap.NitroSubscriptionOffer
+public typealias AndroidSubscriptionOfferInput = margelo.nitro.iap.AndroidSubscriptionOfferInput
 
-public extension NitroSubscriptionOffer {
+public extension AndroidSubscriptionOfferInput {
   private typealias bridge = margelo.nitro.iap.bridge.swift
 
   /**
-   * Create a new instance of `NitroSubscriptionOffer`.
+   * Create a new instance of `AndroidSubscriptionOfferInput`.
    */
-  init(sku: String, offerToken: String) {
-    self.init(std.string(sku), std.string(offerToken))
+  init(offerToken: String, sku: String) {
+    self.init(std.string(offerToken), std.string(sku))
   }
 
-  var sku: String {
+  var offerToken: String {
     @inline(__always)
     get {
-      return String(self.__sku)
+      return String(self.__offerToken)
     }
     @inline(__always)
     set {
-      self.__sku = std.string(newValue)
+      self.__offerToken = std.string(newValue)
     }
   }
   
-  var offerToken: String {
+  var sku: String {
     @inline(__always)
     get {
-      return String(self.__offerToken)
+      return String(self.__sku)
     }
     @inline(__always)
     set {
-      self.__offerToken = std.string(newValue)
+      self.__sku = std.string(newValue)
     }
   }
 }

package/nitrogen/generated/ios/swift/Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____.swift

@@ -0,0 +1,81 @@
+///
+/// Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____.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_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ {
+  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: bridge.std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____) -> Void {
+    self.closure({ () -> RequestPurchaseResult? in
+      if bridge.has_value_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(value) {
+        let __unwrapped = bridge.get_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(value)
+        return { () -> RequestPurchaseResult in
+          let __variant = bridge.std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(__unwrapped)
+          switch __variant.index() {
+            case 0:
+              let __actual = __variant.get_0()
+              return .first(__actual)
+            case 1:
+              let __actual = __variant.get_1()
+              return .second(__actual)
+            case 2:
+              let __actual = __variant.get_2()
+              return .third(__actual.map({ __item in { () -> Purchase in
+                let __variant = bridge.std__variant_PurchaseAndroid__PurchaseIOS_(__item)
+                switch __variant.index() {
+                  case 0:
+                    let __actual = __variant.get_0()
+                    return .first(__actual)
+                  case 1:
+                    let __actual = __variant.get_1()
+                    return .second(__actual)
+                  default:
+                    fatalError("Variant can never have index \(__variant.index())!")
+                }
+              }() }))
+            default:
+              fatalError("Variant can never have index \(__variant.index())!")
+          }
+        }()
+      } else {
+        return nil
+      }
+    }())
+  }
+
+  /**
+   * 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_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ {
+    return Unmanaged<Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____>.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<RequestPurchaseResult>
+  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,49 @@ open class HybridRnIapSpec_cxx {
   }
   
   @inline(__always)
-  public final func requestPurchase(request: NitroPurchaseRequest) -> bridge.Result_std__shared_ptr_Promise_RequestPurchaseResult___ {
+  public final func requestPurchase(request: NitroPurchaseRequest) -> bridge.Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______ {
     do {
       let __result = try self.__implementation.requestPurchase(request: request)
-      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)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______(__promise)
         __result
-          .then({ __result in __promiseHolder.resolve(__result) })
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ in
+              if let __unwrappedValue = __result {
+                return bridge.create_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____({ () -> bridge.std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ in
+                  switch __unwrappedValue {
+                    case .first(let __value):
+                      return bridge.create_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(__value)
+                    case .second(let __value):
+                      return bridge.create_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(__value)
+                    case .third(let __value):
+                      return bridge.create_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___({ () -> bridge.std__vector_std__variant_PurchaseAndroid__PurchaseIOS__ in
+                        var __vector = bridge.create_std__vector_std__variant_PurchaseAndroid__PurchaseIOS__(__value.count)
+                        for __item in __value {
+                          __vector.push_back({ () -> bridge.std__variant_PurchaseAndroid__PurchaseIOS_ in
+                            switch __item {
+                              case .first(let __value):
+                                return bridge.create_std__variant_PurchaseAndroid__PurchaseIOS_(__value)
+                              case .second(let __value):
+                                return bridge.create_std__variant_PurchaseAndroid__PurchaseIOS_(__value)
+                            }
+                          }().variant)
+                        }
+                        return __vector
+                      }())
+                  }
+                }().variant)
+              } else {
+                return .init()
+              }
+            }()) })
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_RequestPurchaseResult___(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_RequestPurchaseResult___(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______(__exceptionPtr)
     }
   }