react-native-acoustic-connect-beta 19.0.36 → 19.1.1

package/nitrogen/generated/android/c++/JHybridAcousticConnectRNSpec.cpp

@@ -22,7 +22,7 @@ namespace margelo::nitro::acousticconnectrn { struct PushErrorInfo; }
 #include <NitroModules/JPromise.hpp>
 #include "PushPermissionResult.hpp"
 #include "JPushPermissionResult.hpp"
-#include "JVariant_NullType_Boolean.hpp"
+#include "JVariant_Boolean_NullType.hpp"
 #include "JVariant_Boolean_String_Double.hpp"
 #include <unordered_map>
 #include <NitroModules/AnyMap.hpp>
@@ -295,9 +295,9 @@ namespace margelo::nitro::acousticconnectrn {
       return __promise;
     }();
   }
-  std::shared_ptr<Promise<bool>> JHybridAcousticConnectRNSpec::pushDidReceiveAuthorization(const std::optional<std::variant<nitro::NullType, bool>>& granted, const std::optional<PushErrorInfo>& error) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JVariant_NullType_Boolean> /* granted */, jni::alias_ref<JPushErrorInfo> /* error */)>("pushDidReceiveAuthorization");
-    auto __result = method(_javaPart, granted.has_value() ? JVariant_NullType_Boolean::fromCpp(granted.value()) : nullptr, error.has_value() ? JPushErrorInfo::fromCpp(error.value()) : nullptr);
+  std::shared_ptr<Promise<bool>> JHybridAcousticConnectRNSpec::pushDidReceiveAuthorization(const std::optional<std::variant<bool, nitro::NullType>>& granted, const std::optional<PushErrorInfo>& error) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JVariant_Boolean_NullType> /* granted */, jni::alias_ref<JPushErrorInfo> /* error */)>("pushDidReceiveAuthorization");
+    auto __result = method(_javaPart, granted.has_value() ? JVariant_Boolean_NullType::fromCpp(granted.value()) : nullptr, error.has_value() ? JPushErrorInfo::fromCpp(error.value()) : nullptr);
     return [&]() {
       auto __promise = Promise<bool>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
@@ -327,13 +327,13 @@ namespace margelo::nitro::acousticconnectrn {
       return __promise;
     }();
   }
