react-native-iap 15.4.0-rc.2 → 15.4.0

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

@@ -0,0 +1,53 @@
+///
+/// Variant_NullType_NitroInAppMessageParamsAndroid.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.iap
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.NullType
+
+/**
+ * Represents the TypeScript variant "NullType | NitroInAppMessageParamsAndroid".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class Variant_NullType_NitroInAppMessageParamsAndroid {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: NullType): Variant_NullType_NitroInAppMessageParamsAndroid()
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: NitroInAppMessageParamsAndroid): Variant_NullType_NitroInAppMessageParamsAndroid()
+
+  val isFirst: Boolean
+    get() = this is First
+  val isSecond: Boolean
+    get() = this is Second
+
+  fun asFirstOrNull(): NullType? {
+    val value = (this as? First)?.value ?: return null
+    return value
+  }
+  fun asSecondOrNull(): NitroInAppMessageParamsAndroid? {
+    val value = (this as? Second)?.value ?: return null
+    return value
+  }
+
+  inline fun <R> match(first: (NullType) -> R, second: (NitroInAppMessageParamsAndroid) -> R): R {
+    return when (this) {
+      is First -> first(value)
+      is Second -> second(value)
+    }
+  }
+
+  companion object {
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: NullType): Variant_NullType_NitroInAppMessageParamsAndroid = First(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: NitroInAppMessageParamsAndroid): Variant_NullType_NitroInAppMessageParamsAndroid = Second(value)
+  }
+}

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

@@ -182,6 +182,14 @@ namespace margelo::nitro::iap::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const NitroBillingChoiceInfoAndroid& /* result */)>
+  Func_void_NitroBillingChoiceInfoAndroid create_Func_void_NitroBillingChoiceInfoAndroid(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroIap::Func_void_NitroBillingChoiceInfoAndroid::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const NitroBillingChoiceInfoAndroid& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::function<void(const NitroBillingProgramReportingDetailsAndroid& /* result */)>
   Func_void_NitroBillingProgramReportingDetailsAndroid create_Func_void_NitroBillingProgramReportingDetailsAndroid(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = NitroIap::Func_void_NitroBillingProgramReportingDetailsAndroid::fromUnsafe(swiftClosureWrapper);
@@ -190,6 +198,22 @@ namespace margelo::nitro::iap::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const NitroBillingResultAndroid& /* result */)>
+  Func_void_NitroBillingResultAndroid create_Func_void_NitroBillingResultAndroid(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroIap::Func_void_NitroBillingResultAndroid::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const NitroBillingResultAndroid& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const NitroInAppMessageResultAndroid& /* result */)>
+  Func_void_NitroInAppMessageResultAndroid create_Func_void_NitroInAppMessageResultAndroid(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroIap::Func_void_NitroInAppMessageResultAndroid::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const NitroInAppMessageResultAndroid& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::function<void(const ExternalPurchaseNoticeResultIOS& /* result */)>
   Func_void_ExternalPurchaseNoticeResultIOS create_Func_void_ExternalPurchaseNoticeResultIOS(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = NitroIap::Func_void_ExternalPurchaseNoticeResultIOS::fromUnsafe(swiftClosureWrapper);

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

@@ -20,10 +20,20 @@ namespace margelo::nitro::iap { struct AdvancedCommerceRefundIOS; }
 namespace margelo::nitro::iap { enum class AlternativeBillingModeAndroid; }
 // Forward declaration of `AndroidSubscriptionOfferInput` to properly resolve imports.
 namespace margelo::nitro::iap { struct AndroidSubscriptionOfferInput; }
+// Forward declaration of `BillingChoiceScreenTypeAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { enum class BillingChoiceScreenTypeAndroid; }
 // Forward declaration of `BillingProgramAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { enum class BillingProgramAndroid; }
+// Forward declaration of `DeveloperBillingLaunchModeAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { enum class DeveloperBillingLaunchModeAndroid; }
+// Forward declaration of `DeveloperBillingOptionParamsAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { struct DeveloperBillingOptionParamsAndroid; }
+// Forward declaration of `DeveloperBillingTypeAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { enum class DeveloperBillingTypeAndroid; }
 // Forward declaration of `DeveloperProvidedBillingDetailsAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct DeveloperProvidedBillingDetailsAndroid; }
+// Forward declaration of `DeveloperProvidedBillingProductAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { struct DeveloperProvidedBillingProductAndroid; }
 // Forward declaration of `ExternalPurchaseCustomLinkNoticeResultIOS` to properly resolve imports.
 namespace margelo::nitro::iap { struct ExternalPurchaseCustomLinkNoticeResultIOS; }
 // Forward declaration of `ExternalPurchaseCustomLinkTokenResultIOS` to properly resolve imports.
@@ -42,6 +52,10 @@ namespace margelo::nitro::iap { enum class IapPlatform; }
 namespace margelo::nitro::iap { enum class IapStore; }
 // Forward declaration of `IapkitPurchaseState` to properly resolve imports.
 namespace margelo::nitro::iap { enum class IapkitPurchaseState; }
+// Forward declaration of `InAppMessageCategoryAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { enum class InAppMessageCategoryAndroid; }
+// Forward declaration of `InAppMessageResponseCodeAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { enum class InAppMessageResponseCodeAndroid; }
 // Forward declaration of `InitConnectionConfig` to properly resolve imports.
 namespace margelo::nitro::iap { struct InitConnectionConfig; }
 // Forward declaration of `NitroActiveSubscription` to properly resolve imports.
@@ -54,10 +68,14 @@ namespace margelo::nitro::iap { enum class NitroAvailablePurchasesAndroidType; }
 namespace margelo::nitro::iap { struct NitroAvailablePurchasesIosOptions; }
 // Forward declaration of `NitroAvailablePurchasesOptions` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroAvailablePurchasesOptions; }
+// Forward declaration of `NitroBillingChoiceInfoAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { struct NitroBillingChoiceInfoAndroid; }
 // Forward declaration of `NitroBillingProgramAvailabilityResultAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroBillingProgramAvailabilityResultAndroid; }
 // Forward declaration of `NitroBillingProgramReportingDetailsAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroBillingProgramReportingDetailsAndroid; }
+// Forward declaration of `NitroBillingResultAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { struct NitroBillingResultAndroid; }
 // Forward declaration of `NitroDiscountAmountAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroDiscountAmountAndroid; }
 // Forward declaration of `NitroDiscountDisplayInfoAndroid` to properly resolve imports.
@@ -66,6 +84,10 @@ namespace margelo::nitro::iap { struct NitroDiscountDisplayInfoAndroid; }
 namespace margelo::nitro::iap { struct NitroFinishTransactionAndroidParams; }
 // Forward declaration of `NitroFinishTransactionIosParams` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroFinishTransactionIosParams; }
+// Forward declaration of `NitroInAppMessageParamsAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { struct NitroInAppMessageParamsAndroid; }
+// Forward declaration of `NitroInAppMessageResultAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { struct NitroInAppMessageResultAndroid; }
 // Forward declaration of `NitroLimitedQuantityInfoAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroLimitedQuantityInfoAndroid; }
 // Forward declaration of `NitroOneTimePurchaseOfferDetail` to properly resolve imports.
@@ -120,6 +142,8 @@ namespace margelo::nitro::iap { struct NitroVerifyPurchaseWithProviderResult; }
 namespace margelo::nitro::iap { enum class PaymentModeIOS; }
 // Forward declaration of `PendingPurchaseUpdateAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct PendingPurchaseUpdateAndroid; }
+// Forward declaration of `ProductType` to properly resolve imports.
+namespace margelo::nitro::iap { enum class ProductType; }
 // Forward declaration of `PromotionalOfferJwsInputIOS` to properly resolve imports.
 namespace margelo::nitro::iap { struct PromotionalOfferJwsInputIOS; }
 // Forward declaration of `PurchaseAndroid` to properly resolve imports.
@@ -138,6 +162,8 @@ namespace margelo::nitro::iap { enum class PurchaseVerificationProvider; }
 namespace margelo::nitro::iap { struct RenewalCommitmentInfoIOS; }
 // Forward declaration of `RenewalInfoIOS` to properly resolve imports.
 namespace margelo::nitro::iap { struct RenewalInfoIOS; }
+// Forward declaration of `SubResponseCodeAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { enum class SubResponseCodeAndroid; }
 // Forward declaration of `SubscriptionBillingPlanTypeIOS` to properly resolve imports.
 namespace margelo::nitro::iap { enum class SubscriptionBillingPlanTypeIOS; }
 // Forward declaration of `SubscriptionProductReplacementParamsAndroid` to properly resolve imports.
@@ -162,8 +188,13 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "AdvancedCommerceRefundIOS.hpp"
 #include "AlternativeBillingModeAndroid.hpp"
 #include "AndroidSubscriptionOfferInput.hpp"
+#include "BillingChoiceScreenTypeAndroid.hpp"
 #include "BillingProgramAndroid.hpp"
+#include "DeveloperBillingLaunchModeAndroid.hpp"
+#include "DeveloperBillingOptionParamsAndroid.hpp"
+#include "DeveloperBillingTypeAndroid.hpp"
 #include "DeveloperProvidedBillingDetailsAndroid.hpp"
+#include "DeveloperProvidedBillingProductAndroid.hpp"
 #include "ExternalPurchaseCustomLinkNoticeResultIOS.hpp"
 #include "ExternalPurchaseCustomLinkTokenResultIOS.hpp"
 #include "ExternalPurchaseLinkResultIOS.hpp"
@@ -173,18 +204,24 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "IapPlatform.hpp"
 #include "IapStore.hpp"
 #include "IapkitPurchaseState.hpp"
+#include "InAppMessageCategoryAndroid.hpp"
+#include "InAppMessageResponseCodeAndroid.hpp"
 #include "InitConnectionConfig.hpp"
 #include "NitroActiveSubscription.hpp"
 #include "NitroAvailablePurchasesAndroidOptions.hpp"
 #include "NitroAvailablePurchasesAndroidType.hpp"
 #include "NitroAvailablePurchasesIosOptions.hpp"
 #include "NitroAvailablePurchasesOptions.hpp"
+#include "NitroBillingChoiceInfoAndroid.hpp"
 #include "NitroBillingProgramAvailabilityResultAndroid.hpp"
 #include "NitroBillingProgramReportingDetailsAndroid.hpp"
+#include "NitroBillingResultAndroid.hpp"
 #include "NitroDiscountAmountAndroid.hpp"
 #include "NitroDiscountDisplayInfoAndroid.hpp"
 #include "NitroFinishTransactionAndroidParams.hpp"
 #include "NitroFinishTransactionIosParams.hpp"
+#include "NitroInAppMessageParamsAndroid.hpp"
+#include "NitroInAppMessageResultAndroid.hpp"
 #include "NitroLimitedQuantityInfoAndroid.hpp"
 #include "NitroOneTimePurchaseOfferDetail.hpp"
 #include "NitroPreorderDetailsAndroid.hpp"
@@ -212,6 +249,7 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "NitroVerifyPurchaseWithProviderResult.hpp"
 #include "PaymentModeIOS.hpp"
 #include "PendingPurchaseUpdateAndroid.hpp"
+#include "ProductType.hpp"
 #include "PromotionalOfferJwsInputIOS.hpp"
 #include "PurchaseAndroid.hpp"
 #include "PurchaseIOS.hpp"
@@ -221,6 +259,7 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "PurchaseVerificationProvider.hpp"
 #include "RenewalCommitmentInfoIOS.hpp"
 #include "RenewalInfoIOS.hpp"
+#include "SubResponseCodeAndroid.hpp"
 #include "SubscriptionBillingPlanTypeIOS.hpp"
 #include "SubscriptionProductReplacementParamsAndroid.hpp"
 #include "SubscriptionReplacementModeAndroid.hpp"
@@ -317,6 +356,21 @@ namespace margelo::nitro::iap::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::optional<BillingChoiceScreenTypeAndroid>
+  /**
+   * Specialized version of `std::optional<BillingChoiceScreenTypeAndroid>`.
+   */
+  using std__optional_BillingChoiceScreenTypeAndroid_ = std::optional<BillingChoiceScreenTypeAndroid>;
+  inline std::optional<BillingChoiceScreenTypeAndroid> create_std__optional_BillingChoiceScreenTypeAndroid_(const BillingChoiceScreenTypeAndroid& value) noexcept {
+    return std::optional<BillingChoiceScreenTypeAndroid>(value);
+  }
+  inline bool has_value_std__optional_BillingChoiceScreenTypeAndroid_(const std::optional<BillingChoiceScreenTypeAndroid>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline BillingChoiceScreenTypeAndroid get_std__optional_BillingChoiceScreenTypeAndroid_(const std::optional<BillingChoiceScreenTypeAndroid>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<BillingProgramAndroid>
   /**
    * Specialized version of `std::optional<BillingProgramAndroid>`.
@@ -1702,6 +1756,65 @@ namespace margelo::nitro::iap::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::optional<DeveloperBillingLaunchModeAndroid>
+  /**
+   * Specialized version of `std::optional<DeveloperBillingLaunchModeAndroid>`.
+   */
+  using std__optional_DeveloperBillingLaunchModeAndroid_ = std::optional<DeveloperBillingLaunchModeAndroid>;
+  inline std::optional<DeveloperBillingLaunchModeAndroid> create_std__optional_DeveloperBillingLaunchModeAndroid_(const DeveloperBillingLaunchModeAndroid& value) noexcept {
+    return std::optional<DeveloperBillingLaunchModeAndroid>(value);
+  }
+  inline bool has_value_std__optional_DeveloperBillingLaunchModeAndroid_(const std::optional<DeveloperBillingLaunchModeAndroid>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline DeveloperBillingLaunchModeAndroid get_std__optional_DeveloperBillingLaunchModeAndroid_(const std::optional<DeveloperBillingLaunchModeAndroid>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid_ final {
+    std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid> variant;
+    std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid_(std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline DeveloperBillingOptionParamsAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid_ create_std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid_ create_std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid_(const DeveloperBillingOptionParamsAndroid& value) noexcept {
+    return std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid__ = std::optional<std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>> create_std__optional_std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid__(const std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid__(const std::optional<std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid> get_std__optional_std__variant_nitro__NullType__DeveloperBillingOptionParamsAndroid__(const std::optional<std::variant<nitro::NullType, DeveloperBillingOptionParamsAndroid>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>
   /**
    * Wrapper struct for `std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>`.
@@ -3176,6 +3289,17 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_UserChoiceBillingDetails_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::vector<DeveloperProvidedBillingProductAndroid>
+  /**
+   * Specialized version of `std::vector<DeveloperProvidedBillingProductAndroid>`.
+   */
+  using std__vector_DeveloperProvidedBillingProductAndroid_ = std::vector<DeveloperProvidedBillingProductAndroid>;
+  inline std::vector<DeveloperProvidedBillingProductAndroid> create_std__vector_DeveloperProvidedBillingProductAndroid_(size_t size) noexcept {
+    std::vector<DeveloperProvidedBillingProductAndroid> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
   // pragma MARK: std::function<void(const DeveloperProvidedBillingDetailsAndroid& /* details */)>
   /**
    * Specialized version of `std::function<void(const DeveloperProvidedBillingDetailsAndroid&)>`.
@@ -3232,6 +3356,40 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_NitroBillingProgramAvailabilityResultAndroid_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<NitroBillingChoiceInfoAndroid>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<NitroBillingChoiceInfoAndroid>>`.
+   */
+  using std__shared_ptr_Promise_NitroBillingChoiceInfoAndroid__ = std::shared_ptr<Promise<NitroBillingChoiceInfoAndroid>>;
+  inline std::shared_ptr<Promise<NitroBillingChoiceInfoAndroid>> create_std__shared_ptr_Promise_NitroBillingChoiceInfoAndroid__() noexcept {
+    return Promise<NitroBillingChoiceInfoAndroid>::create();
+  }
+  inline PromiseHolder<NitroBillingChoiceInfoAndroid> wrap_std__shared_ptr_Promise_NitroBillingChoiceInfoAndroid__(std::shared_ptr<Promise<NitroBillingChoiceInfoAndroid>> promise) noexcept {
+    return PromiseHolder<NitroBillingChoiceInfoAndroid>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const NitroBillingChoiceInfoAndroid& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const NitroBillingChoiceInfoAndroid&)>`.
+   */
+  using Func_void_NitroBillingChoiceInfoAndroid = std::function<void(const NitroBillingChoiceInfoAndroid& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const NitroBillingChoiceInfoAndroid& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_NitroBillingChoiceInfoAndroid_Wrapper final {
+  public:
+    explicit Func_void_NitroBillingChoiceInfoAndroid_Wrapper(std::function<void(const NitroBillingChoiceInfoAndroid& /* result */)>&& func): _function(std::make_unique<std::function<void(const NitroBillingChoiceInfoAndroid& /* result */)>>(std::move(func))) {}
+    inline void call(NitroBillingChoiceInfoAndroid result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const NitroBillingChoiceInfoAndroid& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_NitroBillingChoiceInfoAndroid create_Func_void_NitroBillingChoiceInfoAndroid(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_NitroBillingChoiceInfoAndroid_Wrapper wrap_Func_void_NitroBillingChoiceInfoAndroid(Func_void_NitroBillingChoiceInfoAndroid value) noexcept {
+    return Func_void_NitroBillingChoiceInfoAndroid_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<NitroBillingProgramReportingDetailsAndroid>>
   /**
    * Specialized version of `std::shared_ptr<Promise<NitroBillingProgramReportingDetailsAndroid>>`.
@@ -3266,6 +3424,203 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_NitroBillingProgramReportingDetailsAndroid_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<DeveloperBillingTypeAndroid>
+  /**
+   * Specialized version of `std::optional<DeveloperBillingTypeAndroid>`.
+   */
+  using std__optional_DeveloperBillingTypeAndroid_ = std::optional<DeveloperBillingTypeAndroid>;
+  inline std::optional<DeveloperBillingTypeAndroid> create_std__optional_DeveloperBillingTypeAndroid_(const DeveloperBillingTypeAndroid& value) noexcept {
+    return std::optional<DeveloperBillingTypeAndroid>(value);
+  }
+  inline bool has_value_std__optional_DeveloperBillingTypeAndroid_(const std::optional<DeveloperBillingTypeAndroid>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline DeveloperBillingTypeAndroid get_std__optional_DeveloperBillingTypeAndroid_(const std::optional<DeveloperBillingTypeAndroid>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<SubResponseCodeAndroid>
+  /**
+   * Specialized version of `std::optional<SubResponseCodeAndroid>`.
+   */
+  using std__optional_SubResponseCodeAndroid_ = std::optional<SubResponseCodeAndroid>;
+  inline std::optional<SubResponseCodeAndroid> create_std__optional_SubResponseCodeAndroid_(const SubResponseCodeAndroid& value) noexcept {
+    return std::optional<SubResponseCodeAndroid>(value);
+  }
+  inline bool has_value_std__optional_SubResponseCodeAndroid_(const std::optional<SubResponseCodeAndroid>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline SubResponseCodeAndroid get_std__optional_SubResponseCodeAndroid_(const std::optional<SubResponseCodeAndroid>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<NitroBillingResultAndroid>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<NitroBillingResultAndroid>>`.
+   */
+  using std__shared_ptr_Promise_NitroBillingResultAndroid__ = std::shared_ptr<Promise<NitroBillingResultAndroid>>;
+  inline std::shared_ptr<Promise<NitroBillingResultAndroid>> create_std__shared_ptr_Promise_NitroBillingResultAndroid__() noexcept {
+    return Promise<NitroBillingResultAndroid>::create();
+  }
+  inline PromiseHolder<NitroBillingResultAndroid> wrap_std__shared_ptr_Promise_NitroBillingResultAndroid__(std::shared_ptr<Promise<NitroBillingResultAndroid>> promise) noexcept {
+    return PromiseHolder<NitroBillingResultAndroid>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const NitroBillingResultAndroid& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const NitroBillingResultAndroid&)>`.
+   */
+  using Func_void_NitroBillingResultAndroid = std::function<void(const NitroBillingResultAndroid& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const NitroBillingResultAndroid& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_NitroBillingResultAndroid_Wrapper final {
+  public:
+    explicit Func_void_NitroBillingResultAndroid_Wrapper(std::function<void(const NitroBillingResultAndroid& /* result */)>&& func): _function(std::make_unique<std::function<void(const NitroBillingResultAndroid& /* result */)>>(std::move(func))) {}
+    inline void call(NitroBillingResultAndroid result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const NitroBillingResultAndroid& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_NitroBillingResultAndroid create_Func_void_NitroBillingResultAndroid(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_NitroBillingResultAndroid_Wrapper wrap_Func_void_NitroBillingResultAndroid(Func_void_NitroBillingResultAndroid value) noexcept {
+    return Func_void_NitroBillingResultAndroid_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<NitroInAppMessageResultAndroid>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<NitroInAppMessageResultAndroid>>`.
+   */
+  using std__shared_ptr_Promise_NitroInAppMessageResultAndroid__ = std::shared_ptr<Promise<NitroInAppMessageResultAndroid>>;
+  inline std::shared_ptr<Promise<NitroInAppMessageResultAndroid>> create_std__shared_ptr_Promise_NitroInAppMessageResultAndroid__() noexcept {
+    return Promise<NitroInAppMessageResultAndroid>::create();
+  }
+  inline PromiseHolder<NitroInAppMessageResultAndroid> wrap_std__shared_ptr_Promise_NitroInAppMessageResultAndroid__(std::shared_ptr<Promise<NitroInAppMessageResultAndroid>> promise) noexcept {
+    return PromiseHolder<NitroInAppMessageResultAndroid>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const NitroInAppMessageResultAndroid& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const NitroInAppMessageResultAndroid&)>`.
+   */
+  using Func_void_NitroInAppMessageResultAndroid = std::function<void(const NitroInAppMessageResultAndroid& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const NitroInAppMessageResultAndroid& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_NitroInAppMessageResultAndroid_Wrapper final {
+  public:
+    explicit Func_void_NitroInAppMessageResultAndroid_Wrapper(std::function<void(const NitroInAppMessageResultAndroid& /* result */)>&& func): _function(std::make_unique<std::function<void(const NitroInAppMessageResultAndroid& /* result */)>>(std::move(func))) {}
+    inline void call(NitroInAppMessageResultAndroid result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const NitroInAppMessageResultAndroid& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_NitroInAppMessageResultAndroid create_Func_void_NitroInAppMessageResultAndroid(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_NitroInAppMessageResultAndroid_Wrapper wrap_Func_void_NitroInAppMessageResultAndroid(Func_void_NitroInAppMessageResultAndroid value) noexcept {
+    return Func_void_NitroInAppMessageResultAndroid_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<InAppMessageCategoryAndroid>
+  /**
+   * Specialized version of `std::vector<InAppMessageCategoryAndroid>`.
+   */
+  using std__vector_InAppMessageCategoryAndroid_ = std::vector<InAppMessageCategoryAndroid>;
+  inline std::vector<InAppMessageCategoryAndroid> create_std__vector_InAppMessageCategoryAndroid_(size_t size) noexcept {
+    std::vector<InAppMessageCategoryAndroid> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid__ final {
+    std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>> variant;
+    std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid__(std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline std::vector<InAppMessageCategoryAndroid> get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid__ create_std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid__(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid__(value);
+  }
+  inline std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid__ create_std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid__(const std::vector<InAppMessageCategoryAndroid>& value) noexcept {
+    return std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid__(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid___ = std::optional<std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>>;
+  inline std::optional<std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>> create_std__optional_std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid___(const std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid___(const std::optional<std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>> get_std__optional_std__variant_nitro__NullType__std__vector_InAppMessageCategoryAndroid___(const std::optional<std::variant<nitro::NullType, std::vector<InAppMessageCategoryAndroid>>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__NitroInAppMessageParamsAndroid_ final {
+    std::variant<nitro::NullType, NitroInAppMessageParamsAndroid> variant;
+    std__variant_nitro__NullType__NitroInAppMessageParamsAndroid_(std::variant<nitro::NullType, NitroInAppMessageParamsAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline NitroInAppMessageParamsAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroInAppMessageParamsAndroid_ create_std__variant_nitro__NullType__NitroInAppMessageParamsAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroInAppMessageParamsAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__NitroInAppMessageParamsAndroid_ create_std__variant_nitro__NullType__NitroInAppMessageParamsAndroid_(const NitroInAppMessageParamsAndroid& value) noexcept {
+    return std__variant_nitro__NullType__NitroInAppMessageParamsAndroid_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__NitroInAppMessageParamsAndroid__ = std::optional<std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>> create_std__optional_std__variant_nitro__NullType__NitroInAppMessageParamsAndroid__(const std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroInAppMessageParamsAndroid__(const std::optional<std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, NitroInAppMessageParamsAndroid> get_std__optional_std__variant_nitro__NullType__NitroInAppMessageParamsAndroid__(const std::optional<std::variant<nitro::NullType, NitroInAppMessageParamsAndroid>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>>
   /**
    * Specialized version of `std::shared_ptr<Promise<ExternalPurchaseNoticeResultIOS>>`.
@@ -3567,6 +3922,15 @@ namespace margelo::nitro::iap::bridge::swift {
     return Result<std::shared_ptr<Promise<NitroBillingProgramAvailabilityResultAndroid>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<NitroBillingChoiceInfoAndroid>>>
+  using Result_std__shared_ptr_Promise_NitroBillingChoiceInfoAndroid___ = Result<std::shared_ptr<Promise<NitroBillingChoiceInfoAndroid>>>;
+  inline Result_std__shared_ptr_Promise_NitroBillingChoiceInfoAndroid___ create_Result_std__shared_ptr_Promise_NitroBillingChoiceInfoAndroid___(const std::shared_ptr<Promise<NitroBillingChoiceInfoAndroid>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<NitroBillingChoiceInfoAndroid>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_NitroBillingChoiceInfoAndroid___ create_Result_std__shared_ptr_Promise_NitroBillingChoiceInfoAndroid___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<NitroBillingChoiceInfoAndroid>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<NitroBillingProgramReportingDetailsAndroid>>>
   using Result_std__shared_ptr_Promise_NitroBillingProgramReportingDetailsAndroid___ = Result<std::shared_ptr<Promise<NitroBillingProgramReportingDetailsAndroid>>>;
   inline Result_std__shared_ptr_Promise_NitroBillingProgramReportingDetailsAndroid___ create_Result_std__shared_ptr_Promise_NitroBillingProgramReportingDetailsAndroid___(const std::shared_ptr<Promise<NitroBillingProgramReportingDetailsAndroid>>& value) noexcept {
@@ -3576,6 +3940,24 @@ namespace margelo::nitro::iap::bridge::swift {
     return Result<std::shared_ptr<Promise<NitroBillingProgramReportingDetailsAndroid>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<NitroBillingResultAndroid>>>
+  using Result_std__shared_ptr_Promise_NitroBillingResultAndroid___ = Result<std::shared_ptr<Promise<NitroBillingResultAndroid>>>;
+  inline Result_std__shared_ptr_Promise_NitroBillingResultAndroid___ create_Result_std__shared_ptr_Promise_NitroBillingResultAndroid___(const std::shared_ptr<Promise<NitroBillingResultAndroid>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<NitroBillingResultAndroid>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_NitroBillingResultAndroid___ create_Result_std__shared_ptr_Promise_NitroBillingResultAndroid___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<NitroBillingResultAndroid>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<NitroInAppMessageResultAndroid>>>
+  using Result_std__shared_ptr_Promise_NitroInAppMessageResultAndroid___ = Result<std::shared_ptr<Promise<NitroInAppMessageResultAndroid>>>;
+  inline Result_std__shared_ptr_Promise_NitroInAppMessageResultAndroid___ create_Result_std__shared_ptr_Promise_NitroInAppMessageResultAndroid___(const std::shared_ptr<Promise<NitroInAppMessageResultAndroid>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<NitroInAppMessageResultAndroid>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_NitroInAppMessageResultAndroid___ create_Result_std__shared_ptr_Promise_NitroInAppMessageResultAndroid___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<NitroInAppMessageResultAndroid>>>::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 {