react-native-iap 15.4.0-rc.3 → 15.4.1

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.
@@ -96,8 +118,6 @@ namespace margelo::nitro::iap { struct NitroRentalDetailsAndroid; }
 namespace margelo::nitro::iap { struct NitroRequestPurchaseAndroid; }
 // Forward declaration of `NitroRequestPurchaseIos` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroRequestPurchaseIos; }
-// Forward declaration of `NitroSubscriptionRenewalInfo` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroSubscriptionRenewalInfo; }
 // Forward declaration of `NitroSubscriptionStatus` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroSubscriptionStatus; }
 // Forward declaration of `NitroValidTimeWindowAndroid` to properly resolve imports.
@@ -120,6 +140,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 +160,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 +186,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 +202,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"
@@ -200,7 +235,6 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "NitroRentalDetailsAndroid.hpp"
 #include "NitroRequestPurchaseAndroid.hpp"
 #include "NitroRequestPurchaseIos.hpp"
-#include "NitroSubscriptionRenewalInfo.hpp"
 #include "NitroSubscriptionStatus.hpp"
 #include "NitroValidTimeWindowAndroid.hpp"
 #include "NitroVerifyPurchaseWithIapkitAmazonProps.hpp"
@@ -212,6 +246,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 +256,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 +353,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 +1753,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>`.
@@ -2057,6 +2167,36 @@ namespace margelo::nitro::iap::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& 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::variant<bool, NitroPurchaseResult>
   /**
    * Wrapper struct for `std::variant<bool, NitroPurchaseResult>`.
@@ -2454,50 +2594,6 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>
-  /**
-   * Wrapper struct for `std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>`.
-   * 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__NitroSubscriptionRenewalInfo_ final {
-    std::variant<nitro::NullType, NitroSubscriptionRenewalInfo> variant;
-    std__variant_nitro__NullType__NitroSubscriptionRenewalInfo_(std::variant<nitro::NullType, NitroSubscriptionRenewalInfo> variant): variant(variant) { }
-    operator std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>() 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 NitroSubscriptionRenewalInfo get_1() const noexcept {
-      return std::get<1>(variant);
-    }
-  };
-  inline std__variant_nitro__NullType__NitroSubscriptionRenewalInfo_ create_std__variant_nitro__NullType__NitroSubscriptionRenewalInfo_(nitro::NullType value) noexcept {
-    return std__variant_nitro__NullType__NitroSubscriptionRenewalInfo_(value);
-  }
-  inline std__variant_nitro__NullType__NitroSubscriptionRenewalInfo_ create_std__variant_nitro__NullType__NitroSubscriptionRenewalInfo_(const NitroSubscriptionRenewalInfo& value) noexcept {
-    return std__variant_nitro__NullType__NitroSubscriptionRenewalInfo_(value);
-  }
-  
-  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>>
-  /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>>`.
-   */
-  using std__optional_std__variant_nitro__NullType__NitroSubscriptionRenewalInfo__ = std::optional<std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>>;
-  inline std::optional<std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>> create_std__optional_std__variant_nitro__NullType__NitroSubscriptionRenewalInfo__(const std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>& value) noexcept {
-    return std::optional<std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>>(value);
-  }
-  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroSubscriptionRenewalInfo__(const std::optional<std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::variant<nitro::NullType, NitroSubscriptionRenewalInfo> get_std__optional_std__variant_nitro__NullType__NitroSubscriptionRenewalInfo__(const std::optional<std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>>& optional) noexcept {
-    return optional.value();
-  }
-  
   // pragma MARK: std::vector<NitroSubscriptionStatus>
   /**
    * Specialized version of `std::vector<NitroSubscriptionStatus>`.
@@ -3154,6 +3250,61 @@ namespace margelo::nitro::iap::bridge::swift {
     return optional.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::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>`.
+   * 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_DeveloperProvidedBillingProductAndroid__ final {
+    std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>> variant;
+    std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid__(std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>() 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<DeveloperProvidedBillingProductAndroid> get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid__ create_std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid__(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid__(value);
+  }
+  inline std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid__ create_std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid__(const std::vector<DeveloperProvidedBillingProductAndroid>& value) noexcept {
+    return std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid__(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid___ = std::optional<std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>>;
+  inline std::optional<std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>> create_std__optional_std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid___(const std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid___(const std::optional<std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>> get_std__optional_std__variant_nitro__NullType__std__vector_DeveloperProvidedBillingProductAndroid___(const std::optional<std::variant<nitro::NullType, std::vector<DeveloperProvidedBillingProductAndroid>>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::function<void(const UserChoiceBillingDetails& /* details */)>
   /**
    * Specialized version of `std::function<void(const UserChoiceBillingDetails&)>`.
@@ -3232,6 +3383,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 +3451,188 @@ 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::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 +3934,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 +3952,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 {