react-native-iap 14.4.11 → 14.4.13

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

@@ -8,12 +8,22 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AlternativeBillingModeAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { enum class AlternativeBillingModeAndroid; }
 // Forward declaration of `AndroidSubscriptionOfferInput` to properly resolve imports.
 namespace margelo::nitro::iap { struct AndroidSubscriptionOfferInput; }
+// Forward declaration of `ExternalPurchaseLinkResultIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct ExternalPurchaseLinkResultIOS; }
+// Forward declaration of `ExternalPurchaseNoticeAction` to properly resolve imports.
+namespace margelo::nitro::iap { enum class ExternalPurchaseNoticeAction; }
+// Forward declaration of `ExternalPurchaseNoticeResultIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct ExternalPurchaseNoticeResultIOS; }
 // 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 `InitConnectionConfig` to properly resolve imports.
+namespace margelo::nitro::iap { struct InitConnectionConfig; }
 // Forward declaration of `NitroAvailablePurchasesAndroidOptions` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroAvailablePurchasesAndroidOptions; }
 // Forward declaration of `NitroAvailablePurchasesAndroidType` to properly resolve imports.
@@ -56,15 +66,22 @@ 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 `UserChoiceBillingDetails` to properly resolve imports.
+namespace margelo::nitro::iap { struct UserChoiceBillingDetails; }
 
 // 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 "AlternativeBillingModeAndroid.hpp"
 #include "AndroidSubscriptionOfferInput.hpp"
+#include "ExternalPurchaseLinkResultIOS.hpp"
+#include "ExternalPurchaseNoticeAction.hpp"
+#include "ExternalPurchaseNoticeResultIOS.hpp"
 #include "HybridRnIapSpec.hpp"
 #include "IapPlatform.hpp"
+#include "InitConnectionConfig.hpp"
 #include "NitroAvailablePurchasesAndroidOptions.hpp"
 #include "NitroAvailablePurchasesAndroidType.hpp"
 #include "NitroAvailablePurchasesIosOptions.hpp"
@@ -86,6 +103,7 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "PurchaseIOS.hpp"
 #include "PurchaseOfferIOS.hpp"
 #include "PurchaseState.hpp"
