react-native-iap 15.6.2 → 16.0.0

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

@@ -16,8 +16,6 @@ namespace margelo::nitro::iap { struct AdvancedCommerceItemDetailsIOS; }
 namespace margelo::nitro::iap { struct AdvancedCommerceItemIOS; }
 // Forward declaration of `AdvancedCommerceRefundIOS` to properly resolve imports.
 namespace margelo::nitro::iap { struct AdvancedCommerceRefundIOS; }
-// Forward declaration of `AlternativeBillingModeAndroid` to properly resolve imports.
-namespace margelo::nitro::iap { enum class AlternativeBillingModeAndroid; }
 // Forward declaration of `AndroidSubscriptionOfferInput` to properly resolve imports.
 namespace margelo::nitro::iap { struct AndroidSubscriptionOfferInput; }
 // Forward declaration of `BillingChoiceScreenTypeAndroid` to properly resolve imports.
@@ -78,10 +76,6 @@ namespace margelo::nitro::iap { struct NitroBillingProgramAvailabilityResultAndr
 namespace margelo::nitro::iap { struct NitroBillingProgramReportingDetailsAndroid; }
 // Forward declaration of `NitroBillingResultAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroBillingResultAndroid; }
-// Forward declaration of `NitroDiscountAmountAndroid` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroDiscountAmountAndroid; }
-// Forward declaration of `NitroDiscountDisplayInfoAndroid` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroDiscountDisplayInfoAndroid; }
 // Forward declaration of `NitroFinishTransactionAndroidParams` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroFinishTransactionAndroidParams; }
 // Forward declaration of `NitroFinishTransactionIosParams` to properly resolve imports.
@@ -92,40 +86,30 @@ namespace margelo::nitro::iap { struct NitroIapkitProductClientPayload; }
 namespace margelo::nitro::iap { struct NitroInAppMessageParamsAndroid; }
 // Forward declaration of `NitroInAppMessageResultAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroInAppMessageResultAndroid; }
-// Forward declaration of `NitroLimitedQuantityInfoAndroid` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroLimitedQuantityInfoAndroid; }
-// Forward declaration of `NitroOneTimePurchaseOfferDetail` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroOneTimePurchaseOfferDetail; }
-// Forward declaration of `NitroPreorderDetailsAndroid` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroPreorderDetailsAndroid; }
 // Forward declaration of `NitroProduct` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroProduct; }
 // Forward declaration of `NitroPurchaseResult` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroPurchaseResult; }
+// Forward declaration of `NitroPurchaseVerificationAppleOptions` to properly resolve imports.
+namespace margelo::nitro::iap { struct NitroPurchaseVerificationAppleOptions; }
+// Forward declaration of `NitroPurchaseVerificationGoogleOptions` to properly resolve imports.
+namespace margelo::nitro::iap { struct NitroPurchaseVerificationGoogleOptions; }
+// Forward declaration of `NitroPurchaseVerificationHorizonOptions` to properly resolve imports.
+namespace margelo::nitro::iap { struct NitroPurchaseVerificationHorizonOptions; }
+// Forward declaration of `NitroPurchaseVerificationResultAndroid` to properly resolve imports.
+namespace margelo::nitro::iap { struct NitroPurchaseVerificationResultAndroid; }
+// Forward declaration of `NitroPurchaseVerificationResultIOS` to properly resolve imports.
+namespace margelo::nitro::iap { struct NitroPurchaseVerificationResultIOS; }
 // Forward declaration of `NitroPurchase` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroPurchase; }
-// Forward declaration of `NitroReceiptValidationAppleOptions` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroReceiptValidationAppleOptions; }
-// Forward declaration of `NitroReceiptValidationGoogleOptions` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroReceiptValidationGoogleOptions; }
-// Forward declaration of `NitroReceiptValidationHorizonOptions` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroReceiptValidationHorizonOptions; }
-// Forward declaration of `NitroReceiptValidationResultAndroid` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroReceiptValidationResultAndroid; }
-// Forward declaration of `NitroReceiptValidationResultIOS` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroReceiptValidationResultIOS; }
 // Forward declaration of `NitroRenewalInfoIOS` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroRenewalInfoIOS; }
-// Forward declaration of `NitroRentalDetailsAndroid` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroRentalDetailsAndroid; }
 // Forward declaration of `NitroRequestPurchaseAndroid` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroRequestPurchaseAndroid; }
 // Forward declaration of `NitroRequestPurchaseIos` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroRequestPurchaseIos; }
 // Forward declaration of `NitroSubscriptionStatus` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroSubscriptionStatus; }
-// Forward declaration of `NitroValidTimeWindowAndroid` to properly resolve imports.
-namespace margelo::nitro::iap { struct NitroValidTimeWindowAndroid; }
 // Forward declaration of `NitroVerifyPurchaseWithIapkitAmazonProps` to properly resolve imports.
 namespace margelo::nitro::iap { struct NitroVerifyPurchaseWithIapkitAmazonProps; }
 // Forward declaration of `NitroVerifyPurchaseWithIapkitAppleProps` to properly resolve imports.
@@ -188,7 +172,6 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "AdvancedCommerceItemDetailsIOS.hpp"
 #include "AdvancedCommerceItemIOS.hpp"
 #include "AdvancedCommerceRefundIOS.hpp"
-#include "AlternativeBillingModeAndroid.hpp"
 #include "AndroidSubscriptionOfferInput.hpp"
 #include "BillingChoiceScreenTypeAndroid.hpp"
 #include "BillingProgramAndroid.hpp"
@@ -219,30 +202,23 @@ namespace NitroIap { class HybridRnIapSpec_cxx; }
 #include "NitroBillingProgramAvailabilityResultAndroid.hpp"
 #include "NitroBillingProgramReportingDetailsAndroid.hpp"
 #include "NitroBillingResultAndroid.hpp"
-#include "NitroDiscountAmountAndroid.hpp"
-#include "NitroDiscountDisplayInfoAndroid.hpp"
 #include "NitroFinishTransactionAndroidParams.hpp"
 #include "NitroFinishTransactionIosParams.hpp"
 #include "NitroIapkitProductClientPayload.hpp"
 #include "NitroInAppMessageParamsAndroid.hpp"
 #include "NitroInAppMessageResultAndroid.hpp"
-#include "NitroLimitedQuantityInfoAndroid.hpp"
-#include "NitroOneTimePurchaseOfferDetail.hpp"
-#include "NitroPreorderDetailsAndroid.hpp"
 #include "NitroProduct.hpp"
 #include "NitroPurchase.hpp"
 #include "NitroPurchaseResult.hpp"
-#include "NitroReceiptValidationAppleOptions.hpp"
-#include "NitroReceiptValidationGoogleOptions.hpp"
-#include "NitroReceiptValidationHorizonOptions.hpp"
-#include "NitroReceiptValidationResultAndroid.hpp"
-#include "NitroReceiptValidationResultIOS.hpp"
+#include "NitroPurchaseVerificationAppleOptions.hpp"
+#include "NitroPurchaseVerificationGoogleOptions.hpp"
+#include "NitroPurchaseVerificationHorizonOptions.hpp"
+#include "NitroPurchaseVerificationResultAndroid.hpp"
+#include "NitroPurchaseVerificationResultIOS.hpp"
 #include "NitroRenewalInfoIOS.hpp"
-#include "NitroRentalDetailsAndroid.hpp"
 #include "NitroRequestPurchaseAndroid.hpp"
 #include "NitroRequestPurchaseIos.hpp"
 #include "NitroSubscriptionStatus.hpp"
-#include "NitroValidTimeWindowAndroid.hpp"
 #include "NitroVerifyPurchaseWithIapkitAmazonProps.hpp"
 #include "NitroVerifyPurchaseWithIapkitAppleProps.hpp"
 #include "NitroVerifyPurchaseWithIapkitGoogleProps.hpp"
@@ -344,21 +320,6 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<AlternativeBillingModeAndroid>
-  /**
-   * Specialized version of `std::optional<AlternativeBillingModeAndroid>`.
-   */
-  using std__optional_AlternativeBillingModeAndroid_ = std::optional<AlternativeBillingModeAndroid>;
-  inline std::optional<AlternativeBillingModeAndroid> create_std__optional_AlternativeBillingModeAndroid_(const AlternativeBillingModeAndroid& value) noexcept {
-    return std::optional<AlternativeBillingModeAndroid>(value);
-  }
-  inline bool has_value_std__optional_AlternativeBillingModeAndroid_(const std::optional<AlternativeBillingModeAndroid>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline AlternativeBillingModeAndroid get_std__optional_AlternativeBillingModeAndroid_(const std::optional<AlternativeBillingModeAndroid>& optional) noexcept {
-    return optional.value();
-  }
-  
   // pragma MARK: std::optional<BillingChoiceScreenTypeAndroid>
   /**
    * Specialized version of `std::optional<BillingChoiceScreenTypeAndroid>`.
@@ -580,336 +541,6 @@ namespace margelo::nitro::iap::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::variant<nitro::NullType, 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.
-   */
-  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_std__variant_nitro__NullType__NitroDiscountAmountAndroid__(const std::optional<std::variant<nitro::NullType, NitroDiscountAmountAndroid>>& optional) noexcept {
-    return optional.has_value();
-  }
-  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::variant<nitro::NullType, 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.
-   */
-  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);
-  }
-  
-  // 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 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<std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>>
-  /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>>`.
-   */
-  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_std__variant_nitro__NullType__NitroLimitedQuantityInfoAndroid__(const std::optional<std::variant<nitro::NullType, NitroLimitedQuantityInfoAndroid>>& optional) noexcept {
-    return optional.has_value();
-  }
-  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>
-  /**
-   * Specialized version of `std::vector<std::string>`.
-   */
-  using std__vector_std__string_ = std::vector<std::string>;
-  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
-    std::vector<std::string> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
-  // 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<std::variant<nitro::NullType, NitroPreorderDetailsAndroid>>`.
-   */
-  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_std__variant_nitro__NullType__NitroPreorderDetailsAndroid__(const std::optional<std::variant<nitro::NullType, NitroPreorderDetailsAndroid>>& optional) noexcept {
-    return optional.has_value();
-  }
-  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<std::variant<nitro::NullType, NitroRentalDetailsAndroid>>
-  /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroRentalDetailsAndroid>>`.
-   */
-  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_std__variant_nitro__NullType__NitroRentalDetailsAndroid__(const std::optional<std::variant<nitro::NullType, NitroRentalDetailsAndroid>>& optional) noexcept {
-    return optional.has_value();
-  }
-  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::variant<nitro::NullType, 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.
-   */
-  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_std__variant_nitro__NullType__NitroValidTimeWindowAndroid__(const std::optional<std::variant<nitro::NullType, NitroValidTimeWindowAndroid>>& optional) noexcept {
-    return optional.has_value();
-  }
-  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>
-  /**
-   * Specialized version of `std::vector<NitroOneTimePurchaseOfferDetail>`.
-   */
-  using std__vector_NitroOneTimePurchaseOfferDetail_ = std::vector<NitroOneTimePurchaseOfferDetail>;
-  inline std::vector<NitroOneTimePurchaseOfferDetail> create_std__vector_NitroOneTimePurchaseOfferDetail_(size_t size) noexcept {
-    std::vector<NitroOneTimePurchaseOfferDetail> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
-  // 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::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>>`.
-   */
-  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__variant_nitro__NullType__std__vector_NitroOneTimePurchaseOfferDetail___(const std::optional<std::variant<nitro::NullType, std::vector<NitroOneTimePurchaseOfferDetail>>>& optional) noexcept {
-    return optional.has_value();
-  }
-  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>
   /**
    * Specialized version of `std::vector<NitroProduct>`.
@@ -955,6 +586,17 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__vector_NitroProduct__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::vector<std::string>
+  /**
+   * Specialized version of `std::vector<std::string>`.
+   */
+  using std__vector_std__string_ = std::vector<std::string>;
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
+    std::vector<std::string> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
   // pragma MARK: std::variant<nitro::NullType, std::vector<std::string>>
   /**
    * Wrapper struct for `std::variant<nitro::NullType, std::vector<std::string>>`.
@@ -2435,40 +2077,6 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_NitroProduct_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::string>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
-   */
-  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
-  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() noexcept {
-    return Promise<std::string>::create();
-  }
-  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) noexcept {
-    return PromiseHolder<std::string>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const std::string& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const std::string&)>`.
-   */
-  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__string_Wrapper final {
-  public:
-    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
-    inline void call(std::string result) const noexcept {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::string& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
-    return Func_void_std__string_Wrapper(std::move(value));
-  }
-  
   // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>
   /**
    * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>`.