-  std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>> JHybridAcousticConnectRNSpec::pushGetPermissionState() {
+  std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>> JHybridAcousticConnectRNSpec::pushGetPermissionState() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("pushGetPermissionState");
     auto __result = method(_javaPart);
     return [&]() {
-      auto __promise = Promise<std::variant<nitro::NullType, bool>>::create();
+      auto __promise = Promise<std::variant<bool, nitro::NullType>>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
-        auto __result = jni::static_ref_cast<JVariant_NullType_Boolean>(__boxedResult);
+        auto __result = jni::static_ref_cast<JVariant_Boolean_NullType>(__boxedResult);
         __promise->resolve(__result->toCpp());
       });
       __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {

package/nitrogen/generated/android/c++/JHybridAcousticConnectRNSpec.hpp

@@ -83,9 +83,9 @@ namespace margelo::nitro::acousticconnectrn {
     std::shared_ptr<Promise<bool>> pushDidFailToRegister(const PushErrorInfo& error) override;
     std::shared_ptr<Promise<bool>> pushDidReceiveNotification(const std::unordered_map<std::string, std::variant<bool, std::string, double>>& userInfo) override;
     std::shared_ptr<Promise<bool>> pushDidReceiveResponse(const std::string& actionIdentifier, const std::unordered_map<std::string, std::variant<bool, std::string, double>>& userInfo) override;
-    std::shared_ptr<Promise<bool>> pushDidReceiveAuthorization(const std::optional<std::variant<nitro::NullType, bool>>& granted, const std::optional<PushErrorInfo>& error) override;
+    std::shared_ptr<Promise<bool>> pushDidReceiveAuthorization(const std::optional<std::variant<bool, nitro::NullType>>& granted, const std::optional<PushErrorInfo>& error) override;
     std::shared_ptr<Promise<PushPermissionResult>> pushRequestPermission() override;
-    std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>> pushGetPermissionState() override;
+    std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>> pushGetPermissionState() override;
 
   private:
     jni::global_ref<JHybridAcousticConnectRNSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/c++/JPushErrorInfo.hpp

@@ -18,7 +18,7 @@ namespace margelo::nitro::acousticconnectrn {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "PushErrorInfo" and the the Kotlin data class "PushErrorInfo".
+   * The C++ JNI bridge between the C++ struct "PushErrorInfo" and the Kotlin data class "PushErrorInfo".
    */
   struct JPushErrorInfo final: public jni::JavaClass<JPushErrorInfo> {
   public:

package/nitrogen/generated/android/c++/JPushPermissionResult.hpp

@@ -22,7 +22,7 @@ namespace margelo::nitro::acousticconnectrn {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "PushPermissionResult" and the the Kotlin data class "PushPermissionResult".
+   * The C++ JNI bridge between the C++ struct "PushPermissionResult" and the Kotlin data class "PushPermissionResult".
    */
   struct JPushPermissionResult final: public jni::JavaClass<JPushPermissionResult> {
   public:

package/nitrogen/generated/android/c++/JVariant_Boolean_NullType.cpp

@@ -0,0 +1,26 @@
+///
+/// JVariant_Boolean_NullType.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JVariant_Boolean_NullType.hpp"
+
+namespace margelo::nitro::acousticconnectrn {
+  /**
+   * Converts JVariant_Boolean_NullType to std::variant<bool, nitro::NullType>
+   */
+  std::variant<bool, nitro::NullType> JVariant_Boolean_NullType::toCpp() const {
+    if (isInstanceOf(JVariant_Boolean_NullType_impl::First::javaClassStatic())) {
+      // It's a `bool`
+      auto jniValue = static_cast<const JVariant_Boolean_NullType_impl::First*>(this)->getValue();
+      return static_cast<bool>(jniValue);
+    } else if (isInstanceOf(JVariant_Boolean_NullType_impl::Second::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_Boolean_NullType_impl::Second*>(this)->getValue();
+      return nitro::null;
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::acousticconnectrn

package/nitrogen/generated/android/c++/{JVariant_NullType_Boolean.hpp → JVariant_Boolean_NullType.hpp}

@@ -1,5 +1,5 @@
 ///
-/// JVariant_NullType_Boolean.hpp
+/// JVariant_Boolean_NullType.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -19,51 +19,51 @@ namespace margelo::nitro::acousticconnectrn {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Boolean".
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_Boolean_NullType".
    */
-  class JVariant_NullType_Boolean: public jni::JavaClass<JVariant_NullType_Boolean> {
+  class JVariant_Boolean_NullType: public jni::JavaClass<JVariant_Boolean_NullType> {
   public:
-    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/Variant_NullType_Boolean;";
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/Variant_Boolean_NullType;";
 
-    static jni::local_ref<JVariant_NullType_Boolean> create_0(jni::alias_ref<JNull> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Boolean(jni::alias_ref<JNull>)>("create");
+    static jni::local_ref<JVariant_Boolean_NullType> create_0(jboolean value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_NullType(jboolean)>("create");
       return method(javaClassStatic(), value);
     }
-    static jni::local_ref<JVariant_NullType_Boolean> create_1(jboolean value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Boolean(jboolean)>("create");
+    static jni::local_ref<JVariant_Boolean_NullType> create_1(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_NullType(jni::alias_ref<JNull>)>("create");
       return method(javaClassStatic(), value);
     }
 
-    static jni::local_ref<JVariant_NullType_Boolean> fromCpp(const std::variant<nitro::NullType, bool>& variant) {
+    static jni::local_ref<JVariant_Boolean_NullType> fromCpp(const std::variant<bool, nitro::NullType>& variant) {
       switch (variant.index()) {
-        case 0: return create_0(JNull::null());
-        case 1: return create_1(std::get<1>(variant));
+        case 0: return create_0(std::get<0>(variant));
+        case 1: return create_1(JNull::null());
         default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
       }
     }
 
-    [[nodiscard]] std::variant<nitro::NullType, bool> toCpp() const;
+    [[nodiscard]] std::variant<bool, nitro::NullType> toCpp() const;
   };
 
-  namespace JVariant_NullType_Boolean_impl {
-    class First final: public jni::JavaClass<First, JVariant_NullType_Boolean> {
+  namespace JVariant_Boolean_NullType_impl {
+    class First final: public jni::JavaClass<First, JVariant_Boolean_NullType> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/Variant_NullType_Boolean$First;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/Variant_Boolean_NullType$First;";
     
-      [[nodiscard]] jni::local_ref<JNull> getValue() const {
-        static const auto field = javaClassStatic()->getField<JNull>("value");
+      [[nodiscard]] jboolean getValue() const {
+        static const auto field = javaClassStatic()->getField<jboolean>("value");
         return getFieldValue(field);
       }
     };
     
-    class Second final: public jni::JavaClass<Second, JVariant_NullType_Boolean> {
+    class Second final: public jni::JavaClass<Second, JVariant_Boolean_NullType> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/Variant_NullType_Boolean$Second;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/Variant_Boolean_NullType$Second;";
     
-      [[nodiscard]] jboolean getValue() const {
-        static const auto field = javaClassStatic()->getField<jboolean>("value");
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
         return getFieldValue(field);
       }
     };
-  } // namespace JVariant_NullType_Boolean_impl
+  } // namespace JVariant_Boolean_NullType_impl
 } // namespace margelo::nitro::acousticconnectrn

package/nitrogen/generated/android/kotlin/com/margelo/nitro/acousticconnectrn/HybridAcousticConnectRNSpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.acousticconnectrn
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.core.AnyMap
 import com.margelo.nitro.core.Promise
@@ -150,7 +151,7 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun pushDidReceiveAuthorization(granted: Variant_NullType_Boolean?, error: PushErrorInfo?): Promise<Boolean>
+  abstract fun pushDidReceiveAuthorization(granted: Variant_Boolean_NullType?, error: PushErrorInfo?): Promise<Boolean>
   
   @DoNotStrip
   @Keep
@@ -158,7 +159,7 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun pushGetPermissionState(): Promise<Variant_NullType_Boolean>
+  abstract fun pushGetPermissionState(): Promise<Variant_Boolean_NullType>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {
@@ -170,6 +171,7 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   @Keep
   protected open class CxxPart(javaPart: HybridAcousticConnectRNSpec): HybridObject.CxxPart(javaPart) {
     // C++ JHybridAcousticConnectRNSpec::CxxPart::initHybrid(...)
+    @FastNative
     external override fun initHybrid(): HybridData
   }
   override fun createCxxPart(): CxxPart {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/acousticconnectrn/{Variant_NullType_Boolean.kt → Variant_Boolean_NullType.kt}

@@ -1,5 +1,5 @@
 ///
-/// Variant_NullType_Boolean.kt
+/// Variant_Boolean_NullType.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -11,15 +11,15 @@ import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.core.NullType
 
 /**
- * Represents the TypeScript variant "NullType | Boolean".
+ * Represents the TypeScript variant "Boolean | NullType".
  */
 @Suppress("ClassName")
 @DoNotStrip
-sealed class Variant_NullType_Boolean {
+sealed class Variant_Boolean_NullType {
   @DoNotStrip
-  data class First(@DoNotStrip val value: NullType): Variant_NullType_Boolean()
+  data class First(@DoNotStrip val value: Boolean): Variant_Boolean_NullType()
   @DoNotStrip
-  data class Second(@DoNotStrip val value: Boolean): Variant_NullType_Boolean()
+  data class Second(@DoNotStrip val value: NullType): Variant_Boolean_NullType()
 
   inline fun <reified T> asType(): T? {
     return when (this) {
@@ -30,7 +30,7 @@ sealed class Variant_NullType_Boolean {
   inline fun <reified T> isType(): Boolean {
     return asType<T>() != null
   }
-  inline fun <R> match(first: (NullType) -> R, second: (Boolean) -> R): R {
+  inline fun <R> match(first: (Boolean) -> R, second: (NullType) -> R): R {
     return when (this) {
       is First -> first(value)
       is Second -> second(value)
@@ -42,11 +42,11 @@ sealed class Variant_NullType_Boolean {
   val isSecond: Boolean
     get() = this is Second
 
-  fun asFirstOrNull(): NullType? {
+  fun asFirstOrNull(): Boolean? {
     val value = (this as? First)?.value ?: return null
     return value
   }
-  fun asSecondOrNull(): Boolean? {
+  fun asSecondOrNull(): NullType? {
     val value = (this as? Second)?.value ?: return null
     return value
   }
@@ -54,9 +54,9 @@ sealed class Variant_NullType_Boolean {
   companion object {
     @JvmStatic
     @DoNotStrip
-    fun create(value: NullType): Variant_NullType_Boolean = First(value)
+    fun create(value: Boolean): Variant_Boolean_NullType = First(value)
     @JvmStatic
     @DoNotStrip
-    fun create(value: Boolean): Variant_NullType_Boolean = Second(value)
+    fun create(value: NullType): Variant_Boolean_NullType = Second(value)
   }
 }

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

@@ -38,10 +38,10 @@ namespace margelo::nitro::acousticconnectrn::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(const std::variant<nitro::NullType, bool>& /* result */)>
-  Func_void_std__variant_nitro__NullType__bool_ create_Func_void_std__variant_nitro__NullType__bool_(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = AcousticConnectRN::Func_void_std__variant_nitro__NullType__bool_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::variant<nitro::NullType, bool>& result) mutable -> void {
+  // pragma MARK: std::function<void(const std::variant<bool, nitro::NullType>& /* result */)>
+  Func_void_std__variant_bool__nitro__NullType_ create_Func_void_std__variant_bool__nitro__NullType_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = AcousticConnectRN::Func_void_std__variant_bool__nitro__NullType_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::variant<bool, nitro::NullType>& result) mutable -> void {
       swiftClosure.call(result);
     };
   }

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

@@ -271,47 +271,47 @@ namespace margelo::nitro::acousticconnectrn::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::variant<nitro::NullType, bool>
+  // pragma MARK: std::variant<bool, nitro::NullType>
   /**
-   * Wrapper struct for `std::variant<nitro::NullType, bool>`.
+   * Wrapper struct for `std::variant<bool, nitro::NullType>`.
    * 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 {
+  struct std__variant_bool__nitro__NullType_ final {
+    std::variant<bool, nitro::NullType> variant;
+    std__variant_bool__nitro__NullType_(std::variant<bool, nitro::NullType> variant): variant(variant) { }
+    operator std::variant<bool, nitro::NullType>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
       return variant.index();
     }
-    inline nitro::NullType get_0() const noexcept {
+    inline bool get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline bool get_1() const noexcept {
+    inline nitro::NullType 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_bool__nitro__NullType_ create_std__variant_bool__nitro__NullType_(bool value) noexcept {
+    return std__variant_bool__nitro__NullType_(value);
   }
-  inline std__variant_nitro__NullType__bool_ create_std__variant_nitro__NullType__bool_(bool value) noexcept {
-    return std__variant_nitro__NullType__bool_(value);
+  inline std__variant_bool__nitro__NullType_ create_std__variant_bool__nitro__NullType_(nitro::NullType value) noexcept {
+    return std__variant_bool__nitro__NullType_(value);
   }
   
-  // pragma MARK: std::optional<std::variant<nitro::NullType, bool>>
+  // pragma MARK: std::optional<std::variant<bool, nitro::NullType>>
   /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, bool>>`.
+   * Specialized version of `std::optional<std::variant<bool, nitro::NullType>>`.
    */
-  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);
+  using std__optional_std__variant_bool__nitro__NullType__ = std::optional<std::variant<bool, nitro::NullType>>;
+  inline std::optional<std::variant<bool, nitro::NullType>> create_std__optional_std__variant_bool__nitro__NullType__(const std::variant<bool, nitro::NullType>& value) noexcept {
+    return std::optional<std::variant<bool, nitro::NullType>>(value);
   }
-  inline bool has_value_std__optional_std__variant_nitro__NullType__bool__(const std::optional<std::variant<nitro::NullType, bool>>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_bool__nitro__NullType__(const std::optional<std::variant<bool, nitro::NullType>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::variant<nitro::NullType, bool> get_std__optional_std__variant_nitro__NullType__bool__(const std::optional<std::variant<nitro::NullType, bool>>& optional) noexcept {
+  inline std::variant<bool, nitro::NullType> get_std__optional_std__variant_bool__nitro__NullType__(const std::optional<std::variant<bool, nitro::NullType>>& optional) noexcept {
     return optional.value();
   }
   
@@ -364,38 +364,38 @@ namespace margelo::nitro::acousticconnectrn::bridge::swift {
     return Func_void_PushPermissionResult_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>>
+  // pragma MARK: std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>>`.
    */
-  using std__shared_ptr_Promise_std__variant_nitro__NullType__bool___ = std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>>;
-  inline std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__bool___() noexcept {
-    return Promise<std::variant<nitro::NullType, bool>>::create();
+  using std__shared_ptr_Promise_std__variant_bool__nitro__NullType___ = std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>>;
+  inline std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>> create_std__shared_ptr_Promise_std__variant_bool__nitro__NullType___() noexcept {
+    return Promise<std::variant<bool, nitro::NullType>>::create();
   }
-  inline PromiseHolder<std::variant<nitro::NullType, bool>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__bool___(std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>> promise) noexcept {
-    return PromiseHolder<std::variant<nitro::NullType, bool>>(std::move(promise));
+  inline PromiseHolder<std::variant<bool, nitro::NullType>> wrap_std__shared_ptr_Promise_std__variant_bool__nitro__NullType___(std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>> promise) noexcept {
+    return PromiseHolder<std::variant<bool, nitro::NullType>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::variant<nitro::NullType, bool>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<bool, nitro::NullType>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::variant<nitro::NullType, bool>&)>`.
+   * Specialized version of `std::function<void(const std::variant<bool, nitro::NullType>&)>`.
    */
-  using Func_void_std__variant_nitro__NullType__bool_ = std::function<void(const std::variant<nitro::NullType, bool>& /* result */)>;
+  using Func_void_std__variant_bool__nitro__NullType_ = std::function<void(const std::variant<bool, nitro::NullType>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, bool>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<bool, nitro::NullType>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__variant_nitro__NullType__bool__Wrapper final {
+  class Func_void_std__variant_bool__nitro__NullType__Wrapper final {
   public:
-    explicit Func_void_std__variant_nitro__NullType__bool__Wrapper(std::function<void(const std::variant<nitro::NullType, bool>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, bool>& /* result */)>>(std::move(func))) {}
-    inline void call(std::variant<nitro::NullType, bool> result) const noexcept {
+    explicit Func_void_std__variant_bool__nitro__NullType__Wrapper(std::function<void(const std::variant<bool, nitro::NullType>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<bool, nitro::NullType>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<bool, nitro::NullType> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, bool>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::variant<bool, nitro::NullType>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__variant_nitro__NullType__bool_ create_Func_void_std__variant_nitro__NullType__bool_(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__variant_nitro__NullType__bool__Wrapper wrap_Func_void_std__variant_nitro__NullType__bool_(Func_void_std__variant_nitro__NullType__bool_ value) noexcept {
-    return Func_void_std__variant_nitro__NullType__bool__Wrapper(std::move(value));
+  Func_void_std__variant_bool__nitro__NullType_ create_Func_void_std__variant_bool__nitro__NullType_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_bool__nitro__NullType__Wrapper wrap_Func_void_std__variant_bool__nitro__NullType_(Func_void_std__variant_bool__nitro__NullType_ value) noexcept {
+    return Func_void_std__variant_bool__nitro__NullType__Wrapper(std::move(value));
   }
   
   // pragma MARK: std::shared_ptr<HybridAcousticConnectRNSpec>
@@ -455,13 +455,13 @@ namespace margelo::nitro::acousticconnectrn::bridge::swift {
     return Result<std::shared_ptr<Promise<PushPermissionResult>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>>>
-  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__bool____ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>>>;
-  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__bool____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__bool____(const std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>>>
+  using Result_std__shared_ptr_Promise_std__variant_bool__nitro__NullType____ = Result<std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_bool__nitro__NullType____ create_Result_std__shared_ptr_Promise_std__variant_bool__nitro__NullType____(const std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__bool____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__bool____(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__variant_bool__nitro__NullType____ create_Result_std__shared_ptr_Promise_std__variant_bool__nitro__NullType____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>>>::withError(error);
   }
 
 } // namespace margelo::nitro::acousticconnectrn::bridge::swift

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

@@ -313,7 +313,7 @@ namespace margelo::nitro::acousticconnectrn {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<bool>> pushDidReceiveAuthorization(const std::optional<std::variant<nitro::NullType, bool>>& granted, const std::optional<PushErrorInfo>& error) override {
+    inline std::shared_ptr<Promise<bool>> pushDidReceiveAuthorization(const std::optional<std::variant<bool, nitro::NullType>>& granted, const std::optional<PushErrorInfo>& error) override {
       auto __result = _swiftPart.pushDidReceiveAuthorization(granted, error);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -329,7 +329,7 @@ namespace margelo::nitro::acousticconnectrn {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>> pushGetPermissionState() override {
+    inline std::shared_ptr<Promise<std::variant<bool, nitro::NullType>>> pushGetPermissionState() override {
       auto __result = _swiftPart.pushGetPermissionState();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/{Func_void_std__variant_nitro__NullType__bool_.swift → Func_void_std__variant_bool__nitro__NullType_.swift}

@@ -1,5 +1,5 @@
 ///
-/// Func_void_std__variant_nitro__NullType__bool_.swift
+/// Func_void_std__variant_bool__nitro__NullType_.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -8,29 +8,29 @@
 import NitroModules
 
 /**
- * Wraps a Swift `(_ value: Variant_NullType_Bool) -> Void` as a class.
+ * Wraps a Swift `(_ value: Variant_Bool_NullType) -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
  */
-public final class Func_void_std__variant_nitro__NullType__bool_ {
+public final class Func_void_std__variant_bool__nitro__NullType_ {
   public typealias bridge = margelo.nitro.acousticconnectrn.bridge.swift
 
-  private let closure: (_ value: Variant_NullType_Bool) -> Void
+  private let closure: (_ value: Variant_Bool_NullType) -> Void
 
-  public init(_ closure: @escaping (_ value: Variant_NullType_Bool) -> Void) {
+  public init(_ closure: @escaping (_ value: Variant_Bool_NullType) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(value: bridge.std__variant_nitro__NullType__bool_) -> Void {
-    self.closure({ () -> Variant_NullType_Bool in
+  public func call(value: bridge.std__variant_bool__nitro__NullType_) -> Void {
+    self.closure({ () -> Variant_Bool_NullType in
       let __variant = value
       switch __variant.index() {
         case 0:
           let __actual = __variant.get_0()
-          return .first(NullType.null)
+          return .first(__actual)
         case 1:
           let __actual = __variant.get_1()
-          return .second(__actual)
+          return .second(NullType.null)
         default:
           fatalError("Variant can never have index \(__variant.index())!")
       }
@@ -47,12 +47,12 @@ public final class Func_void_std__variant_nitro__NullType__bool_ {
   }
 
   /**
-   * Casts an unsafe pointer to a `Func_void_std__variant_nitro__NullType__bool_`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__variant_nitro__NullType__bool_>`.
+   * Casts an unsafe pointer to a `Func_void_std__variant_bool__nitro__NullType_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__variant_bool__nitro__NullType_>`.
    * This removes one strong reference from the object!
    */
   @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__variant_nitro__NullType__bool_ {
-    return Unmanaged<Func_void_std__variant_nitro__NullType__bool_>.fromOpaque(pointer).takeRetainedValue()
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__variant_bool__nitro__NullType_ {
+    return Unmanaged<Func_void_std__variant_bool__nitro__NullType_>.fromOpaque(pointer).takeRetainedValue()
   }
 }

package/nitrogen/generated/ios/swift/HybridAcousticConnectRNSpec.swift

@@ -42,9 +42,9 @@ public protocol HybridAcousticConnectRNSpec_protocol: HybridObject {
   func pushDidFailToRegister(error: PushErrorInfo) throws -> Promise<Bool>
   func pushDidReceiveNotification(userInfo: Dictionary<String, Variant_Bool_String_Double>) throws -> Promise<Bool>
   func pushDidReceiveResponse(actionIdentifier: String, userInfo: Dictionary<String, Variant_Bool_String_Double>) throws -> Promise<Bool>
-  func pushDidReceiveAuthorization(granted: Variant_NullType_Bool?, error: PushErrorInfo?) throws -> Promise<Bool>
+  func pushDidReceiveAuthorization(granted: Variant_Bool_NullType?, error: PushErrorInfo?) throws -> Promise<Bool>
   func pushRequestPermission() throws -> Promise<PushPermissionResult>
-  func pushGetPermissionState() throws -> Promise<Variant_NullType_Bool>
+  func pushGetPermissionState() throws -> Promise<Variant_Bool_NullType>
 }
 
 public extension HybridAcousticConnectRNSpec_protocol {

package/nitrogen/generated/ios/swift/HybridAcousticConnectRNSpec_cxx.swift

@@ -745,20 +745,20 @@ open class HybridAcousticConnectRNSpec_cxx {
   }
   
   @inline(__always)
-  public final func pushDidReceiveAuthorization(granted: bridge.std__optional_std__variant_nitro__NullType__bool__, error: bridge.std__optional_PushErrorInfo_) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+  public final func pushDidReceiveAuthorization(granted: bridge.std__optional_std__variant_bool__nitro__NullType__, error: bridge.std__optional_PushErrorInfo_) -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {
-      let __result = try self.__implementation.pushDidReceiveAuthorization(granted: { () -> Variant_NullType_Bool? in
-        if bridge.has_value_std__optional_std__variant_nitro__NullType__bool__(granted) {
-          let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__bool__(granted)
-          return { () -> Variant_NullType_Bool in
-            let __variant = bridge.std__variant_nitro__NullType__bool_(__unwrapped)
+      let __result = try self.__implementation.pushDidReceiveAuthorization(granted: { () -> Variant_Bool_NullType? in
+        if bridge.has_value_std__optional_std__variant_bool__nitro__NullType__(granted) {
+          let __unwrapped = bridge.get_std__optional_std__variant_bool__nitro__NullType__(granted)
+          return { () -> Variant_Bool_NullType in
+            let __variant = bridge.std__variant_bool__nitro__NullType_(__unwrapped)
             switch __variant.index() {
               case 0:
                 let __actual = __variant.get_0()
-                return .first(NullType.null)
+                return .first(__actual)
               case 1:
                 let __actual = __variant.get_1()
-                return .second(__actual)
+                return .second(NullType.null)
               default:
                 fatalError("Variant can never have index \(__variant.index())!")
             }
@@ -802,28 +802,28 @@ open class HybridAcousticConnectRNSpec_cxx {
   }
   
   @inline(__always)
-  public final func pushGetPermissionState() -> bridge.Result_std__shared_ptr_Promise_std__variant_nitro__NullType__bool____ {
+  public final func pushGetPermissionState() -> bridge.Result_std__shared_ptr_Promise_std__variant_bool__nitro__NullType____ {
     do {
       let __result = try self.__implementation.pushGetPermissionState()
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__variant_nitro__NullType__bool___ in
-        let __promise = bridge.create_std__shared_ptr_Promise_std__variant_nitro__NullType__bool___()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__bool___(__promise)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__variant_bool__nitro__NullType___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__variant_bool__nitro__NullType___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__variant_bool__nitro__NullType___(__promise)
         __result
-          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__variant_nitro__NullType__bool_ in
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__variant_bool__nitro__NullType_ in
               switch __result {
                 case .first(let __value):
-                  return bridge.create_std__variant_nitro__NullType__bool_(margelo.nitro.NullType.null)
+                  return bridge.create_std__variant_bool__nitro__NullType_(__value)
                 case .second(let __value):
-                  return bridge.create_std__variant_nitro__NullType__bool_(__value)
+                  return bridge.create_std__variant_bool__nitro__NullType_(margelo.nitro.NullType.null)
               }
             }().variant) })
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__bool____(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_std__variant_bool__nitro__NullType____(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__bool____(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_std__variant_bool__nitro__NullType____(__exceptionPtr)
     }
   }
 }