react-native-iap 14.7.13 → 14.7.15

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

@@ -2,7 +2,7 @@
 /// NitroIap-Swift-Cxx-Bridge.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -200,7 +200,7 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "SubscriptionReplacementModeAndroid.hpp"
 #include "UserChoiceBillingDetails.hpp"
 #include "WinBackOfferInputIOS.hpp"
-#include <NitroModules/FastVectorCopy.hpp>
+#include <NitroModules/Null.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -287,7 +287,7 @@ namespace margelo::nitro::iap::bridge::swift {
     return optional.has_value();
   }
   inline AlternativeBillingModeAndroid get_std__optional_AlternativeBillingModeAndroid_(const std::optional<AlternativeBillingModeAndroid>& optional) noexcept {
-    return *optional;
+    return optional.value();
   }
   
   // pragma MARK: std::optional<BillingProgramAndroid>
@@ -302,22 +302,95 @@ namespace margelo::nitro::iap::bridge::swift {
     return optional.has_value();
   }
   inline BillingProgramAndroid get_std__optional_BillingProgramAndroid_(const std::optional<BillingProgramAndroid>& optional) noexcept {
-    return *optional;
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<InitConnectionConfig>
+  // pragma MARK: std::variant<nitro::NullType, InitConnectionConfig>
   /**
-   * Specialized version of `std::optional<InitConnectionConfig>`.
+   * Wrapper struct for `std::variant<nitro::NullType, InitConnectionConfig>`.
+   * 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__InitConnectionConfig_ final {
+    std::variant<nitro::NullType, InitConnectionConfig> variant;
+    std__variant_nitro__NullType__InitConnectionConfig_(std::variant<nitro::NullType, InitConnectionConfig> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, InitConnectionConfig>() 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 InitConnectionConfig get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__InitConnectionConfig_ create_std__variant_nitro__NullType__InitConnectionConfig_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__InitConnectionConfig_(value);
+  }
+  inline std__variant_nitro__NullType__InitConnectionConfig_ create_std__variant_nitro__NullType__InitConnectionConfig_(const InitConnectionConfig& value) noexcept {
+    return std__variant_nitro__NullType__InitConnectionConfig_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, InitConnectionConfig>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, InitConnectionConfig>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__InitConnectionConfig__ = std::optional<std::variant<nitro::NullType, InitConnectionConfig>>;
+  inline std::optional<std::variant<nitro::NullType, InitConnectionConfig>> create_std__optional_std__variant_nitro__NullType__InitConnectionConfig__(const std::variant<nitro::NullType, InitConnectionConfig>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, InitConnectionConfig>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__InitConnectionConfig__(const std::optional<std::variant<nitro::NullType, InitConnectionConfig>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, InitConnectionConfig> get_std__optional_std__variant_nitro__NullType__InitConnectionConfig__(const std::optional<std::variant<nitro::NullType, InitConnectionConfig>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, std::string>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::string>`.
+   * 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__string_ final {
+    std::variant<nitro::NullType, std::string> variant;
+    std__variant_nitro__NullType__std__string_(std::variant<nitro::NullType, std::string> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::string>() 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::string get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(const std::string& value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::string>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::string>>`.
    */
-  using std__optional_InitConnectionConfig_ = std::optional<InitConnectionConfig>;
-  inline std::optional<InitConnectionConfig> create_std__optional_InitConnectionConfig_(const InitConnectionConfig& value) noexcept {
-    return std::optional<InitConnectionConfig>(value);
+  using std__optional_std__variant_nitro__NullType__std__string__ = std::optional<std::variant<nitro::NullType, std::string>>;
+  inline std::optional<std::variant<nitro::NullType, std::string>> create_std__optional_std__variant_nitro__NullType__std__string__(const std::variant<nitro::NullType, std::string>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::string>>(value);
   }
-  inline bool has_value_std__optional_InitConnectionConfig_(const std::optional<InitConnectionConfig>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__string__(const std::optional<std::variant<nitro::NullType, std::string>>& optional) noexcept {
     return optional.has_value();
   }
-  inline InitConnectionConfig get_std__optional_InitConnectionConfig_(const std::optional<InitConnectionConfig>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, std::string> get_std__optional_std__variant_nitro__NullType__std__string__(const std::optional<std::variant<nitro::NullType, std::string>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::optional<std::string>
@@ -332,82 +405,227 @@ namespace margelo::nitro::iap::bridge::swift {
     return optional.has_value();
   }
   inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return *optional;
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<double>
+  // pragma MARK: std::variant<nitro::NullType, double>
   /**
-   * Specialized version of `std::optional<double>`.
+   * Wrapper struct for `std::variant<nitro::NullType, double>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_double_ = std::optional<double>;
-  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
-    return std::optional<double>(value);
+  struct std__variant_nitro__NullType__double_ final {
+    std::variant<nitro::NullType, double> variant;
+    std__variant_nitro__NullType__double_(std::variant<nitro::NullType, double> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, double>() 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 double get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__double_(value);
   }
-  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+  inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(double value) noexcept {
+    return std__variant_nitro__NullType__double_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, double>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, double>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__double__ = std::optional<std::variant<nitro::NullType, double>>;
+  inline std::optional<std::variant<nitro::NullType, double>> create_std__optional_std__variant_nitro__NullType__double__(const std::variant<nitro::NullType, double>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, double>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
     return optional.has_value();
   }
-  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, double> get_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, bool>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, bool>`.
+   * 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__bool_ final {
+    std::variant<nitro::NullType, bool> variant;
+    std__variant_nitro__NullType__bool_(std::variant<nitro::NullType, bool> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, bool>() 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 bool get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__bool_ create_std__variant_nitro__NullType__bool_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__bool_(value);
+  }
+  inline std__variant_nitro__NullType__bool_ create_std__variant_nitro__NullType__bool_(bool value) noexcept {
+    return std__variant_nitro__NullType__bool_(value);
   }
   
-  // pragma MARK: std::optional<bool>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, bool>>
   /**
-   * Specialized version of `std::optional<bool>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, 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);
+  using std__optional_std__variant_nitro__NullType__bool__ = std::optional<std::variant<nitro::NullType, bool>>;
+  inline std::optional<std::variant<nitro::NullType, bool>> create_std__optional_std__variant_nitro__NullType__bool__(const std::variant<nitro::NullType, bool>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, bool>>(value);
   }
-  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__bool__(const std::optional<std::variant<nitro::NullType, bool>>& optional) noexcept {
     return optional.has_value();
   }
-  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, bool> get_std__optional_std__variant_nitro__NullType__bool__(const std::optional<std::variant<nitro::NullType, bool>>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<NitroDiscountAmountAndroid>
+  // pragma MARK: std::variant<nitro::NullType, NitroDiscountAmountAndroid>
   /**
-   * Specialized version of `std::optional<NitroDiscountAmountAndroid>`.
+   * Wrapper struct for `std::variant<nitro::NullType, NitroDiscountAmountAndroid>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_NitroDiscountAmountAndroid_ = std::optional<NitroDiscountAmountAndroid>;
-  inline std::optional<NitroDiscountAmountAndroid> create_std__optional_NitroDiscountAmountAndroid_(const NitroDiscountAmountAndroid& value) noexcept {
-    return std::optional<NitroDiscountAmountAndroid>(value);
+  struct std__variant_nitro__NullType__NitroDiscountAmountAndroid_ final {
+    std::variant<nitro::NullType, NitroDiscountAmountAndroid> variant;
+    std__variant_nitro__NullType__NitroDiscountAmountAndroid_(std::variant<nitro::NullType, NitroDiscountAmountAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroDiscountAmountAndroid>() 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 NitroDiscountAmountAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroDiscountAmountAndroid_ create_std__variant_nitro__NullType__NitroDiscountAmountAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroDiscountAmountAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__NitroDiscountAmountAndroid_ create_std__variant_nitro__NullType__NitroDiscountAmountAndroid_(const NitroDiscountAmountAndroid& value) noexcept {
+    return std__variant_nitro__NullType__NitroDiscountAmountAndroid_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroDiscountAmountAndroid>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroDiscountAmountAndroid>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__NitroDiscountAmountAndroid__ = std::optional<std::variant<nitro::NullType, NitroDiscountAmountAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, NitroDiscountAmountAndroid>> create_std__optional_std__variant_nitro__NullType__NitroDiscountAmountAndroid__(const std::variant<nitro::NullType, NitroDiscountAmountAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroDiscountAmountAndroid>>(value);
   }
-  inline bool has_value_std__optional_NitroDiscountAmountAndroid_(const std::optional<NitroDiscountAmountAndroid>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroDiscountAmountAndroid__(const std::optional<std::variant<nitro::NullType, NitroDiscountAmountAndroid>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroDiscountAmountAndroid get_std__optional_NitroDiscountAmountAndroid_(const std::optional<NitroDiscountAmountAndroid>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroDiscountAmountAndroid> get_std__optional_std__variant_nitro__NullType__NitroDiscountAmountAndroid__(const std::optional<std::variant<nitro::NullType, NitroDiscountAmountAndroid>>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<NitroDiscountDisplayInfoAndroid>
+  // pragma MARK: std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>
   /**
-   * Specialized version of `std::optional<NitroDiscountDisplayInfoAndroid>`.
+   * Wrapper struct for `std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_NitroDiscountDisplayInfoAndroid_ = std::optional<NitroDiscountDisplayInfoAndroid>;
-  inline std::optional<NitroDiscountDisplayInfoAndroid> create_std__optional_NitroDiscountDisplayInfoAndroid_(const NitroDiscountDisplayInfoAndroid& value) noexcept {
-    return std::optional<NitroDiscountDisplayInfoAndroid>(value);
+  struct std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid_ final {
+    std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid> variant;
+    std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid_(std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>() 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 NitroDiscountDisplayInfoAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid_ create_std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid_ create_std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid_(const NitroDiscountDisplayInfoAndroid& value) noexcept {
+    return std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid_(value);
   }
-  inline bool has_value_std__optional_NitroDiscountDisplayInfoAndroid_(const std::optional<NitroDiscountDisplayInfoAndroid>& optional) noexcept {
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid__ = std::optional<std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>> create_std__optional_std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid__(const std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid__(const std::optional<std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroDiscountDisplayInfoAndroid get_std__optional_NitroDiscountDisplayInfoAndroid_(const std::optional<NitroDiscountDisplayInfoAndroid>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid> get_std__optional_std__variant_nitro__NullType__NitroDiscountDisplayInfoAndroid__(const std::optional<std::variant<nitro::NullType, NitroDiscountDisplayInfoAndroid>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>`.
+   * 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__NitroLimitedQuantityInfoAndroid_ final {
+    std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid> variant;
+    std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid_(std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>() 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 NitroLimitedQuantityInfoAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid_ create_std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid_ create_std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid_(const NitroLimitedQuantityInfoAndroid& value) noexcept {
+    return std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid_(value);
   }
   
-  // pragma MARK: std::optional<NitroLimitedQuantityInfoAndroid>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>>
   /**
-   * Specialized version of `std::optional<NitroLimitedQuantityInfoAndroid>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>>`.
    */
-  using std__optional_NitroLimitedQuantityInfoAndroid_ = std::optional<NitroLimitedQuantityInfoAndroid>;
-  inline std::optional<NitroLimitedQuantityInfoAndroid> create_std__optional_NitroLimitedQuantityInfoAndroid_(const NitroLimitedQuantityInfoAndroid& value) noexcept {
-    return std::optional<NitroLimitedQuantityInfoAndroid>(value);
+  using std__optional_std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid__ = std::optional<std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>> create_std__optional_std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid__(const std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>>(value);
   }
-  inline bool has_value_std__optional_NitroLimitedQuantityInfoAndroid_(const std::optional<NitroLimitedQuantityInfoAndroid>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid__(const std::optional<std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroLimitedQuantityInfoAndroid get_std__optional_NitroLimitedQuantityInfoAndroid_(const std::optional<NitroLimitedQuantityInfoAndroid>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid> get_std__optional_std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid__(const std::optional<std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::vector<std::string>
@@ -421,49 +639,136 @@ namespace margelo::nitro::iap::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<NitroPreorderDetailsAndroid>
+  // pragma MARK: std::variant<nitro::NullType, NitroPreorderDetailsAndroid>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroPreorderDetailsAndroid>`.
+   * 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__NitroPreorderDetailsAndroid_ final {
+    std::variant<nitro::NullType, NitroPreorderDetailsAndroid> variant;
+    std__variant_nitro__NullType__NitroPreorderDetailsAndroid_(std::variant<nitro::NullType, NitroPreorderDetailsAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroPreorderDetailsAndroid>() 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 NitroPreorderDetailsAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroPreorderDetailsAndroid_ create_std__variant_nitro__NullType__NitroPreorderDetailsAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroPreorderDetailsAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__NitroPreorderDetailsAndroid_ create_std__variant_nitro__NullType__NitroPreorderDetailsAndroid_(const NitroPreorderDetailsAndroid& value) noexcept {
+    return std__variant_nitro__NullType__NitroPreorderDetailsAndroid_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroPreorderDetailsAndroid>>
   /**
-   * Specialized version of `std::optional<NitroPreorderDetailsAndroid>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroPreorderDetailsAndroid>>`.
    */
-  using std__optional_NitroPreorderDetailsAndroid_ = std::optional<NitroPreorderDetailsAndroid>;
-  inline std::optional<NitroPreorderDetailsAndroid> create_std__optional_NitroPreorderDetailsAndroid_(const NitroPreorderDetailsAndroid& value) noexcept {
-    return std::optional<NitroPreorderDetailsAndroid>(value);
+  using std__optional_std__variant_nitro__NullType__NitroPreorderDetailsAndroid__ = std::optional<std::variant<nitro::NullType, NitroPreorderDetailsAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, NitroPreorderDetailsAndroid>> create_std__optional_std__variant_nitro__NullType__NitroPreorderDetailsAndroid__(const std::variant<nitro::NullType, NitroPreorderDetailsAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroPreorderDetailsAndroid>>(value);
   }
-  inline bool has_value_std__optional_NitroPreorderDetailsAndroid_(const std::optional<NitroPreorderDetailsAndroid>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroPreorderDetailsAndroid__(const std::optional<std::variant<nitro::NullType, NitroPreorderDetailsAndroid>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroPreorderDetailsAndroid get_std__optional_NitroPreorderDetailsAndroid_(const std::optional<NitroPreorderDetailsAndroid>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroPreorderDetailsAndroid> get_std__optional_std__variant_nitro__NullType__NitroPreorderDetailsAndroid__(const std::optional<std::variant<nitro::NullType, NitroPreorderDetailsAndroid>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroRentalDetailsAndroid>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroRentalDetailsAndroid>`.
+   * 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__NitroRentalDetailsAndroid_ final {
+    std::variant<nitro::NullType, NitroRentalDetailsAndroid> variant;
+    std__variant_nitro__NullType__NitroRentalDetailsAndroid_(std::variant<nitro::NullType, NitroRentalDetailsAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroRentalDetailsAndroid>() 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 NitroRentalDetailsAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroRentalDetailsAndroid_ create_std__variant_nitro__NullType__NitroRentalDetailsAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroRentalDetailsAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__NitroRentalDetailsAndroid_ create_std__variant_nitro__NullType__NitroRentalDetailsAndroid_(const NitroRentalDetailsAndroid& value) noexcept {
+    return std__variant_nitro__NullType__NitroRentalDetailsAndroid_(value);
   }
   
-  // pragma MARK: std::optional<NitroRentalDetailsAndroid>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroRentalDetailsAndroid>>
   /**
-   * Specialized version of `std::optional<NitroRentalDetailsAndroid>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroRentalDetailsAndroid>>`.
    */
-  using std__optional_NitroRentalDetailsAndroid_ = std::optional<NitroRentalDetailsAndroid>;
-  inline std::optional<NitroRentalDetailsAndroid> create_std__optional_NitroRentalDetailsAndroid_(const NitroRentalDetailsAndroid& value) noexcept {
-    return std::optional<NitroRentalDetailsAndroid>(value);
+  using std__optional_std__variant_nitro__NullType__NitroRentalDetailsAndroid__ = std::optional<std::variant<nitro::NullType, NitroRentalDetailsAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, NitroRentalDetailsAndroid>> create_std__optional_std__variant_nitro__NullType__NitroRentalDetailsAndroid__(const std::variant<nitro::NullType, NitroRentalDetailsAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroRentalDetailsAndroid>>(value);
   }
-  inline bool has_value_std__optional_NitroRentalDetailsAndroid_(const std::optional<NitroRentalDetailsAndroid>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroRentalDetailsAndroid__(const std::optional<std::variant<nitro::NullType, NitroRentalDetailsAndroid>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroRentalDetailsAndroid get_std__optional_NitroRentalDetailsAndroid_(const std::optional<NitroRentalDetailsAndroid>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroRentalDetailsAndroid> get_std__optional_std__variant_nitro__NullType__NitroRentalDetailsAndroid__(const std::optional<std::variant<nitro::NullType, NitroRentalDetailsAndroid>>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<NitroValidTimeWindowAndroid>
+  // pragma MARK: std::variant<nitro::NullType, NitroValidTimeWindowAndroid>
   /**
-   * Specialized version of `std::optional<NitroValidTimeWindowAndroid>`.
+   * Wrapper struct for `std::variant<nitro::NullType, NitroValidTimeWindowAndroid>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_NitroValidTimeWindowAndroid_ = std::optional<NitroValidTimeWindowAndroid>;
-  inline std::optional<NitroValidTimeWindowAndroid> create_std__optional_NitroValidTimeWindowAndroid_(const NitroValidTimeWindowAndroid& value) noexcept {
-    return std::optional<NitroValidTimeWindowAndroid>(value);
+  struct std__variant_nitro__NullType__NitroValidTimeWindowAndroid_ final {
+    std::variant<nitro::NullType, NitroValidTimeWindowAndroid> variant;
+    std__variant_nitro__NullType__NitroValidTimeWindowAndroid_(std::variant<nitro::NullType, NitroValidTimeWindowAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroValidTimeWindowAndroid>() 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 NitroValidTimeWindowAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroValidTimeWindowAndroid_ create_std__variant_nitro__NullType__NitroValidTimeWindowAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroValidTimeWindowAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__NitroValidTimeWindowAndroid_ create_std__variant_nitro__NullType__NitroValidTimeWindowAndroid_(const NitroValidTimeWindowAndroid& value) noexcept {
+    return std__variant_nitro__NullType__NitroValidTimeWindowAndroid_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroValidTimeWindowAndroid>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroValidTimeWindowAndroid>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__NitroValidTimeWindowAndroid__ = std::optional<std::variant<nitro::NullType, NitroValidTimeWindowAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, NitroValidTimeWindowAndroid>> create_std__optional_std__variant_nitro__NullType__NitroValidTimeWindowAndroid__(const std::variant<nitro::NullType, NitroValidTimeWindowAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroValidTimeWindowAndroid>>(value);
   }
-  inline bool has_value_std__optional_NitroValidTimeWindowAndroid_(const std::optional<NitroValidTimeWindowAndroid>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroValidTimeWindowAndroid__(const std::optional<std::variant<nitro::NullType, NitroValidTimeWindowAndroid>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroValidTimeWindowAndroid get_std__optional_NitroValidTimeWindowAndroid_(const std::optional<NitroValidTimeWindowAndroid>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroValidTimeWindowAndroid> get_std__optional_std__variant_nitro__NullType__NitroValidTimeWindowAndroid__(const std::optional<std::variant<nitro::NullType, NitroValidTimeWindowAndroid>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::vector<NitroOneTimePurchaseOfferDetail>
@@ -477,19 +782,48 @@ namespace margelo::nitro::iap::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<std::vector<NitroOneTimePurchaseOfferDetail>>
+  // pragma MARK: std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>`.
+   * 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_NitroOneTimePurchaseOfferDetail__ final {
+    std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>> variant;
+    std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail__(std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>() 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<NitroOneTimePurchaseOfferDetail> get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail__ create_std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail__(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail__(value);
+  }
+  inline std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail__ create_std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail__(const std::vector<NitroOneTimePurchaseOfferDetail>& value) noexcept {
+    return std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail__(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>>
   /**
-   * Specialized version of `std::optional<std::vector<NitroOneTimePurchaseOfferDetail>>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>>`.
    */
-  using std__optional_std__vector_NitroOneTimePurchaseOfferDetail__ = std::optional<std::vector<NitroOneTimePurchaseOfferDetail>>;
-  inline std::optional<std::vector<NitroOneTimePurchaseOfferDetail>> create_std__optional_std__vector_NitroOneTimePurchaseOfferDetail__(const std::vector<NitroOneTimePurchaseOfferDetail>& value) noexcept {
-    return std::optional<std::vector<NitroOneTimePurchaseOfferDetail>>(value);
+  using std__optional_std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail___ = std::optional<std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>>;
+  inline std::optional<std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>> create_std__optional_std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail___(const std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>>(value);
   }
-  inline bool has_value_std__optional_std__vector_NitroOneTimePurchaseOfferDetail__(const std::optional<std::vector<NitroOneTimePurchaseOfferDetail>>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail___(const std::optional<std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::vector<NitroOneTimePurchaseOfferDetail> get_std__optional_std__vector_NitroOneTimePurchaseOfferDetail__(const std::optional<std::vector<NitroOneTimePurchaseOfferDetail>>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>> get_std__optional_std__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail___(const std::optional<std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::vector<NitroProduct>
@@ -537,64 +871,180 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__vector_NitroProduct__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::vector<std::string>>
+  // pragma MARK: std::variant<nitro::NullType, std::vector<std::string>>
   /**
-   * Specialized version of `std::optional<std::vector<std::string>>`.
+   * Wrapper struct for `std::variant<nitro::NullType, std::vector<std::string>>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_std__vector_std__string__ = std::optional<std::vector<std::string>>;
-  inline std::optional<std::vector<std::string>> create_std__optional_std__vector_std__string__(const std::vector<std::string>& value) noexcept {
-    return std::optional<std::vector<std::string>>(value);
+  struct std__variant_nitro__NullType__std__vector_std__string__ final {
+    std::variant<nitro::NullType, std::vector<std::string>> variant;
+    std__variant_nitro__NullType__std__vector_std__string__(std::variant<nitro::NullType, std::vector<std::string>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::vector<std::string>>() 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<std::string> get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__vector_std__string__ create_std__variant_nitro__NullType__std__vector_std__string__(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__vector_std__string__(value);
   }
-  inline bool has_value_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+  inline std__variant_nitro__NullType__std__vector_std__string__ create_std__variant_nitro__NullType__std__vector_std__string__(const std::vector<std::string>& value) noexcept {
+    return std__variant_nitro__NullType__std__vector_std__string__(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::vector<std::string>>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::vector<std::string>>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__std__vector_std__string___ = std::optional<std::variant<nitro::NullType, std::vector<std::string>>>;
+  inline std::optional<std::variant<nitro::NullType, std::vector<std::string>>> create_std__optional_std__variant_nitro__NullType__std__vector_std__string___(const std::variant<nitro::NullType, std::vector<std::string>>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::vector<std::string>>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__vector_std__string___(const std::optional<std::variant<nitro::NullType, std::vector<std::string>>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::vector<std::string> get_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, std::vector<std::string>> get_std__optional_std__variant_nitro__NullType__std__vector_std__string___(const std::optional<std::variant<nitro::NullType, std::vector<std::string>>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>`.
+   * 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__PendingPurchaseUpdateAndroid_ final {
+    std::variant<nitro::NullType, PendingPurchaseUpdateAndroid> variant;
+    std__variant_nitro__NullType__PendingPurchaseUpdateAndroid_(std::variant<nitro::NullType, PendingPurchaseUpdateAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>() 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 PendingPurchaseUpdateAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__PendingPurchaseUpdateAndroid_ create_std__variant_nitro__NullType__PendingPurchaseUpdateAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__PendingPurchaseUpdateAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__PendingPurchaseUpdateAndroid_ create_std__variant_nitro__NullType__PendingPurchaseUpdateAndroid_(const PendingPurchaseUpdateAndroid& value) noexcept {
+    return std__variant_nitro__NullType__PendingPurchaseUpdateAndroid_(value);
   }
   
-  // pragma MARK: std::optional<PendingPurchaseUpdateAndroid>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>>
   /**
-   * Specialized version of `std::optional<PendingPurchaseUpdateAndroid>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>>`.
    */
-  using std__optional_PendingPurchaseUpdateAndroid_ = std::optional<PendingPurchaseUpdateAndroid>;
-  inline std::optional<PendingPurchaseUpdateAndroid> create_std__optional_PendingPurchaseUpdateAndroid_(const PendingPurchaseUpdateAndroid& value) noexcept {
-    return std::optional<PendingPurchaseUpdateAndroid>(value);
+  using std__optional_std__variant_nitro__NullType__PendingPurchaseUpdateAndroid__ = std::optional<std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>> create_std__optional_std__variant_nitro__NullType__PendingPurchaseUpdateAndroid__(const std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>>(value);
   }
-  inline bool has_value_std__optional_PendingPurchaseUpdateAndroid_(const std::optional<PendingPurchaseUpdateAndroid>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__PendingPurchaseUpdateAndroid__(const std::optional<std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>>& optional) noexcept {
     return optional.has_value();
   }
-  inline PendingPurchaseUpdateAndroid get_std__optional_PendingPurchaseUpdateAndroid_(const std::optional<PendingPurchaseUpdateAndroid>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, PendingPurchaseUpdateAndroid> get_std__optional_std__variant_nitro__NullType__PendingPurchaseUpdateAndroid__(const std::optional<std::variant<nitro::NullType, PendingPurchaseUpdateAndroid>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, PurchaseOfferIOS>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, PurchaseOfferIOS>`.
+   * 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__PurchaseOfferIOS_ final {
+    std::variant<nitro::NullType, PurchaseOfferIOS> variant;
+    std__variant_nitro__NullType__PurchaseOfferIOS_(std::variant<nitro::NullType, PurchaseOfferIOS> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, PurchaseOfferIOS>() 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 PurchaseOfferIOS get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__PurchaseOfferIOS_ create_std__variant_nitro__NullType__PurchaseOfferIOS_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__PurchaseOfferIOS_(value);
+  }
+  inline std__variant_nitro__NullType__PurchaseOfferIOS_ create_std__variant_nitro__NullType__PurchaseOfferIOS_(const PurchaseOfferIOS& value) noexcept {
+    return std__variant_nitro__NullType__PurchaseOfferIOS_(value);
   }
   
-  // pragma MARK: std::optional<PurchaseOfferIOS>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, PurchaseOfferIOS>>
   /**
-   * Specialized version of `std::optional<PurchaseOfferIOS>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, PurchaseOfferIOS>>`.
    */
-  using std__optional_PurchaseOfferIOS_ = std::optional<PurchaseOfferIOS>;
-  inline std::optional<PurchaseOfferIOS> create_std__optional_PurchaseOfferIOS_(const PurchaseOfferIOS& value) noexcept {
-    return std::optional<PurchaseOfferIOS>(value);
+  using std__optional_std__variant_nitro__NullType__PurchaseOfferIOS__ = std::optional<std::variant<nitro::NullType, PurchaseOfferIOS>>;
+  inline std::optional<std::variant<nitro::NullType, PurchaseOfferIOS>> create_std__optional_std__variant_nitro__NullType__PurchaseOfferIOS__(const std::variant<nitro::NullType, PurchaseOfferIOS>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, PurchaseOfferIOS>>(value);
   }
-  inline bool has_value_std__optional_PurchaseOfferIOS_(const std::optional<PurchaseOfferIOS>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__PurchaseOfferIOS__(const std::optional<std::variant<nitro::NullType, PurchaseOfferIOS>>& optional) noexcept {
     return optional.has_value();
   }
-  inline PurchaseOfferIOS get_std__optional_PurchaseOfferIOS_(const std::optional<PurchaseOfferIOS>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, PurchaseOfferIOS> get_std__optional_std__variant_nitro__NullType__PurchaseOfferIOS__(const std::optional<std::variant<nitro::NullType, PurchaseOfferIOS>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, RenewalInfoIOS>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, RenewalInfoIOS>`.
+   * 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__RenewalInfoIOS_ final {
+    std::variant<nitro::NullType, RenewalInfoIOS> variant;
+    std__variant_nitro__NullType__RenewalInfoIOS_(std::variant<nitro::NullType, RenewalInfoIOS> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, RenewalInfoIOS>() 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 RenewalInfoIOS get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__RenewalInfoIOS_ create_std__variant_nitro__NullType__RenewalInfoIOS_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__RenewalInfoIOS_(value);
+  }
+  inline std__variant_nitro__NullType__RenewalInfoIOS_ create_std__variant_nitro__NullType__RenewalInfoIOS_(const RenewalInfoIOS& value) noexcept {
+    return std__variant_nitro__NullType__RenewalInfoIOS_(value);
   }
   
-  // pragma MARK: std::optional<RenewalInfoIOS>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, RenewalInfoIOS>>
   /**
-   * Specialized version of `std::optional<RenewalInfoIOS>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, RenewalInfoIOS>>`.
    */
-  using std__optional_RenewalInfoIOS_ = std::optional<RenewalInfoIOS>;
-  inline std::optional<RenewalInfoIOS> create_std__optional_RenewalInfoIOS_(const RenewalInfoIOS& value) noexcept {
-    return std::optional<RenewalInfoIOS>(value);
+  using std__optional_std__variant_nitro__NullType__RenewalInfoIOS__ = std::optional<std::variant<nitro::NullType, RenewalInfoIOS>>;
+  inline std::optional<std::variant<nitro::NullType, RenewalInfoIOS>> create_std__optional_std__variant_nitro__NullType__RenewalInfoIOS__(const std::variant<nitro::NullType, RenewalInfoIOS>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, RenewalInfoIOS>>(value);
   }
-  inline bool has_value_std__optional_RenewalInfoIOS_(const std::optional<RenewalInfoIOS>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__RenewalInfoIOS__(const std::optional<std::variant<nitro::NullType, RenewalInfoIOS>>& optional) noexcept {
     return optional.has_value();
   }
-  inline RenewalInfoIOS get_std__optional_RenewalInfoIOS_(const std::optional<RenewalInfoIOS>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, RenewalInfoIOS> get_std__optional_std__variant_nitro__NullType__RenewalInfoIOS__(const std::optional<std::variant<nitro::NullType, RenewalInfoIOS>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::variant<PurchaseAndroid, PurchaseIOS>
@@ -603,7 +1053,7 @@ namespace margelo::nitro::iap::bridge::swift {
    * 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_PurchaseAndroid__PurchaseIOS_ {
+  struct std__variant_PurchaseAndroid__PurchaseIOS_ final {
     std::variant<PurchaseAndroid, PurchaseIOS> variant;
     std__variant_PurchaseAndroid__PurchaseIOS_(std::variant<PurchaseAndroid, PurchaseIOS> variant): variant(variant) { }
     operator std::variant<PurchaseAndroid, PurchaseIOS>() const noexcept {
@@ -637,88 +1087,79 @@ namespace margelo::nitro::iap::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>
+  // pragma MARK: std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>
   /**
-   * Wrapper struct for `std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>`.
+   * Wrapper struct for `std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>`.
    * std::variant cannot be used in Swift because of a Swift bug.
    * Not even specializing it works. So we create a wrapper struct.
    */
-  struct std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ {
-    std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>> variant;
-    std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>> variant): variant(variant) { }
-    operator std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>() const noexcept {
+  struct std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ final {
+    std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>> variant;
+    std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
       return variant.index();
     }
-    inline PurchaseAndroid get_0() const noexcept {
+    inline nitro::NullType get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline PurchaseIOS get_1() const noexcept {
+    inline PurchaseAndroid get_1() const noexcept {
       return std::get<1>(variant);
     }
-    inline std::vector<std::variant<PurchaseAndroid, PurchaseIOS>> get_2() const noexcept {
+    inline PurchaseIOS get_2() const noexcept {
       return std::get<2>(variant);
     }
+    inline std::vector<std::variant<PurchaseAndroid, PurchaseIOS>> get_3() const noexcept {
+      return std::get<3>(variant);
+    }
   };
-  inline std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const PurchaseAndroid& value) noexcept {
-    return std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(value);
-  }
-  inline std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const PurchaseIOS& value) noexcept {
-    return std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(value);
+  inline std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(value);
   }
-  inline std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>& value) noexcept {
-    return std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(value);
+  inline std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const PurchaseAndroid& value) noexcept {
+    return std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(value);
   }
-  
-  // pragma MARK: std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>
-  /**
-   * Specialized version of `std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>`.
-   */
-  using std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ = std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>;
-  inline std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>> create_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(const std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>& value) noexcept {
-    return std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>(value);
-  }
-  inline bool has_value_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& optional) noexcept {
-    return optional.has_value();
+  inline std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const PurchaseIOS& value) noexcept {
+    return std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(value);
   }
-  inline std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>> get_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& optional) noexcept {
-    return *optional;
+  inline std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(const std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>& value) noexcept {
+    return std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(value);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>
+  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>`.
    */
-  using std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______ = std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>;
-  inline std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>> create_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______() noexcept {
-    return Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>::create();
+  using std__shared_ptr_Promise_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____ = std::shared_ptr<Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>;
+  inline std::shared_ptr<Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____() noexcept {
+    return Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>::create();
   }
-  inline PromiseHolder<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>> wrap_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______(std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>> promise) noexcept {
-    return PromiseHolder<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>(std::move(promise));
+  inline PromiseHolder<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____(std::shared_ptr<Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>> promise) noexcept {
+    return PromiseHolder<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>&)>`.
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>&)>`.
    */
-  using Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ = std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& /* result */)>;
+  using Func_void_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ = std::function<void(const std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____Wrapper final {
+  class Func_void_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____Wrapper final {
   public:
-    explicit Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____Wrapper(std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>> result) const noexcept {
+    explicit Func_void_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____Wrapper(std::function<void(const std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ create_Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____Wrapper wrap_Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____(Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____ value) noexcept {
-    return Func_void_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_____Wrapper(std::move(value));
+  Func_void_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ create_Func_void_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____Wrapper wrap_Func_void_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___(Func_void_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS___ value) noexcept {
+    return Func_void_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS____Wrapper(std::move(value));
   }
   
   // pragma MARK: std::unordered_map<std::string, std::string>
@@ -746,64 +1187,180 @@ namespace margelo::nitro::iap::bridge::swift {
     map.emplace(key, value);
   }
   
-  // pragma MARK: std::optional<std::unordered_map<std::string, std::string>>
+  // pragma MARK: std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>
   /**
-   * Specialized version of `std::optional<std::unordered_map<std::string, std::string>>`.
+   * Wrapper struct for `std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>`.
+   * 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__unordered_map_std__string__std__string__ final {
+    std::variant<nitro::NullType, std::unordered_map<std::string, std::string>> variant;
+    std__variant_nitro__NullType__std__unordered_map_std__string__std__string__(std::variant<nitro::NullType, std::unordered_map<std::string, std::string>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>() 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::unordered_map<std::string, std::string> get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__unordered_map_std__string__std__string__ create_std__variant_nitro__NullType__std__unordered_map_std__string__std__string__(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__unordered_map_std__string__std__string__(value);
+  }
+  inline std__variant_nitro__NullType__std__unordered_map_std__string__std__string__ create_std__variant_nitro__NullType__std__unordered_map_std__string__std__string__(const std::unordered_map<std::string, std::string>& value) noexcept {
+    return std__variant_nitro__NullType__std__unordered_map_std__string__std__string__(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>`.
    */
-  using std__optional_std__unordered_map_std__string__std__string__ = std::optional<std::unordered_map<std::string, std::string>>;
-  inline std::optional<std::unordered_map<std::string, std::string>> create_std__optional_std__unordered_map_std__string__std__string__(const std::unordered_map<std::string, std::string>& value) noexcept {
-    return std::optional<std::unordered_map<std::string, std::string>>(value);
+  using std__optional_std__variant_nitro__NullType__std__unordered_map_std__string__std__string___ = std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>;
+  inline std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>> create_std__optional_std__variant_nitro__NullType__std__unordered_map_std__string__std__string___(const std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>(value);
   }
-  inline bool has_value_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__unordered_map_std__string__std__string___(const std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::unordered_map<std::string, std::string> get_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, std::unordered_map<std::string, std::string>> get_std__optional_std__variant_nitro__NullType__std__unordered_map_std__string__std__string___(const std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<PromotionalOfferJwsInputIOS>
+  // pragma MARK: std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>
   /**
-   * Specialized version of `std::optional<PromotionalOfferJwsInputIOS>`.
+   * Wrapper struct for `std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_PromotionalOfferJwsInputIOS_ = std::optional<PromotionalOfferJwsInputIOS>;
-  inline std::optional<PromotionalOfferJwsInputIOS> create_std__optional_PromotionalOfferJwsInputIOS_(const PromotionalOfferJwsInputIOS& value) noexcept {
-    return std::optional<PromotionalOfferJwsInputIOS>(value);
+  struct std__variant_nitro__NullType__PromotionalOfferJwsInputIOS_ final {
+    std::variant<nitro::NullType, PromotionalOfferJwsInputIOS> variant;
+    std__variant_nitro__NullType__PromotionalOfferJwsInputIOS_(std::variant<nitro::NullType, PromotionalOfferJwsInputIOS> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>() 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 PromotionalOfferJwsInputIOS get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__PromotionalOfferJwsInputIOS_ create_std__variant_nitro__NullType__PromotionalOfferJwsInputIOS_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__PromotionalOfferJwsInputIOS_(value);
+  }
+  inline std__variant_nitro__NullType__PromotionalOfferJwsInputIOS_ create_std__variant_nitro__NullType__PromotionalOfferJwsInputIOS_(const PromotionalOfferJwsInputIOS& value) noexcept {
+    return std__variant_nitro__NullType__PromotionalOfferJwsInputIOS_(value);
   }
-  inline bool has_value_std__optional_PromotionalOfferJwsInputIOS_(const std::optional<PromotionalOfferJwsInputIOS>& optional) noexcept {
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__PromotionalOfferJwsInputIOS__ = std::optional<std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>>;
+  inline std::optional<std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>> create_std__optional_std__variant_nitro__NullType__PromotionalOfferJwsInputIOS__(const std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__PromotionalOfferJwsInputIOS__(const std::optional<std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>>& optional) noexcept {
     return optional.has_value();
   }
-  inline PromotionalOfferJwsInputIOS get_std__optional_PromotionalOfferJwsInputIOS_(const std::optional<PromotionalOfferJwsInputIOS>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, PromotionalOfferJwsInputIOS> get_std__optional_std__variant_nitro__NullType__PromotionalOfferJwsInputIOS__(const std::optional<std::variant<nitro::NullType, PromotionalOfferJwsInputIOS>>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<WinBackOfferInputIOS>
+  // pragma MARK: std::variant<nitro::NullType, WinBackOfferInputIOS>
   /**
-   * Specialized version of `std::optional<WinBackOfferInputIOS>`.
+   * Wrapper struct for `std::variant<nitro::NullType, WinBackOfferInputIOS>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_WinBackOfferInputIOS_ = std::optional<WinBackOfferInputIOS>;
-  inline std::optional<WinBackOfferInputIOS> create_std__optional_WinBackOfferInputIOS_(const WinBackOfferInputIOS& value) noexcept {
-    return std::optional<WinBackOfferInputIOS>(value);
+  struct std__variant_nitro__NullType__WinBackOfferInputIOS_ final {
+    std::variant<nitro::NullType, WinBackOfferInputIOS> variant;
+    std__variant_nitro__NullType__WinBackOfferInputIOS_(std::variant<nitro::NullType, WinBackOfferInputIOS> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, WinBackOfferInputIOS>() 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 WinBackOfferInputIOS get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__WinBackOfferInputIOS_ create_std__variant_nitro__NullType__WinBackOfferInputIOS_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__WinBackOfferInputIOS_(value);
   }
-  inline bool has_value_std__optional_WinBackOfferInputIOS_(const std::optional<WinBackOfferInputIOS>& optional) noexcept {
+  inline std__variant_nitro__NullType__WinBackOfferInputIOS_ create_std__variant_nitro__NullType__WinBackOfferInputIOS_(const WinBackOfferInputIOS& value) noexcept {
+    return std__variant_nitro__NullType__WinBackOfferInputIOS_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, WinBackOfferInputIOS>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, WinBackOfferInputIOS>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__WinBackOfferInputIOS__ = std::optional<std::variant<nitro::NullType, WinBackOfferInputIOS>>;
+  inline std::optional<std::variant<nitro::NullType, WinBackOfferInputIOS>> create_std__optional_std__variant_nitro__NullType__WinBackOfferInputIOS__(const std::variant<nitro::NullType, WinBackOfferInputIOS>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, WinBackOfferInputIOS>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__WinBackOfferInputIOS__(const std::optional<std::variant<nitro::NullType, WinBackOfferInputIOS>>& optional) noexcept {
     return optional.has_value();
   }
-  inline WinBackOfferInputIOS get_std__optional_WinBackOfferInputIOS_(const std::optional<WinBackOfferInputIOS>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, WinBackOfferInputIOS> get_std__optional_std__variant_nitro__NullType__WinBackOfferInputIOS__(const std::optional<std::variant<nitro::NullType, WinBackOfferInputIOS>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroRequestPurchaseIos>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroRequestPurchaseIos>`.
+   * 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__NitroRequestPurchaseIos_ final {
+    std::variant<nitro::NullType, NitroRequestPurchaseIos> variant;
+    std__variant_nitro__NullType__NitroRequestPurchaseIos_(std::variant<nitro::NullType, NitroRequestPurchaseIos> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroRequestPurchaseIos>() 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 NitroRequestPurchaseIos get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroRequestPurchaseIos_ create_std__variant_nitro__NullType__NitroRequestPurchaseIos_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroRequestPurchaseIos_(value);
+  }
+  inline std__variant_nitro__NullType__NitroRequestPurchaseIos_ create_std__variant_nitro__NullType__NitroRequestPurchaseIos_(const NitroRequestPurchaseIos& value) noexcept {
+    return std__variant_nitro__NullType__NitroRequestPurchaseIos_(value);
   }
   
-  // pragma MARK: std::optional<NitroRequestPurchaseIos>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroRequestPurchaseIos>>
   /**
-   * Specialized version of `std::optional<NitroRequestPurchaseIos>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroRequestPurchaseIos>>`.
    */
-  using std__optional_NitroRequestPurchaseIos_ = std::optional<NitroRequestPurchaseIos>;
-  inline std::optional<NitroRequestPurchaseIos> create_std__optional_NitroRequestPurchaseIos_(const NitroRequestPurchaseIos& value) noexcept {
-    return std::optional<NitroRequestPurchaseIos>(value);
+  using std__optional_std__variant_nitro__NullType__NitroRequestPurchaseIos__ = std::optional<std::variant<nitro::NullType, NitroRequestPurchaseIos>>;
+  inline std::optional<std::variant<nitro::NullType, NitroRequestPurchaseIos>> create_std__optional_std__variant_nitro__NullType__NitroRequestPurchaseIos__(const std::variant<nitro::NullType, NitroRequestPurchaseIos>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroRequestPurchaseIos>>(value);
   }
-  inline bool has_value_std__optional_NitroRequestPurchaseIos_(const std::optional<NitroRequestPurchaseIos>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroRequestPurchaseIos__(const std::optional<std::variant<nitro::NullType, NitroRequestPurchaseIos>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroRequestPurchaseIos get_std__optional_NitroRequestPurchaseIos_(const std::optional<NitroRequestPurchaseIos>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroRequestPurchaseIos> get_std__optional_std__variant_nitro__NullType__NitroRequestPurchaseIos__(const std::optional<std::variant<nitro::NullType, NitroRequestPurchaseIos>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::vector<AndroidSubscriptionOfferInput>
@@ -817,64 +1374,180 @@ namespace margelo::nitro::iap::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<std::vector<AndroidSubscriptionOfferInput>>
+  // pragma MARK: std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>`.
+   * 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_AndroidSubscriptionOfferInput__ final {
+    std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>> variant;
+    std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput__(std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>() 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<AndroidSubscriptionOfferInput> get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput__ create_std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput__(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput__(value);
+  }
+  inline std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput__ create_std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput__(const std::vector<AndroidSubscriptionOfferInput>& value) noexcept {
+    return std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput__(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>>
   /**
-   * Specialized version of `std::optional<std::vector<AndroidSubscriptionOfferInput>>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>>`.
    */
-  using std__optional_std__vector_AndroidSubscriptionOfferInput__ = std::optional<std::vector<AndroidSubscriptionOfferInput>>;
-  inline std::optional<std::vector<AndroidSubscriptionOfferInput>> create_std__optional_std__vector_AndroidSubscriptionOfferInput__(const std::vector<AndroidSubscriptionOfferInput>& value) noexcept {
-    return std::optional<std::vector<AndroidSubscriptionOfferInput>>(value);
+  using std__optional_std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput___ = std::optional<std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>>;
+  inline std::optional<std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>> create_std__optional_std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput___(const std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>>(value);
   }
-  inline bool has_value_std__optional_std__vector_AndroidSubscriptionOfferInput__(const std::optional<std::vector<AndroidSubscriptionOfferInput>>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput___(const std::optional<std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::vector<AndroidSubscriptionOfferInput> get_std__optional_std__vector_AndroidSubscriptionOfferInput__(const std::optional<std::vector<AndroidSubscriptionOfferInput>>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>> get_std__optional_std__variant_nitro__NullType__std__vector_AndroidSubscriptionOfferInput___(const std::optional<std::variant<nitro::NullType, std::vector<AndroidSubscriptionOfferInput>>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>`.
+   * 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__SubscriptionProductReplacementParamsAndroid_ final {
+    std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid> variant;
+    std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid_(std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>() 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 SubscriptionProductReplacementParamsAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid_ create_std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid_ create_std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid_(const SubscriptionProductReplacementParamsAndroid& value) noexcept {
+    return std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid_(value);
   }
   
-  // pragma MARK: std::optional<SubscriptionProductReplacementParamsAndroid>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>>
   /**
-   * Specialized version of `std::optional<SubscriptionProductReplacementParamsAndroid>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>>`.
    */
-  using std__optional_SubscriptionProductReplacementParamsAndroid_ = std::optional<SubscriptionProductReplacementParamsAndroid>;
-  inline std::optional<SubscriptionProductReplacementParamsAndroid> create_std__optional_SubscriptionProductReplacementParamsAndroid_(const SubscriptionProductReplacementParamsAndroid& value) noexcept {
-    return std::optional<SubscriptionProductReplacementParamsAndroid>(value);
+  using std__optional_std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid__ = std::optional<std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>> create_std__optional_std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid__(const std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>>(value);
   }
-  inline bool has_value_std__optional_SubscriptionProductReplacementParamsAndroid_(const std::optional<SubscriptionProductReplacementParamsAndroid>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid__(const std::optional<std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>>& optional) noexcept {
     return optional.has_value();
   }
-  inline SubscriptionProductReplacementParamsAndroid get_std__optional_SubscriptionProductReplacementParamsAndroid_(const std::optional<SubscriptionProductReplacementParamsAndroid>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid> get_std__optional_std__variant_nitro__NullType__SubscriptionProductReplacementParamsAndroid__(const std::optional<std::variant<nitro::NullType, SubscriptionProductReplacementParamsAndroid>>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<NitroRequestPurchaseAndroid>
+  // pragma MARK: std::variant<nitro::NullType, NitroRequestPurchaseAndroid>
   /**
-   * Specialized version of `std::optional<NitroRequestPurchaseAndroid>`.
+   * Wrapper struct for `std::variant<nitro::NullType, NitroRequestPurchaseAndroid>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_NitroRequestPurchaseAndroid_ = std::optional<NitroRequestPurchaseAndroid>;
-  inline std::optional<NitroRequestPurchaseAndroid> create_std__optional_NitroRequestPurchaseAndroid_(const NitroRequestPurchaseAndroid& value) noexcept {
-    return std::optional<NitroRequestPurchaseAndroid>(value);
+  struct std__variant_nitro__NullType__NitroRequestPurchaseAndroid_ final {
+    std::variant<nitro::NullType, NitroRequestPurchaseAndroid> variant;
+    std__variant_nitro__NullType__NitroRequestPurchaseAndroid_(std::variant<nitro::NullType, NitroRequestPurchaseAndroid> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroRequestPurchaseAndroid>() 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 NitroRequestPurchaseAndroid get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroRequestPurchaseAndroid_ create_std__variant_nitro__NullType__NitroRequestPurchaseAndroid_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroRequestPurchaseAndroid_(value);
+  }
+  inline std__variant_nitro__NullType__NitroRequestPurchaseAndroid_ create_std__variant_nitro__NullType__NitroRequestPurchaseAndroid_(const NitroRequestPurchaseAndroid& value) noexcept {
+    return std__variant_nitro__NullType__NitroRequestPurchaseAndroid_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroRequestPurchaseAndroid>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroRequestPurchaseAndroid>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__NitroRequestPurchaseAndroid__ = std::optional<std::variant<nitro::NullType, NitroRequestPurchaseAndroid>>;
+  inline std::optional<std::variant<nitro::NullType, NitroRequestPurchaseAndroid>> create_std__optional_std__variant_nitro__NullType__NitroRequestPurchaseAndroid__(const std::variant<nitro::NullType, NitroRequestPurchaseAndroid>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroRequestPurchaseAndroid>>(value);
   }
-  inline bool has_value_std__optional_NitroRequestPurchaseAndroid_(const std::optional<NitroRequestPurchaseAndroid>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroRequestPurchaseAndroid__(const std::optional<std::variant<nitro::NullType, NitroRequestPurchaseAndroid>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroRequestPurchaseAndroid get_std__optional_NitroRequestPurchaseAndroid_(const std::optional<NitroRequestPurchaseAndroid>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroRequestPurchaseAndroid> get_std__optional_std__variant_nitro__NullType__NitroRequestPurchaseAndroid__(const std::optional<std::variant<nitro::NullType, NitroRequestPurchaseAndroid>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroRenewalInfoIOS>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroRenewalInfoIOS>`.
+   * 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__NitroRenewalInfoIOS_ final {
+    std::variant<nitro::NullType, NitroRenewalInfoIOS> variant;
+    std__variant_nitro__NullType__NitroRenewalInfoIOS_(std::variant<nitro::NullType, NitroRenewalInfoIOS> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroRenewalInfoIOS>() 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 NitroRenewalInfoIOS get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroRenewalInfoIOS_ create_std__variant_nitro__NullType__NitroRenewalInfoIOS_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroRenewalInfoIOS_(value);
+  }
+  inline std__variant_nitro__NullType__NitroRenewalInfoIOS_ create_std__variant_nitro__NullType__NitroRenewalInfoIOS_(const NitroRenewalInfoIOS& value) noexcept {
+    return std__variant_nitro__NullType__NitroRenewalInfoIOS_(value);
   }
   
-  // pragma MARK: std::optional<NitroRenewalInfoIOS>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroRenewalInfoIOS>>
   /**
-   * Specialized version of `std::optional<NitroRenewalInfoIOS>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroRenewalInfoIOS>>`.
    */
-  using std__optional_NitroRenewalInfoIOS_ = std::optional<NitroRenewalInfoIOS>;
-  inline std::optional<NitroRenewalInfoIOS> create_std__optional_NitroRenewalInfoIOS_(const NitroRenewalInfoIOS& value) noexcept {
-    return std::optional<NitroRenewalInfoIOS>(value);
+  using std__optional_std__variant_nitro__NullType__NitroRenewalInfoIOS__ = std::optional<std::variant<nitro::NullType, NitroRenewalInfoIOS>>;
+  inline std::optional<std::variant<nitro::NullType, NitroRenewalInfoIOS>> create_std__optional_std__variant_nitro__NullType__NitroRenewalInfoIOS__(const std::variant<nitro::NullType, NitroRenewalInfoIOS>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroRenewalInfoIOS>>(value);
   }
-  inline bool has_value_std__optional_NitroRenewalInfoIOS_(const std::optional<NitroRenewalInfoIOS>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroRenewalInfoIOS__(const std::optional<std::variant<nitro::NullType, NitroRenewalInfoIOS>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroRenewalInfoIOS get_std__optional_NitroRenewalInfoIOS_(const std::optional<NitroRenewalInfoIOS>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroRenewalInfoIOS> get_std__optional_std__variant_nitro__NullType__NitroRenewalInfoIOS__(const std::optional<std::variant<nitro::NullType, NitroRenewalInfoIOS>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::vector<NitroPurchase>
@@ -922,19 +1595,48 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__vector_NitroPurchase__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<NitroAvailablePurchasesIosOptions>
+  // pragma MARK: std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>
   /**
-   * Specialized version of `std::optional<NitroAvailablePurchasesIosOptions>`.
+   * Wrapper struct for `std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_NitroAvailablePurchasesIosOptions_ = std::optional<NitroAvailablePurchasesIosOptions>;
-  inline std::optional<NitroAvailablePurchasesIosOptions> create_std__optional_NitroAvailablePurchasesIosOptions_(const NitroAvailablePurchasesIosOptions& value) noexcept {
-    return std::optional<NitroAvailablePurchasesIosOptions>(value);
+  struct std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions_ final {
+    std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions> variant;
+    std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions_(std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>() 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 NitroAvailablePurchasesIosOptions get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions_ create_std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions_(value);
+  }
+  inline std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions_ create_std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions_(const NitroAvailablePurchasesIosOptions& value) noexcept {
+    return std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions__ = std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>>;
+  inline std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>> create_std__optional_std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions__(const std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>>(value);
   }
-  inline bool has_value_std__optional_NitroAvailablePurchasesIosOptions_(const std::optional<NitroAvailablePurchasesIosOptions>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions__(const std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroAvailablePurchasesIosOptions get_std__optional_NitroAvailablePurchasesIosOptions_(const std::optional<NitroAvailablePurchasesIosOptions>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions> get_std__optional_std__variant_nitro__NullType__NitroAvailablePurchasesIosOptions__(const std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesIosOptions>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::optional<NitroAvailablePurchasesAndroidType>
@@ -948,23 +1650,52 @@ namespace margelo::nitro::iap::bridge::swift {
   inline bool has_value_std__optional_NitroAvailablePurchasesAndroidType_(const std::optional<NitroAvailablePurchasesAndroidType>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroAvailablePurchasesAndroidType get_std__optional_NitroAvailablePurchasesAndroidType_(const std::optional<NitroAvailablePurchasesAndroidType>& optional) noexcept {
-    return *optional;
+  inline NitroAvailablePurchasesAndroidType get_std__optional_NitroAvailablePurchasesAndroidType_(const std::optional<NitroAvailablePurchasesAndroidType>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>`.
+   * 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__NitroAvailablePurchasesAndroidOptions_ final {
+    std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions> variant;
+    std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions_(std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>() 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 NitroAvailablePurchasesAndroidOptions get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions_ create_std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions_(value);
+  }
+  inline std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions_ create_std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions_(const NitroAvailablePurchasesAndroidOptions& value) noexcept {
+    return std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions_(value);
   }
   
-  // pragma MARK: std::optional<NitroAvailablePurchasesAndroidOptions>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>>
   /**
-   * Specialized version of `std::optional<NitroAvailablePurchasesAndroidOptions>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>>`.
    */
-  using std__optional_NitroAvailablePurchasesAndroidOptions_ = std::optional<NitroAvailablePurchasesAndroidOptions>;
-  inline std::optional<NitroAvailablePurchasesAndroidOptions> create_std__optional_NitroAvailablePurchasesAndroidOptions_(const NitroAvailablePurchasesAndroidOptions& value) noexcept {
-    return std::optional<NitroAvailablePurchasesAndroidOptions>(value);
+  using std__optional_std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions__ = std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>>;
+  inline std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>> create_std__optional_std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions__(const std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>>(value);
   }
-  inline bool has_value_std__optional_NitroAvailablePurchasesAndroidOptions_(const std::optional<NitroAvailablePurchasesAndroidOptions>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions__(const std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroAvailablePurchasesAndroidOptions get_std__optional_NitroAvailablePurchasesAndroidOptions_(const std::optional<NitroAvailablePurchasesAndroidOptions>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions> get_std__optional_std__variant_nitro__NullType__NitroAvailablePurchasesAndroidOptions__(const std::optional<std::variant<nitro::NullType, NitroAvailablePurchasesAndroidOptions>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::optional<NitroAvailablePurchasesOptions>
@@ -979,7 +1710,7 @@ namespace margelo::nitro::iap::bridge::swift {
     return optional.has_value();
   }
   inline NitroAvailablePurchasesOptions get_std__optional_NitroAvailablePurchasesOptions_(const std::optional<NitroAvailablePurchasesOptions>& optional) noexcept {
-    return *optional;
+    return optional.value();
   }
   
   // pragma MARK: std::vector<NitroActiveSubscription>
@@ -1027,13 +1758,28 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__vector_NitroActiveSubscription__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<std::vector<std::string>>
+  /**
+   * Specialized version of `std::optional<std::vector<std::string>>`.
+   */
+  using std__optional_std__vector_std__string__ = std::optional<std::vector<std::string>>;
+  inline std::optional<std::vector<std::string>> create_std__optional_std__vector_std__string__(const std::vector<std::string>& value) noexcept {
+    return std::optional<std::vector<std::string>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<std::string> get_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::variant<bool, NitroPurchaseResult>
   /**
    * Wrapper struct for `std::variant<bool, NitroPurchaseResult>`.
    * 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_bool__NitroPurchaseResult_ {
+  struct std__variant_bool__NitroPurchaseResult_ final {
     std::variant<bool, NitroPurchaseResult> variant;
     std__variant_bool__NitroPurchaseResult_(std::variant<bool, NitroPurchaseResult> variant): variant(variant) { }
     operator std::variant<bool, NitroPurchaseResult>() const noexcept {
@@ -1090,34 +1836,92 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__variant_bool__NitroPurchaseResult__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<NitroFinishTransactionIosParams>
+  // pragma MARK: std::variant<nitro::NullType, NitroFinishTransactionIosParams>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroFinishTransactionIosParams>`.
+   * 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__NitroFinishTransactionIosParams_ final {
+    std::variant<nitro::NullType, NitroFinishTransactionIosParams> variant;
+    std__variant_nitro__NullType__NitroFinishTransactionIosParams_(std::variant<nitro::NullType, NitroFinishTransactionIosParams> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroFinishTransactionIosParams>() 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 NitroFinishTransactionIosParams get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroFinishTransactionIosParams_ create_std__variant_nitro__NullType__NitroFinishTransactionIosParams_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroFinishTransactionIosParams_(value);
+  }
+  inline std__variant_nitro__NullType__NitroFinishTransactionIosParams_ create_std__variant_nitro__NullType__NitroFinishTransactionIosParams_(const NitroFinishTransactionIosParams& value) noexcept {
+    return std__variant_nitro__NullType__NitroFinishTransactionIosParams_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroFinishTransactionIosParams>>
   /**
-   * Specialized version of `std::optional<NitroFinishTransactionIosParams>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroFinishTransactionIosParams>>`.
    */
-  using std__optional_NitroFinishTransactionIosParams_ = std::optional<NitroFinishTransactionIosParams>;
-  inline std::optional<NitroFinishTransactionIosParams> create_std__optional_NitroFinishTransactionIosParams_(const NitroFinishTransactionIosParams& value) noexcept {
-    return std::optional<NitroFinishTransactionIosParams>(value);
+  using std__optional_std__variant_nitro__NullType__NitroFinishTransactionIosParams__ = std::optional<std::variant<nitro::NullType, NitroFinishTransactionIosParams>>;
+  inline std::optional<std::variant<nitro::NullType, NitroFinishTransactionIosParams>> create_std__optional_std__variant_nitro__NullType__NitroFinishTransactionIosParams__(const std::variant<nitro::NullType, NitroFinishTransactionIosParams>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroFinishTransactionIosParams>>(value);
   }
-  inline bool has_value_std__optional_NitroFinishTransactionIosParams_(const std::optional<NitroFinishTransactionIosParams>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroFinishTransactionIosParams__(const std::optional<std::variant<nitro::NullType, NitroFinishTransactionIosParams>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroFinishTransactionIosParams get_std__optional_NitroFinishTransactionIosParams_(const std::optional<NitroFinishTransactionIosParams>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroFinishTransactionIosParams> get_std__optional_std__variant_nitro__NullType__NitroFinishTransactionIosParams__(const std::optional<std::variant<nitro::NullType, NitroFinishTransactionIosParams>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>`.
+   * 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__NitroFinishTransactionAndroidParams_ final {
+    std::variant<nitro::NullType, NitroFinishTransactionAndroidParams> variant;
+    std__variant_nitro__NullType__NitroFinishTransactionAndroidParams_(std::variant<nitro::NullType, NitroFinishTransactionAndroidParams> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>() 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 NitroFinishTransactionAndroidParams get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroFinishTransactionAndroidParams_ create_std__variant_nitro__NullType__NitroFinishTransactionAndroidParams_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroFinishTransactionAndroidParams_(value);
+  }
+  inline std__variant_nitro__NullType__NitroFinishTransactionAndroidParams_ create_std__variant_nitro__NullType__NitroFinishTransactionAndroidParams_(const NitroFinishTransactionAndroidParams& value) noexcept {
+    return std__variant_nitro__NullType__NitroFinishTransactionAndroidParams_(value);
   }
   
-  // pragma MARK: std::optional<NitroFinishTransactionAndroidParams>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>>
   /**
-   * Specialized version of `std::optional<NitroFinishTransactionAndroidParams>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>>`.
    */
-  using std__optional_NitroFinishTransactionAndroidParams_ = std::optional<NitroFinishTransactionAndroidParams>;
-  inline std::optional<NitroFinishTransactionAndroidParams> create_std__optional_NitroFinishTransactionAndroidParams_(const NitroFinishTransactionAndroidParams& value) noexcept {
-    return std::optional<NitroFinishTransactionAndroidParams>(value);
+  using std__optional_std__variant_nitro__NullType__NitroFinishTransactionAndroidParams__ = std::optional<std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>>;
+  inline std::optional<std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>> create_std__optional_std__variant_nitro__NullType__NitroFinishTransactionAndroidParams__(const std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>>(value);
   }
-  inline bool has_value_std__optional_NitroFinishTransactionAndroidParams_(const std::optional<NitroFinishTransactionAndroidParams>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroFinishTransactionAndroidParams__(const std::optional<std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroFinishTransactionAndroidParams get_std__optional_NitroFinishTransactionAndroidParams_(const std::optional<NitroFinishTransactionAndroidParams>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroFinishTransactionAndroidParams> get_std__optional_std__variant_nitro__NullType__NitroFinishTransactionAndroidParams__(const std::optional<std::variant<nitro::NullType, NitroFinishTransactionAndroidParams>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::function<void(const NitroPurchase& /* purchase */)>
@@ -1220,87 +2024,101 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__string_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::optional<std::string>>>
+  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::optional<std::string>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>`.
    */
-  using std__shared_ptr_Promise_std__optional_std__string___ = std::shared_ptr<Promise<std::optional<std::string>>>;
-  inline std::shared_ptr<Promise<std::optional<std::string>>> create_std__shared_ptr_Promise_std__optional_std__string___() noexcept {
-    return Promise<std::optional<std::string>>::create();
+  using std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___ = std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>;
+  inline std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___() noexcept {
+    return Promise<std::variant<nitro::NullType, std::string>>::create();
   }
-  inline PromiseHolder<std::optional<std::string>> wrap_std__shared_ptr_Promise_std__optional_std__string___(std::shared_ptr<Promise<std::optional<std::string>>> promise) noexcept {
-    return PromiseHolder<std::optional<std::string>>(std::move(promise));
+  inline PromiseHolder<std::variant<nitro::NullType, std::string>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___(std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> promise) noexcept {
+    return PromiseHolder<std::variant<nitro::NullType, std::string>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::optional<std::string>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::optional<std::string>&)>`.
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, std::string>&)>`.
    */
-  using Func_void_std__optional_std__string_ = std::function<void(const std::optional<std::string>& /* result */)>;
+  using Func_void_std__variant_nitro__NullType__std__string_ = std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::optional<std::string>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, std::string>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__optional_std__string__Wrapper final {
+  class Func_void_std__variant_nitro__NullType__std__string__Wrapper final {
   public:
-    explicit Func_void_std__optional_std__string__Wrapper(std::function<void(const std::optional<std::string>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::string>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<std::string> result) const noexcept {
+    explicit Func_void_std__variant_nitro__NullType__std__string__Wrapper(std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<nitro::NullType, std::string> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::optional<std::string>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_std__string_ create_Func_void_std__optional_std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__optional_std__string__Wrapper wrap_Func_void_std__optional_std__string_(Func_void_std__optional_std__string_ value) noexcept {
-    return Func_void_std__optional_std__string__Wrapper(std::move(value));
+  Func_void_std__variant_nitro__NullType__std__string_ create_Func_void_std__variant_nitro__NullType__std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_nitro__NullType__std__string__Wrapper wrap_Func_void_std__variant_nitro__NullType__std__string_(Func_void_std__variant_nitro__NullType__std__string_ value) noexcept {
+    return Func_void_std__variant_nitro__NullType__std__string__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<NitroProduct>
+  // pragma MARK: std::variant<nitro::NullType, NitroProduct>
   /**
-   * Specialized version of `std::optional<NitroProduct>`.
+   * Wrapper struct for `std::variant<nitro::NullType, NitroProduct>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_NitroProduct_ = std::optional<NitroProduct>;
-  inline std::optional<NitroProduct> create_std__optional_NitroProduct_(const NitroProduct& value) noexcept {
-    return std::optional<NitroProduct>(value);
-  }
-  inline bool has_value_std__optional_NitroProduct_(const std::optional<NitroProduct>& optional) noexcept {
-    return optional.has_value();
+  struct std__variant_nitro__NullType__NitroProduct_ final {
+    std::variant<nitro::NullType, NitroProduct> variant;
+    std__variant_nitro__NullType__NitroProduct_(std::variant<nitro::NullType, NitroProduct> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroProduct>() 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 NitroProduct get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroProduct_ create_std__variant_nitro__NullType__NitroProduct_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroProduct_(value);
   }
-  inline NitroProduct get_std__optional_NitroProduct_(const std::optional<NitroProduct>& optional) noexcept {
-    return *optional;
+  inline std__variant_nitro__NullType__NitroProduct_ create_std__variant_nitro__NullType__NitroProduct_(const NitroProduct& value) noexcept {
+    return std__variant_nitro__NullType__NitroProduct_(value);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::optional<NitroProduct>>>
+  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::optional<NitroProduct>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>>`.
    */
-  using std__shared_ptr_Promise_std__optional_NitroProduct___ = std::shared_ptr<Promise<std::optional<NitroProduct>>>;
-  inline std::shared_ptr<Promise<std::optional<NitroProduct>>> create_std__shared_ptr_Promise_std__optional_NitroProduct___() noexcept {
-    return Promise<std::optional<NitroProduct>>::create();
+  using std__shared_ptr_Promise_std__variant_nitro__NullType__NitroProduct___ = std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>>;
+  inline std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroProduct___() noexcept {
+    return Promise<std::variant<nitro::NullType, NitroProduct>>::create();
   }
-  inline PromiseHolder<std::optional<NitroProduct>> wrap_std__shared_ptr_Promise_std__optional_NitroProduct___(std::shared_ptr<Promise<std::optional<NitroProduct>>> promise) noexcept {
-    return PromiseHolder<std::optional<NitroProduct>>(std::move(promise));
+  inline PromiseHolder<std::variant<nitro::NullType, NitroProduct>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroProduct___(std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>> promise) noexcept {
+    return PromiseHolder<std::variant<nitro::NullType, NitroProduct>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::optional<NitroProduct>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, NitroProduct>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::optional<NitroProduct>&)>`.
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, NitroProduct>&)>`.
    */
-  using Func_void_std__optional_NitroProduct_ = std::function<void(const std::optional<NitroProduct>& /* result */)>;
+  using Func_void_std__variant_nitro__NullType__NitroProduct_ = std::function<void(const std::variant<nitro::NullType, NitroProduct>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::optional<NitroProduct>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, NitroProduct>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__optional_NitroProduct__Wrapper final {
+  class Func_void_std__variant_nitro__NullType__NitroProduct__Wrapper final {
   public:
-    explicit Func_void_std__optional_NitroProduct__Wrapper(std::function<void(const std::optional<NitroProduct>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<NitroProduct>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<NitroProduct> result) const noexcept {
+    explicit Func_void_std__variant_nitro__NullType__NitroProduct__Wrapper(std::function<void(const std::variant<nitro::NullType, NitroProduct>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, NitroProduct>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<nitro::NullType, NitroProduct> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::optional<NitroProduct>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, NitroProduct>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_NitroProduct_ create_Func_void_std__optional_NitroProduct_(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__optional_NitroProduct__Wrapper wrap_Func_void_std__optional_NitroProduct_(Func_void_std__optional_NitroProduct_ value) noexcept {
-    return Func_void_std__optional_NitroProduct__Wrapper(std::move(value));
+  Func_void_std__variant_nitro__NullType__NitroProduct_ create_Func_void_std__variant_nitro__NullType__NitroProduct_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_nitro__NullType__NitroProduct__Wrapper wrap_Func_void_std__variant_nitro__NullType__NitroProduct_(Func_void_std__variant_nitro__NullType__NitroProduct_ value) noexcept {
+    return Func_void_std__variant_nitro__NullType__NitroProduct__Wrapper(std::move(value));
   }
   
   // pragma MARK: std::shared_ptr<Promise<void>>
@@ -1337,19 +2155,48 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<NitroSubscriptionRenewalInfo>
+  // 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<NitroSubscriptionRenewalInfo>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroSubscriptionRenewalInfo>>`.
    */
-  using std__optional_NitroSubscriptionRenewalInfo_ = std::optional<NitroSubscriptionRenewalInfo>;
-  inline std::optional<NitroSubscriptionRenewalInfo> create_std__optional_NitroSubscriptionRenewalInfo_(const NitroSubscriptionRenewalInfo& value) noexcept {
-    return std::optional<NitroSubscriptionRenewalInfo>(value);
+  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_NitroSubscriptionRenewalInfo_(const std::optional<NitroSubscriptionRenewalInfo>& optional) noexcept {
+  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 NitroSubscriptionRenewalInfo get_std__optional_NitroSubscriptionRenewalInfo_(const std::optional<NitroSubscriptionRenewalInfo>& optional) noexcept {
-    return *optional;
+  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>
@@ -1363,102 +2210,145 @@ namespace margelo::nitro::iap::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<std::vector<NitroSubscriptionStatus>>
+  // pragma MARK: std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>
   /**
-   * Specialized version of `std::optional<std::vector<NitroSubscriptionStatus>>`.
+   * Wrapper struct for `std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_std__vector_NitroSubscriptionStatus__ = std::optional<std::vector<NitroSubscriptionStatus>>;
-  inline std::optional<std::vector<NitroSubscriptionStatus>> create_std__optional_std__vector_NitroSubscriptionStatus__(const std::vector<NitroSubscriptionStatus>& value) noexcept {
-    return std::optional<std::vector<NitroSubscriptionStatus>>(value);
-  }
-  inline bool has_value_std__optional_std__vector_NitroSubscriptionStatus__(const std::optional<std::vector<NitroSubscriptionStatus>>& optional) noexcept {
-    return optional.has_value();
+  struct std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__ final {
+    std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>> variant;
+    std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__(std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>() 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<NitroSubscriptionStatus> get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__ create_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__(value);
   }
-  inline std::vector<NitroSubscriptionStatus> get_std__optional_std__vector_NitroSubscriptionStatus__(const std::optional<std::vector<NitroSubscriptionStatus>>& optional) noexcept {
-    return *optional;
+  inline std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__ create_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__(const std::vector<NitroSubscriptionStatus>& value) noexcept {
+    return std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__(value);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>
+  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>>`.
    */
-  using std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus____ = std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>;
-  inline std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>> create_std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus____() noexcept {
-    return Promise<std::optional<std::vector<NitroSubscriptionStatus>>>::create();
+  using std__shared_ptr_Promise_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus____ = std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>>;
+  inline std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus____() noexcept {
+    return Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>::create();
   }
-  inline PromiseHolder<std::optional<std::vector<NitroSubscriptionStatus>>> wrap_std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus____(std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>> promise) noexcept {
-    return PromiseHolder<std::optional<std::vector<NitroSubscriptionStatus>>>(std::move(promise));
+  inline PromiseHolder<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus____(std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>> promise) noexcept {
+    return PromiseHolder<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::optional<std::vector<NitroSubscriptionStatus>>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::optional<std::vector<NitroSubscriptionStatus>>&)>`.
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>&)>`.
    */
-  using Func_void_std__optional_std__vector_NitroSubscriptionStatus__ = std::function<void(const std::optional<std::vector<NitroSubscriptionStatus>>& /* result */)>;
+  using Func_void_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__ = std::function<void(const std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::optional<std::vector<NitroSubscriptionStatus>>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__optional_std__vector_NitroSubscriptionStatus___Wrapper final {
+  class Func_void_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus___Wrapper final {
   public:
-    explicit Func_void_std__optional_std__vector_NitroSubscriptionStatus___Wrapper(std::function<void(const std::optional<std::vector<NitroSubscriptionStatus>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::vector<NitroSubscriptionStatus>>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<std::vector<NitroSubscriptionStatus>> result) const noexcept {
+    explicit Func_void_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus___Wrapper(std::function<void(const std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::optional<std::vector<NitroSubscriptionStatus>>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_std__vector_NitroSubscriptionStatus__ create_Func_void_std__optional_std__vector_NitroSubscriptionStatus__(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__optional_std__vector_NitroSubscriptionStatus___Wrapper wrap_Func_void_std__optional_std__vector_NitroSubscriptionStatus__(Func_void_std__optional_std__vector_NitroSubscriptionStatus__ value) noexcept {
-    return Func_void_std__optional_std__vector_NitroSubscriptionStatus___Wrapper(std::move(value));
+  Func_void_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__ create_Func_void_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus___Wrapper wrap_Func_void_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__(Func_void_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus__ value) noexcept {
+    return Func_void_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus___Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<NitroPurchase>
+  // pragma MARK: std::variant<nitro::NullType, NitroPurchase>
   /**
-   * Specialized version of `std::optional<NitroPurchase>`.
+   * Wrapper struct for `std::variant<nitro::NullType, NitroPurchase>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  using std__optional_NitroPurchase_ = std::optional<NitroPurchase>;
-  inline std::optional<NitroPurchase> create_std__optional_NitroPurchase_(const NitroPurchase& value) noexcept {
-    return std::optional<NitroPurchase>(value);
-  }
-  inline bool has_value_std__optional_NitroPurchase_(const std::optional<NitroPurchase>& optional) noexcept {
-    return optional.has_value();
+  struct std__variant_nitro__NullType__NitroPurchase_ final {
+    std::variant<nitro::NullType, NitroPurchase> variant;
+    std__variant_nitro__NullType__NitroPurchase_(std::variant<nitro::NullType, NitroPurchase> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroPurchase>() 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 NitroPurchase get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroPurchase_ create_std__variant_nitro__NullType__NitroPurchase_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroPurchase_(value);
   }
-  inline NitroPurchase get_std__optional_NitroPurchase_(const std::optional<NitroPurchase>& optional) noexcept {
-    return *optional;
+  inline std__variant_nitro__NullType__NitroPurchase_ create_std__variant_nitro__NullType__NitroPurchase_(const NitroPurchase& value) noexcept {
+    return std__variant_nitro__NullType__NitroPurchase_(value);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::optional<NitroPurchase>>>
+  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::optional<NitroPurchase>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>>`.
    */
-  using std__shared_ptr_Promise_std__optional_NitroPurchase___ = std::shared_ptr<Promise<std::optional<NitroPurchase>>>;
-  inline std::shared_ptr<Promise<std::optional<NitroPurchase>>> create_std__shared_ptr_Promise_std__optional_NitroPurchase___() noexcept {
-    return Promise<std::optional<NitroPurchase>>::create();
+  using std__shared_ptr_Promise_std__variant_nitro__NullType__NitroPurchase___ = std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>>;
+  inline std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroPurchase___() noexcept {
+    return Promise<std::variant<nitro::NullType, NitroPurchase>>::create();
   }
-  inline PromiseHolder<std::optional<NitroPurchase>> wrap_std__shared_ptr_Promise_std__optional_NitroPurchase___(std::shared_ptr<Promise<std::optional<NitroPurchase>>> promise) noexcept {
-    return PromiseHolder<std::optional<NitroPurchase>>(std::move(promise));
+  inline PromiseHolder<std::variant<nitro::NullType, NitroPurchase>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroPurchase___(std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>> promise) noexcept {
+    return PromiseHolder<std::variant<nitro::NullType, NitroPurchase>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::optional<NitroPurchase>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, NitroPurchase>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::optional<NitroPurchase>&)>`.
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, NitroPurchase>&)>`.
    */
-  using Func_void_std__optional_NitroPurchase_ = std::function<void(const std::optional<NitroPurchase>& /* result */)>;
+  using Func_void_std__variant_nitro__NullType__NitroPurchase_ = std::function<void(const std::variant<nitro::NullType, NitroPurchase>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::optional<NitroPurchase>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, NitroPurchase>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__optional_NitroPurchase__Wrapper final {
+  class Func_void_std__variant_nitro__NullType__NitroPurchase__Wrapper final {
   public:
-    explicit Func_void_std__optional_NitroPurchase__Wrapper(std::function<void(const std::optional<NitroPurchase>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<NitroPurchase>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<NitroPurchase> result) const noexcept {
+    explicit Func_void_std__variant_nitro__NullType__NitroPurchase__Wrapper(std::function<void(const std::variant<nitro::NullType, NitroPurchase>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, NitroPurchase>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<nitro::NullType, NitroPurchase> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::optional<NitroPurchase>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, NitroPurchase>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_NitroPurchase_ create_Func_void_std__optional_NitroPurchase_(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__optional_NitroPurchase__Wrapper wrap_Func_void_std__optional_NitroPurchase_(Func_void_std__optional_NitroPurchase_ value) noexcept {
-    return Func_void_std__optional_NitroPurchase__Wrapper(std::move(value));
+  Func_void_std__variant_nitro__NullType__NitroPurchase_ create_Func_void_std__variant_nitro__NullType__NitroPurchase_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_nitro__NullType__NitroPurchase__Wrapper wrap_Func_void_std__variant_nitro__NullType__NitroPurchase_(Func_void_std__variant_nitro__NullType__NitroPurchase_ value) noexcept {
+    return Func_void_std__variant_nitro__NullType__NitroPurchase__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroPurchase>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroPurchase>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__NitroPurchase__ = std::optional<std::variant<nitro::NullType, NitroPurchase>>;
+  inline std::optional<std::variant<nitro::NullType, NitroPurchase>> create_std__optional_std__variant_nitro__NullType__NitroPurchase__(const std::variant<nitro::NullType, NitroPurchase>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroPurchase>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroPurchase__(const std::optional<std::variant<nitro::NullType, NitroPurchase>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, NitroPurchase> get_std__optional_std__variant_nitro__NullType__NitroPurchase__(const std::optional<std::variant<nitro::NullType, NitroPurchase>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>
@@ -1467,7 +2357,7 @@ namespace margelo::nitro::iap::bridge::swift {
    * 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_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_ {
+  struct std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_ final {
     std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid> variant;
     std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_(std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid> variant): variant(variant) { }
     operator std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>() const noexcept {
@@ -1524,64 +2414,180 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<NitroReceiptValidationAppleOptions>
+  // pragma MARK: std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>`.
+   * 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__NitroReceiptValidationAppleOptions_ final {
+    std::variant<nitro::NullType, NitroReceiptValidationAppleOptions> variant;
+    std__variant_nitro__NullType__NitroReceiptValidationAppleOptions_(std::variant<nitro::NullType, NitroReceiptValidationAppleOptions> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>() 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 NitroReceiptValidationAppleOptions get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroReceiptValidationAppleOptions_ create_std__variant_nitro__NullType__NitroReceiptValidationAppleOptions_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroReceiptValidationAppleOptions_(value);
+  }
+  inline std__variant_nitro__NullType__NitroReceiptValidationAppleOptions_ create_std__variant_nitro__NullType__NitroReceiptValidationAppleOptions_(const NitroReceiptValidationAppleOptions& value) noexcept {
+    return std__variant_nitro__NullType__NitroReceiptValidationAppleOptions_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>>
   /**
-   * Specialized version of `std::optional<NitroReceiptValidationAppleOptions>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>>`.
    */
-  using std__optional_NitroReceiptValidationAppleOptions_ = std::optional<NitroReceiptValidationAppleOptions>;
-  inline std::optional<NitroReceiptValidationAppleOptions> create_std__optional_NitroReceiptValidationAppleOptions_(const NitroReceiptValidationAppleOptions& value) noexcept {
-    return std::optional<NitroReceiptValidationAppleOptions>(value);
+  using std__optional_std__variant_nitro__NullType__NitroReceiptValidationAppleOptions__ = std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>>;
+  inline std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>> create_std__optional_std__variant_nitro__NullType__NitroReceiptValidationAppleOptions__(const std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>>(value);
   }
-  inline bool has_value_std__optional_NitroReceiptValidationAppleOptions_(const std::optional<NitroReceiptValidationAppleOptions>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroReceiptValidationAppleOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroReceiptValidationAppleOptions get_std__optional_NitroReceiptValidationAppleOptions_(const std::optional<NitroReceiptValidationAppleOptions>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroReceiptValidationAppleOptions> get_std__optional_std__variant_nitro__NullType__NitroReceiptValidationAppleOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>`.
+   * 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__NitroReceiptValidationGoogleOptions_ final {
+    std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions> variant;
+    std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions_(std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>() 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 NitroReceiptValidationGoogleOptions get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions_ create_std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions_(value);
+  }
+  inline std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions_ create_std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions_(const NitroReceiptValidationGoogleOptions& value) noexcept {
+    return std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions_(value);
   }
   
-  // pragma MARK: std::optional<NitroReceiptValidationGoogleOptions>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>>
   /**
-   * Specialized version of `std::optional<NitroReceiptValidationGoogleOptions>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>>`.
    */
-  using std__optional_NitroReceiptValidationGoogleOptions_ = std::optional<NitroReceiptValidationGoogleOptions>;
-  inline std::optional<NitroReceiptValidationGoogleOptions> create_std__optional_NitroReceiptValidationGoogleOptions_(const NitroReceiptValidationGoogleOptions& value) noexcept {
-    return std::optional<NitroReceiptValidationGoogleOptions>(value);
+  using std__optional_std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions__ = std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>>;
+  inline std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>> create_std__optional_std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions__(const std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>>(value);
   }
-  inline bool has_value_std__optional_NitroReceiptValidationGoogleOptions_(const std::optional<NitroReceiptValidationGoogleOptions>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroReceiptValidationGoogleOptions get_std__optional_NitroReceiptValidationGoogleOptions_(const std::optional<NitroReceiptValidationGoogleOptions>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions> get_std__optional_std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>`.
+   * 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__NitroReceiptValidationHorizonOptions_ final {
+    std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions> variant;
+    std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions_(std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>() 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 NitroReceiptValidationHorizonOptions get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions_ create_std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions_(value);
+  }
+  inline std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions_ create_std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions_(const NitroReceiptValidationHorizonOptions& value) noexcept {
+    return std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions_(value);
   }
   
-  // pragma MARK: std::optional<NitroReceiptValidationHorizonOptions>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>>
   /**
-   * Specialized version of `std::optional<NitroReceiptValidationHorizonOptions>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>>`.
    */
-  using std__optional_NitroReceiptValidationHorizonOptions_ = std::optional<NitroReceiptValidationHorizonOptions>;
-  inline std::optional<NitroReceiptValidationHorizonOptions> create_std__optional_NitroReceiptValidationHorizonOptions_(const NitroReceiptValidationHorizonOptions& value) noexcept {
-    return std::optional<NitroReceiptValidationHorizonOptions>(value);
+  using std__optional_std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions__ = std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>>;
+  inline std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>> create_std__optional_std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions__(const std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>>(value);
   }
-  inline bool has_value_std__optional_NitroReceiptValidationHorizonOptions_(const std::optional<NitroReceiptValidationHorizonOptions>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroReceiptValidationHorizonOptions get_std__optional_NitroReceiptValidationHorizonOptions_(const std::optional<NitroReceiptValidationHorizonOptions>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions> get_std__optional_std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>`.
+   * 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__NitroVerifyPurchaseWithIapkitResult_ final {
+    std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult> variant;
+    std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult_(std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>() 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 NitroVerifyPurchaseWithIapkitResult get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult_ create_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult_(value);
+  }
+  inline std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult_ create_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult_(const NitroVerifyPurchaseWithIapkitResult& value) noexcept {
+    return std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult_(value);
   }
   
-  // pragma MARK: std::optional<NitroVerifyPurchaseWithIapkitResult>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>>
   /**
-   * Specialized version of `std::optional<NitroVerifyPurchaseWithIapkitResult>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>>`.
    */
-  using std__optional_NitroVerifyPurchaseWithIapkitResult_ = std::optional<NitroVerifyPurchaseWithIapkitResult>;
-  inline std::optional<NitroVerifyPurchaseWithIapkitResult> create_std__optional_NitroVerifyPurchaseWithIapkitResult_(const NitroVerifyPurchaseWithIapkitResult& value) noexcept {
-    return std::optional<NitroVerifyPurchaseWithIapkitResult>(value);
+  using std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult__ = std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>>;
+  inline std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>> create_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult__(const std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>>(value);
   }
-  inline bool has_value_std__optional_NitroVerifyPurchaseWithIapkitResult_(const std::optional<NitroVerifyPurchaseWithIapkitResult>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult__(const std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroVerifyPurchaseWithIapkitResult get_std__optional_NitroVerifyPurchaseWithIapkitResult_(const std::optional<NitroVerifyPurchaseWithIapkitResult>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult> get_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitResult__(const std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitResult>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::vector<NitroVerifyPurchaseWithProviderError>
@@ -1595,19 +2601,48 @@ namespace margelo::nitro::iap::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<std::vector<NitroVerifyPurchaseWithProviderError>>
+  // pragma MARK: std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>`.
+   * 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_NitroVerifyPurchaseWithProviderError__ final {
+    std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>> variant;
+    std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError__(std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>() 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<NitroVerifyPurchaseWithProviderError> get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError__ create_std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError__(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError__(value);
+  }
+  inline std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError__ create_std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError__(const std::vector<NitroVerifyPurchaseWithProviderError>& value) noexcept {
+    return std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError__(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>>
   /**
-   * Specialized version of `std::optional<std::vector<NitroVerifyPurchaseWithProviderError>>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>>`.
    */
-  using std__optional_std__vector_NitroVerifyPurchaseWithProviderError__ = std::optional<std::vector<NitroVerifyPurchaseWithProviderError>>;
-  inline std::optional<std::vector<NitroVerifyPurchaseWithProviderError>> create_std__optional_std__vector_NitroVerifyPurchaseWithProviderError__(const std::vector<NitroVerifyPurchaseWithProviderError>& value) noexcept {
-    return std::optional<std::vector<NitroVerifyPurchaseWithProviderError>>(value);
+  using std__optional_std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError___ = std::optional<std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>>;
+  inline std::optional<std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>> create_std__optional_std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError___(const std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>>(value);
   }
-  inline bool has_value_std__optional_std__vector_NitroVerifyPurchaseWithProviderError__(const std::optional<std::vector<NitroVerifyPurchaseWithProviderError>>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError___(const std::optional<std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::vector<NitroVerifyPurchaseWithProviderError> get_std__optional_std__vector_NitroVerifyPurchaseWithProviderError__(const std::optional<std::vector<NitroVerifyPurchaseWithProviderError>>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>> get_std__optional_std__variant_nitro__NullType__std__vector_NitroVerifyPurchaseWithProviderError___(const std::optional<std::variant<nitro::NullType, std::vector<NitroVerifyPurchaseWithProviderError>>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::shared_ptr<Promise<NitroVerifyPurchaseWithProviderResult>>
@@ -1644,49 +2679,136 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_NitroVerifyPurchaseWithProviderResult_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<NitroVerifyPurchaseWithIapkitAppleProps>
+  // pragma MARK: std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>`.
+   * 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__NitroVerifyPurchaseWithIapkitAppleProps_ final {
+    std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps> variant;
+    std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps_(std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>() 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 NitroVerifyPurchaseWithIapkitAppleProps get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps_ create_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps_(value);
+  }
+  inline std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps_ create_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps_(const NitroVerifyPurchaseWithIapkitAppleProps& value) noexcept {
+    return std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>>
   /**
-   * Specialized version of `std::optional<NitroVerifyPurchaseWithIapkitAppleProps>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>>`.
    */
-  using std__optional_NitroVerifyPurchaseWithIapkitAppleProps_ = std::optional<NitroVerifyPurchaseWithIapkitAppleProps>;
-  inline std::optional<NitroVerifyPurchaseWithIapkitAppleProps> create_std__optional_NitroVerifyPurchaseWithIapkitAppleProps_(const NitroVerifyPurchaseWithIapkitAppleProps& value) noexcept {
-    return std::optional<NitroVerifyPurchaseWithIapkitAppleProps>(value);
+  using std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps__ = std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>>;
+  inline std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>> create_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps__(const std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>>(value);
   }
-  inline bool has_value_std__optional_NitroVerifyPurchaseWithIapkitAppleProps_(const std::optional<NitroVerifyPurchaseWithIapkitAppleProps>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps__(const std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroVerifyPurchaseWithIapkitAppleProps get_std__optional_NitroVerifyPurchaseWithIapkitAppleProps_(const std::optional<NitroVerifyPurchaseWithIapkitAppleProps>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps> get_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitAppleProps__(const std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitAppleProps>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>`.
+   * 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__NitroVerifyPurchaseWithIapkitGoogleProps_ final {
+    std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps> variant;
+    std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps_(std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>() 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 NitroVerifyPurchaseWithIapkitGoogleProps get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps_ create_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps_(value);
+  }
+  inline std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps_ create_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps_(const NitroVerifyPurchaseWithIapkitGoogleProps& value) noexcept {
+    return std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps_(value);
   }
   
-  // pragma MARK: std::optional<NitroVerifyPurchaseWithIapkitGoogleProps>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>>
   /**
-   * Specialized version of `std::optional<NitroVerifyPurchaseWithIapkitGoogleProps>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>>`.
    */
-  using std__optional_NitroVerifyPurchaseWithIapkitGoogleProps_ = std::optional<NitroVerifyPurchaseWithIapkitGoogleProps>;
-  inline std::optional<NitroVerifyPurchaseWithIapkitGoogleProps> create_std__optional_NitroVerifyPurchaseWithIapkitGoogleProps_(const NitroVerifyPurchaseWithIapkitGoogleProps& value) noexcept {
-    return std::optional<NitroVerifyPurchaseWithIapkitGoogleProps>(value);
+  using std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps__ = std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>>;
+  inline std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>> create_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps__(const std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>>(value);
   }
-  inline bool has_value_std__optional_NitroVerifyPurchaseWithIapkitGoogleProps_(const std::optional<NitroVerifyPurchaseWithIapkitGoogleProps>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps__(const std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroVerifyPurchaseWithIapkitGoogleProps get_std__optional_NitroVerifyPurchaseWithIapkitGoogleProps_(const std::optional<NitroVerifyPurchaseWithIapkitGoogleProps>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps> get_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitGoogleProps__(const std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitGoogleProps>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>`.
+   * 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__NitroVerifyPurchaseWithIapkitProps_ final {
+    std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps> variant;
+    std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps_(std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>() 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 NitroVerifyPurchaseWithIapkitProps get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps_ create_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps_(value);
+  }
+  inline std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps_ create_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps_(const NitroVerifyPurchaseWithIapkitProps& value) noexcept {
+    return std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps_(value);
   }
   
-  // pragma MARK: std::optional<NitroVerifyPurchaseWithIapkitProps>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>>
   /**
-   * Specialized version of `std::optional<NitroVerifyPurchaseWithIapkitProps>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>>`.
    */
-  using std__optional_NitroVerifyPurchaseWithIapkitProps_ = std::optional<NitroVerifyPurchaseWithIapkitProps>;
-  inline std::optional<NitroVerifyPurchaseWithIapkitProps> create_std__optional_NitroVerifyPurchaseWithIapkitProps_(const NitroVerifyPurchaseWithIapkitProps& value) noexcept {
-    return std::optional<NitroVerifyPurchaseWithIapkitProps>(value);
+  using std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps__ = std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>>;
+  inline std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>> create_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps__(const std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>>(value);
   }
-  inline bool has_value_std__optional_NitroVerifyPurchaseWithIapkitProps_(const std::optional<NitroVerifyPurchaseWithIapkitProps>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps__(const std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroVerifyPurchaseWithIapkitProps get_std__optional_NitroVerifyPurchaseWithIapkitProps_(const std::optional<NitroVerifyPurchaseWithIapkitProps>& optional) noexcept {
-    return *optional;
+  inline std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps> get_std__optional_std__variant_nitro__NullType__NitroVerifyPurchaseWithIapkitProps__(const std::optional<std::variant<nitro::NullType, NitroVerifyPurchaseWithIapkitProps>>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::function<void(const UserChoiceBillingDetails& /* details */)>
@@ -1967,13 +3089,13 @@ namespace margelo::nitro::iap::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<NitroProduct>>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>>
-  using Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______ = Result<std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>>;
-  inline Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______ create_Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______(const std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>
+  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______(const std::shared_ptr<Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______ create_Result_std__shared_ptr_Promise_std__optional_std__variant_PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS_______(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<std::variant<PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__PurchaseAndroid__PurchaseIOS__std__vector_std__variant_PurchaseAndroid__PurchaseIOS______(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, PurchaseAndroid, PurchaseIOS, std::vector<std::variant<PurchaseAndroid, PurchaseIOS>>>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NitroPurchase>>>>
@@ -2021,22 +3143,22 @@ namespace margelo::nitro::iap::bridge::swift {
     return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::string>>>>
-  using Result_std__shared_ptr_Promise_std__optional_std__string____ = Result<std::shared_ptr<Promise<std::optional<std::string>>>>;
-  inline Result_std__shared_ptr_Promise_std__optional_std__string____ create_Result_std__shared_ptr_Promise_std__optional_std__string____(const std::shared_ptr<Promise<std::optional<std::string>>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<std::string>>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>>
+  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____(const std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__optional_std__string____ create_Result_std__shared_ptr_Promise_std__optional_std__string____(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<std::string>>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<NitroProduct>>>>
-  using Result_std__shared_ptr_Promise_std__optional_NitroProduct____ = Result<std::shared_ptr<Promise<std::optional<NitroProduct>>>>;
-  inline Result_std__shared_ptr_Promise_std__optional_NitroProduct____ create_Result_std__shared_ptr_Promise_std__optional_NitroProduct____(const std::shared_ptr<Promise<std::optional<NitroProduct>>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<NitroProduct>>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>>>
+  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroProduct____ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroProduct____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroProduct____(const std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__optional_NitroProduct____ create_Result_std__shared_ptr_Promise_std__optional_NitroProduct____(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<NitroProduct>>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroProduct____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroProduct____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<void>>>
@@ -2048,22 +3170,22 @@ namespace margelo::nitro::iap::bridge::swift {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>>
-  using Result_std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus_____ = Result<std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>>;
-  inline Result_std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus_____ create_Result_std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus_____(const std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>>>
+  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus_____ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus_____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus_____(const std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus_____ create_Result_std__shared_ptr_Promise_std__optional_std__vector_NitroSubscriptionStatus_____(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<std::vector<NitroSubscriptionStatus>>>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus_____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus_____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<NitroPurchase>>>>
-  using Result_std__shared_ptr_Promise_std__optional_NitroPurchase____ = Result<std::shared_ptr<Promise<std::optional<NitroPurchase>>>>;
-  inline Result_std__shared_ptr_Promise_std__optional_NitroPurchase____ create_Result_std__shared_ptr_Promise_std__optional_NitroPurchase____(const std::shared_ptr<Promise<std::optional<NitroPurchase>>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<NitroPurchase>>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>>>
+  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroPurchase____ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroPurchase____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroPurchase____(const std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__optional_NitroPurchase____ create_Result_std__shared_ptr_Promise_std__optional_NitroPurchase____(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<NitroPurchase>>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroPurchase____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__NitroPurchase____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>>>