@@ -2566,6 +2174,69 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__variant_nitro__NullType__NitroProduct__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::variant<nitro::NullType, 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.
+   */
+  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 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::variant<nitro::NullType, NitroPurchase>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>>`.
+   */
+  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::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::variant<nitro::NullType, NitroPurchase>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, NitroPurchase>&)>`.
+   */
+  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::variant<nitro::NullType, NitroPurchase>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__variant_nitro__NullType__NitroPurchase__Wrapper final {
+  public:
+    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::variant<nitro::NullType, NitroPurchase>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  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::shared_ptr<Promise<void>>
   /**
    * Specialized version of `std::shared_ptr<Promise<void>>`.
@@ -2674,67 +2345,38 @@ namespace margelo::nitro::iap::bridge::swift {
     return Func_void_std__variant_nitro__NullType__std__vector_NitroSubscriptionStatus___Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::variant<nitro::NullType, 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.
-   */
-  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 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::variant<nitro::NullType, NitroPurchase>>>
+  // pragma MARK: std::shared_ptr<Promise<std::string>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, NitroPurchase>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
    */
-  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();
+  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
+  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() noexcept {
+    return Promise<std::string>::create();
   }
-  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));
+  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) noexcept {
+    return PromiseHolder<std::string>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::variant<nitro::NullType, NitroPurchase>& /* result */)>
+  // pragma MARK: std::function<void(const std::string& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::variant<nitro::NullType, NitroPurchase>&)>`.
+   * Specialized version of `std::function<void(const std::string&)>`.
    */