+#include "UserChoiceBillingDetails.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -160,6 +178,36 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<AlternativeBillingModeAndroid>
+  /**
+   * Specialized version of `std::optional<AlternativeBillingModeAndroid>`.
+   */
+  using std__optional_AlternativeBillingModeAndroid_ = std::optional<AlternativeBillingModeAndroid>;
+  inline std::optional<AlternativeBillingModeAndroid> create_std__optional_AlternativeBillingModeAndroid_(const AlternativeBillingModeAndroid& value) noexcept {
+    return std::optional<AlternativeBillingModeAndroid>(value);
+  }
+  inline bool has_value_std__optional_AlternativeBillingModeAndroid_(const std::optional<AlternativeBillingModeAndroid>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AlternativeBillingModeAndroid get_std__optional_AlternativeBillingModeAndroid_(const std::optional<AlternativeBillingModeAndroid>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<InitConnectionConfig>
+  /**
+   * Specialized version of `std::optional<InitConnectionConfig>`.
+   */
+  using std__optional_InitConnectionConfig_ = std::optional<InitConnectionConfig>;
+  inline std::optional<InitConnectionConfig> create_std__optional_InitConnectionConfig_(const InitConnectionConfig& value) noexcept {
+    return std::optional<InitConnectionConfig>(value);
+  }
+  inline bool has_value_std__optional_InitConnectionConfig_(const std::optional<InitConnectionConfig>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline InitConnectionConfig get_std__optional_InitConnectionConfig_(const std::optional<InitConnectionConfig>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::optional<std::string>
   /**
    * Specialized version of `std::optional<std::string>`.
@@ -1143,6 +1191,96 @@ namespace margelo::nitro::iap::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::function<void(const UserChoiceBillingDetails& /* details */)>
+  /**
+   * Specialized version of `std::function<void(const UserChoiceBillingDetails&)>`.
+   */
+  using Func_void_UserChoiceBillingDetails = std::function<void(const UserChoiceBillingDetails& /* details */)>;
+  /**
+   * Wrapper class for a `std::function<void(const UserChoiceBillingDetails& / * details * /)>`, this can be used from Swift.
+   */
+  class Func_void_UserChoiceBillingDetails_Wrapper final {
+  public:
+    explicit Func_void_UserChoiceBillingDetails_Wrapper(std::function<void(const UserChoiceBillingDetails& /* details */)>&& func): _function(std::make_unique<std::function<void(const UserChoiceBillingDetails& /* details */)>>(std::move(func))) {}
+    inline void call(UserChoiceBillingDetails details) const noexcept {
+      _function->operator()(details);
+    }
+  private:
+    std::unique_ptr<std::function<void(const UserChoiceBillingDetails& /* details */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_UserChoiceBillingDetails create_Func_void_UserChoiceBillingDetails(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_UserChoiceBillingDetails_Wrapper wrap_Func_void_UserChoiceBillingDetails(Func_void_UserChoiceBillingDetails value) noexcept {
+    return Func_void_UserChoiceBillingDetails_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>>`.
+   */
+  using std__shared_ptr_Promise_ExternalPurchaseNoticeResultIOS__ = std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>>;
+  inline std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>> create_std__shared_ptr_Promise_ExternalPurchaseNoticeResultIOS__() noexcept {
+    return Promise<ExternalPurchaseNoticeResultIOS>::create();
+  }
+  inline PromiseHolder<ExternalPurchaseNoticeResultIOS> wrap_std__shared_ptr_Promise_ExternalPurchaseNoticeResultIOS__(std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>> promise) noexcept {
+    return PromiseHolder<ExternalPurchaseNoticeResultIOS>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const ExternalPurchaseNoticeResultIOS& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const ExternalPurchaseNoticeResultIOS&)>`.
+   */
+  using Func_void_ExternalPurchaseNoticeResultIOS = std::function<void(const ExternalPurchaseNoticeResultIOS& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const ExternalPurchaseNoticeResultIOS& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_ExternalPurchaseNoticeResultIOS_Wrapper final {
+  public:
+    explicit Func_void_ExternalPurchaseNoticeResultIOS_Wrapper(std::function<void(const ExternalPurchaseNoticeResultIOS& /* result */)>&& func): _function(std::make_unique<std::function<void(const ExternalPurchaseNoticeResultIOS& /* result */)>>(std::move(func))) {}
+    inline void call(ExternalPurchaseNoticeResultIOS result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const ExternalPurchaseNoticeResultIOS& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_ExternalPurchaseNoticeResultIOS create_Func_void_ExternalPurchaseNoticeResultIOS(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_ExternalPurchaseNoticeResultIOS_Wrapper wrap_Func_void_ExternalPurchaseNoticeResultIOS(Func_void_ExternalPurchaseNoticeResultIOS value) noexcept {
+    return Func_void_ExternalPurchaseNoticeResultIOS_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>>`.
+   */
+  using std__shared_ptr_Promise_ExternalPurchaseLinkResultIOS__ = std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>>;
+  inline std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>> create_std__shared_ptr_Promise_ExternalPurchaseLinkResultIOS__() noexcept {
+    return Promise<ExternalPurchaseLinkResultIOS>::create();
+  }
+  inline PromiseHolder<ExternalPurchaseLinkResultIOS> wrap_std__shared_ptr_Promise_ExternalPurchaseLinkResultIOS__(std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>> promise) noexcept {
+    return PromiseHolder<ExternalPurchaseLinkResultIOS>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const ExternalPurchaseLinkResultIOS& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const ExternalPurchaseLinkResultIOS&)>`.
+   */
+  using Func_void_ExternalPurchaseLinkResultIOS = std::function<void(const ExternalPurchaseLinkResultIOS& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const ExternalPurchaseLinkResultIOS& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_ExternalPurchaseLinkResultIOS_Wrapper final {
+  public:
+    explicit Func_void_ExternalPurchaseLinkResultIOS_Wrapper(std::function<void(const ExternalPurchaseLinkResultIOS& /* result */)>&& func): _function(std::make_unique<std::function<void(const ExternalPurchaseLinkResultIOS& /* result */)>>(std::move(func))) {}
+    inline void call(ExternalPurchaseLinkResultIOS result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const ExternalPurchaseLinkResultIOS& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_ExternalPurchaseLinkResultIOS create_Func_void_ExternalPurchaseLinkResultIOS(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_ExternalPurchaseLinkResultIOS_Wrapper wrap_Func_void_ExternalPurchaseLinkResultIOS(Func_void_ExternalPurchaseLinkResultIOS value) noexcept {
+    return Func_void_ExternalPurchaseLinkResultIOS_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridRnIapSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridRnIapSpec>`.
@@ -1271,5 +1409,23 @@ namespace margelo::nitro::iap::bridge::swift {
   inline Result_std__shared_ptr_Promise_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid____ create_Result_std__shared_ptr_Promise_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid____(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>>>::withError(error);
   }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>>>
+  using Result_std__shared_ptr_Promise_ExternalPurchaseNoticeResultIOS___ = Result<std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>>>;
+  inline Result_std__shared_ptr_Promise_ExternalPurchaseNoticeResultIOS___ create_Result_std__shared_ptr_Promise_ExternalPurchaseNoticeResultIOS___(const std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_ExternalPurchaseNoticeResultIOS___ create_Result_std__shared_ptr_Promise_ExternalPurchaseNoticeResultIOS___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>>>
+  using Result_std__shared_ptr_Promise_ExternalPurchaseLinkResultIOS___ = Result<std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>>>;
+  inline Result_std__shared_ptr_Promise_ExternalPurchaseLinkResultIOS___ create_Result_std__shared_ptr_Promise_ExternalPurchaseLinkResultIOS___(const std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_ExternalPurchaseLinkResultIOS___ create_Result_std__shared_ptr_Promise_ExternalPurchaseLinkResultIOS___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::iap::bridge::swift

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

@@ -8,12 +8,22 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AlternativeBillingModeAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { enum class AlternativeBillingModeAndroid; }
 // Forward declaration of `AndroidSubscriptionOfferInput` to properly resolve imports.
 namespace margelo::nitro::iap { struct AndroidSubscriptionOfferInput; }
+// Forward declaration of `ExternalPurchaseLinkResultIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct ExternalPurchaseLinkResultIOS; }
+// Forward declaration of `ExternalPurchaseNoticeAction` to properly resolve imports.
+namespace margelo::nitro::iap { enum class ExternalPurchaseNoticeAction; }
+// Forward declaration of `ExternalPurchaseNoticeResultIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct ExternalPurchaseNoticeResultIOS; }
 // 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 `InitConnectionConfig` to properly resolve imports.
+namespace margelo::nitro::iap { struct InitConnectionConfig; }
 // Forward declaration of `NitroAvailablePurchasesAndroidOptions` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroAvailablePurchasesAndroidOptions; }
 // Forward declaration of `NitroAvailablePurchasesAndroidType` to properly resolve imports.
@@ -64,11 +74,18 @@ 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 `UserChoiceBillingDetails` to properly resolve imports.
+namespace margelo::nitro::iap { struct UserChoiceBillingDetails; }
 
 // Include C++ defined types
+#include "AlternativeBillingModeAndroid.hpp"
 #include "AndroidSubscriptionOfferInput.hpp"
+#include "ExternalPurchaseLinkResultIOS.hpp"
+#include "ExternalPurchaseNoticeAction.hpp"
+#include "ExternalPurchaseNoticeResultIOS.hpp"
 #include "HybridRnIapSpec.hpp"
 #include "IapPlatform.hpp"
+#include "InitConnectionConfig.hpp"
 #include "NitroAvailablePurchasesAndroidOptions.hpp"
 #include "NitroAvailablePurchasesAndroidType.hpp"
 #include "NitroAvailablePurchasesIosOptions.hpp"
@@ -94,6 +111,7 @@ namespace margelo::nitro::iap { enum class PurchaseState; }
 #include "PurchaseIOS.hpp"
 #include "PurchaseOfferIOS.hpp"
 #include "PurchaseState.hpp"
+#include "UserChoiceBillingDetails.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>

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

@@ -12,6 +12,10 @@
 // Forward declaration of `HybridRnIapSpec_cxx` to properly resolve imports.
 namespace NitroIap { class HybridRnIapSpec_cxx; }
 
+// Forward declaration of `InitConnectionConfig` to properly resolve imports.
+namespace margelo::nitro::iap { struct InitConnectionConfig; }
+// Forward declaration of `AlternativeBillingModeAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { enum class AlternativeBillingModeAndroid; }
 // Forward declaration of `NitroProduct` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroProduct; }
 // Forward declaration of `IapPlatform` to properly resolve imports.
@@ -66,12 +70,22 @@ namespace margelo::nitro::iap { struct NitroReceiptValidationParams; }
 namespace margelo::nitro::iap { struct NitroReceiptValidationAndroidOptions; }
 // Forward declaration of `NitroDeepLinkOptionsAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroDeepLinkOptionsAndroid; }
+// Forward declaration of `UserChoiceBillingDetails` to properly resolve imports.
+namespace margelo::nitro::iap { struct UserChoiceBillingDetails; }
+// Forward declaration of `ExternalPurchaseNoticeResultIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct ExternalPurchaseNoticeResultIOS; }
+// Forward declaration of `ExternalPurchaseNoticeAction` to properly resolve imports.
+namespace margelo::nitro::iap { enum class ExternalPurchaseNoticeAction; }
+// Forward declaration of `ExternalPurchaseLinkResultIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct ExternalPurchaseLinkResultIOS; }
 
 #include <NitroModules/Promise.hpp>
+#include "InitConnectionConfig.hpp"
+#include <optional>
+#include "AlternativeBillingModeAndroid.hpp"
 #include "NitroProduct.hpp"
 #include <vector>
 #include <string>
-#include <optional>
 #include "IapPlatform.hpp"
 #include "NitroOneTimePurchaseOfferDetail.hpp"
 #include "PurchaseAndroid.hpp"
@@ -101,6 +115,10 @@ namespace margelo::nitro::iap { struct NitroDeepLinkOptionsAndroid; }
 #include "NitroReceiptValidationParams.hpp"
 #include "NitroReceiptValidationAndroidOptions.hpp"
 #include "NitroDeepLinkOptionsAndroid.hpp"
+#include "UserChoiceBillingDetails.hpp"
+#include "ExternalPurchaseNoticeResultIOS.hpp"
+#include "ExternalPurchaseNoticeAction.hpp"
+#include "ExternalPurchaseLinkResultIOS.hpp"
 
 #include "NitroIap-Swift-Cxx-Umbrella.hpp"
 
@@ -143,8 +161,8 @@ namespace margelo::nitro::iap {
 
   public:
     // Methods
-    inline std::shared_ptr<Promise<bool>> initConnection() override {
-      auto __result = _swiftPart.initConnection();
+    inline std::shared_ptr<Promise<bool>> initConnection(const std::optional<InitConnectionConfig>& config) override {
+      auto __result = _swiftPart.initConnection(config);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -419,6 +437,66 @@ namespace margelo::nitro::iap {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<bool>> checkAlternativeBillingAvailabilityAndroid() override {
+      auto __result = _swiftPart.checkAlternativeBillingAvailabilityAndroid();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> showAlternativeBillingDialogAndroid() override {
+      auto __result = _swiftPart.showAlternativeBillingDialogAndroid();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::optional<std::string>>> createAlternativeBillingTokenAndroid(const std::optional<std::string>& sku) override {
+      auto __result = _swiftPart.createAlternativeBillingTokenAndroid(sku);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void addUserChoiceBillingListenerAndroid(const std::function<void(const UserChoiceBillingDetails& /* details */)>& listener) override {
+      auto __result = _swiftPart.addUserChoiceBillingListenerAndroid(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void removeUserChoiceBillingListenerAndroid(const std::function<void(const UserChoiceBillingDetails& /* details */)>& listener) override {
+      auto __result = _swiftPart.removeUserChoiceBillingListenerAndroid(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<bool>> canPresentExternalPurchaseNoticeIOS() override {
+      auto __result = _swiftPart.canPresentExternalPurchaseNoticeIOS();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>> presentExternalPurchaseNoticeSheetIOS() override {
+      auto __result = _swiftPart.presentExternalPurchaseNoticeSheetIOS();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<ExternalPurchaseLinkResultIOS>> presentExternalPurchaseLinkIOS(const std::string& url) override {
+      auto __result = _swiftPart.presentExternalPurchaseLinkIOS(url);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroIap::HybridRnIapSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/AlternativeBillingModeAndroid.swift

@@ -0,0 +1,44 @@
+///
+/// AlternativeBillingModeAndroid.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 `AlternativeBillingModeAndroid`, backed by a C++ enum.
+ */
+public typealias AlternativeBillingModeAndroid = margelo.nitro.iap.AlternativeBillingModeAndroid
+
+public extension AlternativeBillingModeAndroid {
+  /**
+   * Get a AlternativeBillingModeAndroid for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "none":
+        self = .none
+      case "user-choice":
+        self = .userChoice
+      case "alternative-only":
+        self = .alternativeOnly
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AlternativeBillingModeAndroid represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .none:
+        return "none"
+      case .userChoice:
+        return "user-choice"
+      case .alternativeOnly:
+        return "alternative-only"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/ExternalPurchaseLinkResultIOS.swift

@@ -0,0 +1,65 @@
+///
+/// ExternalPurchaseLinkResultIOS.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `ExternalPurchaseLinkResultIOS`, backed by a C++ struct.
+ */
+public typealias ExternalPurchaseLinkResultIOS = margelo.nitro.iap.ExternalPurchaseLinkResultIOS
+
+public extension ExternalPurchaseLinkResultIOS {
+  private typealias bridge = margelo.nitro.iap.bridge.swift
+
+  /**
+   * Create a new instance of `ExternalPurchaseLinkResultIOS`.
+   */
+  init(error: String?, success: Bool) {
+    self.init({ () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = error {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), success)
+  }
+
+  var error: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__error) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__error)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__error = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var success: Bool {
+    @inline(__always)
+    get {
+      return self.__success
+    }
+    @inline(__always)
+    set {
+      self.__success = newValue
+    }
+  }
+}

package/nitrogen/generated/ios/swift/ExternalPurchaseNoticeAction.swift

@@ -0,0 +1,40 @@
+///
+/// ExternalPurchaseNoticeAction.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 `ExternalPurchaseNoticeAction`, backed by a C++ enum.
+ */
+public typealias ExternalPurchaseNoticeAction = margelo.nitro.iap.ExternalPurchaseNoticeAction
+
+public extension ExternalPurchaseNoticeAction {
+  /**
+   * Get a ExternalPurchaseNoticeAction for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "continue":
+        self = .continue
+      case "dismissed":
+        self = .dismissed
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this ExternalPurchaseNoticeAction represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .continue:
+        return "continue"
+      case .dismissed:
+        return "dismissed"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/ExternalPurchaseNoticeResultIOS.swift

@@ -0,0 +1,65 @@
+///
+/// ExternalPurchaseNoticeResultIOS.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `ExternalPurchaseNoticeResultIOS`, backed by a C++ struct.
+ */
+public typealias ExternalPurchaseNoticeResultIOS = margelo.nitro.iap.ExternalPurchaseNoticeResultIOS
+
+public extension ExternalPurchaseNoticeResultIOS {
+  private typealias bridge = margelo.nitro.iap.bridge.swift
+
+  /**
+   * Create a new instance of `ExternalPurchaseNoticeResultIOS`.
+   */
+  init(error: String?, result: ExternalPurchaseNoticeAction) {
+    self.init({ () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = error {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), result)
+  }
+
+  var error: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__error) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__error)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__error = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var result: ExternalPurchaseNoticeAction {
+    @inline(__always)
+    get {
+      return self.__result
+    }
+    @inline(__always)
+    set {
+      self.__result = newValue
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_ExternalPurchaseLinkResultIOS.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_ExternalPurchaseLinkResultIOS.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: ExternalPurchaseLinkResultIOS) -> 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_ExternalPurchaseLinkResultIOS {
+  public typealias bridge = margelo.nitro.iap.bridge.swift
+
+  private let closure: (_ value: ExternalPurchaseLinkResultIOS) -> Void
+
+  public init(_ closure: @escaping (_ value: ExternalPurchaseLinkResultIOS) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: ExternalPurchaseLinkResultIOS) -> 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_ExternalPurchaseLinkResultIOS`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_ExternalPurchaseLinkResultIOS>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_ExternalPurchaseLinkResultIOS {
+    return Unmanaged<Func_void_ExternalPurchaseLinkResultIOS>.fromOpaque(pointer).takeRetainedValue()
+  }
+}