-  using Func_void_std__variant_nitro__NullType__NitroPurchase_ = std::function<void(const std::variant<nitro::NullType, NitroPurchase>& /* result */)>;
+  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, NitroPurchase>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__variant_nitro__NullType__NitroPurchase__Wrapper final {
+  class Func_void_std__string_Wrapper final {
   public:
-    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 {
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
+    inline void call(std::string result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, NitroPurchase>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::string& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  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));
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
+    return Func_void_std__string_Wrapper(std::move(value));
   }
   
   // pragma MARK: std::optional<std::variant<nitro::NullType, NitroPurchase>>
@@ -2752,79 +2394,79 @@ namespace margelo::nitro::iap::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>
+  // pragma MARK: std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>
   /**
-   * Wrapper struct for `std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>`.
+   * Wrapper struct for `std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>`.
    * 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_ final {
-    std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid> variant;
-    std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_(std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid> variant): variant(variant) { }
-    operator std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>() const noexcept {
+  struct std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_ final {
+    std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid> variant;
+    std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_(std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid> variant): variant(variant) { }
+    operator std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
       return variant.index();
     }
-    inline NitroReceiptValidationResultIOS get_0() const noexcept {
+    inline NitroPurchaseVerificationResultIOS get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline NitroReceiptValidationResultAndroid get_1() const noexcept {
+    inline NitroPurchaseVerificationResultAndroid get_1() const noexcept {
       return std::get<1>(variant);
     }
   };
-  inline std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_ create_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_(const NitroReceiptValidationResultIOS& value) noexcept {
-    return std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_(value);
+  inline std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_ create_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_(const NitroPurchaseVerificationResultIOS& value) noexcept {
+    return std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_(value);
   }
-  inline std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_ create_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_(const NitroReceiptValidationResultAndroid& value) noexcept {
-    return std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_(value);
+  inline std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_ create_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_(const NitroPurchaseVerificationResultAndroid& value) noexcept {
+    return std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_(value);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>>
+  // pragma MARK: std::shared_ptr<Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>>`.
    */
-  using std__shared_ptr_Promise_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid___ = std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>>;
-  inline std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>> create_std__shared_ptr_Promise_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid___() noexcept {
-    return Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>::create();
+  using std__shared_ptr_Promise_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid___ = std::shared_ptr<Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>>;
+  inline std::shared_ptr<Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>> create_std__shared_ptr_Promise_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid___() noexcept {
+    return Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>::create();
   }
-  inline PromiseHolder<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>> wrap_std__shared_ptr_Promise_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid___(std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>> promise) noexcept {
-    return PromiseHolder<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>(std::move(promise));
+  inline PromiseHolder<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>> wrap_std__shared_ptr_Promise_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid___(std::shared_ptr<Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>> promise) noexcept {
+    return PromiseHolder<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>&)>`.
+   * Specialized version of `std::function<void(const std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>&)>`.
    */
-  using Func_void_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_ = std::function<void(const std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>& /* result */)>;
+  using Func_void_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_ = std::function<void(const std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid__Wrapper final {
+  class Func_void_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid__Wrapper final {
   public:
-    explicit Func_void_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid__Wrapper(std::function<void(const std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>& /* result */)>>(std::move(func))) {}
-    inline void call(std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid> result) const noexcept {
+    explicit Func_void_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid__Wrapper(std::function<void(const std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_ create_Func_void_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid__Wrapper wrap_Func_void_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_(Func_void_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid_ value) noexcept {
-    return Func_void_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid__Wrapper(std::move(value));
+  Func_void_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_ create_Func_void_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid__Wrapper wrap_Func_void_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_(Func_void_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid_ value) noexcept {
+    return Func_void_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>
+  // pragma MARK: std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>
   /**
-   * Wrapper struct for `std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>`.
+   * Wrapper struct for `std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>`.
    * 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 {
+  struct std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions_ final {
+    std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions> variant;
+    std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions_(std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
@@ -2833,42 +2475,42 @@ namespace margelo::nitro::iap::bridge::swift {
     inline nitro::NullType get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline NitroReceiptValidationAppleOptions get_1() const noexcept {
+    inline NitroPurchaseVerificationAppleOptions 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__NitroPurchaseVerificationAppleOptions_ create_std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions_(value);
   }
-  inline std__variant_nitro__NullType__NitroReceiptValidationAppleOptions_ create_std__variant_nitro__NullType__NitroReceiptValidationAppleOptions_(const NitroReceiptValidationAppleOptions& value) noexcept {
-    return std__variant_nitro__NullType__NitroReceiptValidationAppleOptions_(value);
+  inline std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions_ create_std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions_(const NitroPurchaseVerificationAppleOptions& value) noexcept {
+    return std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions_(value);
   }
   
-  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>>
   /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>>`.
    */
-  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);
+  using std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions__ = std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>>;
+  inline std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>> create_std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions__(const std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>>(value);
   }
-  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroReceiptValidationAppleOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions__(const std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::variant<nitro::NullType, NitroReceiptValidationAppleOptions> get_std__optional_std__variant_nitro__NullType__NitroReceiptValidationAppleOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationAppleOptions>>& optional) noexcept {
+  inline std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions> get_std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationAppleOptions__(const std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationAppleOptions>>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>
+  // pragma MARK: std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>
   /**
-   * Wrapper struct for `std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>`.
+   * Wrapper struct for `std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>`.
    * 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 {
+  struct std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions_ final {
+    std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions> variant;
+    std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions_(std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
@@ -2877,42 +2519,42 @@ namespace margelo::nitro::iap::bridge::swift {
     inline nitro::NullType get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline NitroReceiptValidationGoogleOptions get_1() const noexcept {
+    inline NitroPurchaseVerificationGoogleOptions 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__NitroPurchaseVerificationGoogleOptions_ create_std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions_(value);
   }
-  inline std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions_ create_std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions_(const NitroReceiptValidationGoogleOptions& value) noexcept {
-    return std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions_(value);
+  inline std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions_ create_std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions_(const NitroPurchaseVerificationGoogleOptions& value) noexcept {
+    return std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions_(value);
   }
   
-  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>>
   /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>>`.
    */
-  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);
+  using std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions__ = std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>>;
+  inline std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>> create_std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions__(const std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>>(value);
   }
-  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions__(const std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions> get_std__optional_std__variant_nitro__NullType__NitroReceiptValidationGoogleOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationGoogleOptions>>& optional) noexcept {
+  inline std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions> get_std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationGoogleOptions__(const std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationGoogleOptions>>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>
+  // pragma MARK: std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>
   /**
-   * Wrapper struct for `std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>`.
+   * Wrapper struct for `std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>`.
    * 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 {
+  struct std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions_ final {
+    std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions> variant;
+    std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions_(std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
@@ -2921,29 +2563,29 @@ namespace margelo::nitro::iap::bridge::swift {
     inline nitro::NullType get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline NitroReceiptValidationHorizonOptions get_1() const noexcept {
+    inline NitroPurchaseVerificationHorizonOptions 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__NitroPurchaseVerificationHorizonOptions_ create_std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions_(value);
   }
-  inline std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions_ create_std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions_(const NitroReceiptValidationHorizonOptions& value) noexcept {
-    return std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions_(value);
+  inline std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions_ create_std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions_(const NitroPurchaseVerificationHorizonOptions& value) noexcept {
+    return std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions_(value);
   }
   
-  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>>
   /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>>`.
    */
-  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);
+  using std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions__ = std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>>;
+  inline std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>> create_std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions__(const std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>>(value);
   }
-  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions__(const std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions> get_std__optional_std__variant_nitro__NullType__NitroReceiptValidationHorizonOptions__(const std::optional<std::variant<nitro::NullType, NitroReceiptValidationHorizonOptions>>& optional) noexcept {
+  inline std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions> get_std__optional_std__variant_nitro__NullType__NitroPurchaseVerificationHorizonOptions__(const std::optional<std::variant<nitro::NullType, NitroPurchaseVerificationHorizonOptions>>& optional) noexcept {
     return optional.value();
   }
   
@@ -3903,15 +3545,6 @@ namespace margelo::nitro::iap::bridge::swift {
     return Result<void>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
-  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
-  }
-  
   // 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 {
@@ -3930,6 +3563,15 @@ namespace margelo::nitro::iap::bridge::swift {
     return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, NitroProduct>>>>::withError(error);
   }
   
+  // 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__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<void>>>
   using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
   inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
@@ -3948,22 +3590,22 @@ namespace margelo::nitro::iap::bridge::swift {
     return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::vector<NitroSubscriptionStatus>>>>>::withError(error);
   }
   
-  // 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);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
+  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
   }
-  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);
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>>>
-  using Result_std__shared_ptr_Promise_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid____ = Result<std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>>>;
-  inline Result_std__shared_ptr_Promise_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid____ create_Result_std__shared_ptr_Promise_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid____(const std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>>>
+  using Result_std__shared_ptr_Promise_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid____ = Result<std::shared_ptr<Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid____ create_Result_std__shared_ptr_Promise_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid____(const std::shared_ptr<Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid____ create_Result_std__shared_ptr_Promise_std__variant_NitroReceiptValidationResultIOS__NitroReceiptValidationResultAndroid____(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::variant<NitroReceiptValidationResultIOS, NitroReceiptValidationResultAndroid>>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid____ create_Result_std__shared_ptr_Promise_std__variant_NitroPurchaseVerificationResultIOS__NitroPurchaseVerificationResultAndroid____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<NitroPurchaseVerificationResultIOS, NitroPurchaseVerificationResultAndroid>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<NitroVerifyPurchaseWithProviderResult>>>