react-native-acoustic-connect-beta 18.0.26 → 18.0.28

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

@@ -7,7 +7,10 @@
 
 #include "JHybridAcousticConnectRNSpec.hpp"
 
-
+// Forward declaration of `PushPermissionResult` to properly resolve imports.
+namespace margelo::nitro::acousticconnectrn { struct PushPermissionResult; }
+// Forward declaration of `PushErrorInfo` to properly resolve imports.
+namespace margelo::nitro::acousticconnectrn { struct PushErrorInfo; }
 
 #include <NitroModules/Null.hpp>
 #include <string>
@@ -15,8 +18,17 @@
 #include <optional>
 #include "JVariant_NullType_String.hpp"
 #include <NitroModules/JNull.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "PushPermissionResult.hpp"
+#include "JPushPermissionResult.hpp"
+#include "JVariant_NullType_Boolean.hpp"
 #include "JVariant_Boolean_String_Double.hpp"
 #include <unordered_map>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include "PushErrorInfo.hpp"
+#include "JPushErrorInfo.hpp"
 
 namespace margelo::nitro::acousticconnectrn {
 
@@ -189,5 +201,129 @@ namespace margelo::nitro::acousticconnectrn {
     }());
     return static_cast<bool>(__result);
   }
+  std::shared_ptr<Promise<bool>> JHybridAcousticConnectRNSpec::pushDidRegisterWithToken(const std::shared_ptr<ArrayBuffer>& deviceToken) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JArrayBuffer::javaobject> /* deviceToken */)>("pushDidRegisterWithToken");
+    auto __result = method(_javaPart, JArrayBuffer::wrap(deviceToken));
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<bool>> JHybridAcousticConnectRNSpec::pushDidFailToRegister(const PushErrorInfo& error) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPushErrorInfo> /* error */)>("pushDidFailToRegister");
+    auto __result = method(_javaPart, JPushErrorInfo::fromCpp(error));
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<bool>> JHybridAcousticConnectRNSpec::pushDidReceiveNotification(const std::unordered_map<std::string, std::variant<bool, std::string, double>>& userInfo) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JMap<jni::JString, JVariant_Boolean_String_Double>> /* userInfo */)>("pushDidReceiveNotification");
+    auto __result = method(_javaPart, [&]() -> jni::local_ref<jni::JMap<jni::JString, JVariant_Boolean_String_Double>> {
+      auto __map = jni::JHashMap<jni::JString, JVariant_Boolean_String_Double>::create(userInfo.size());
+      for (const auto& __entry : userInfo) {
+        __map->put(jni::make_jstring(__entry.first), JVariant_Boolean_String_Double::fromCpp(__entry.second));
+      }
+      return __map;
+    }());
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<bool>> JHybridAcousticConnectRNSpec::pushDidReceiveResponse(const std::string& actionIdentifier, const std::unordered_map<std::string, std::variant<bool, std::string, double>>& userInfo) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* actionIdentifier */, jni::alias_ref<jni::JMap<jni::JString, JVariant_Boolean_String_Double>> /* userInfo */)>("pushDidReceiveResponse");
+    auto __result = method(_javaPart, jni::make_jstring(actionIdentifier), [&]() -> jni::local_ref<jni::JMap<jni::JString, JVariant_Boolean_String_Double>> {
+      auto __map = jni::JHashMap<jni::JString, JVariant_Boolean_String_Double>::create(userInfo.size());
+      for (const auto& __entry : userInfo) {
+        __map->put(jni::make_jstring(__entry.first), JVariant_Boolean_String_Double::fromCpp(__entry.second));
+      }
+      return __map;
+    }());
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      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);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<PushPermissionResult>> JHybridAcousticConnectRNSpec::pushRequestPermission() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("pushRequestPermission");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<PushPermissionResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPushPermissionResult>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>> 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();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_Boolean>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::acousticconnectrn

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

@@ -78,6 +78,13 @@ namespace margelo::nitro::acousticconnectrn {
     bool logDialogDismissEvent(const std::string& dialogId, const std::string& dismissReason) override;
     bool logDialogButtonClickEvent(const std::string& dialogId, const std::string& buttonText, double buttonIndex) override;
     bool logDialogCustomEvent(const std::string& dialogId, const std::string& eventName, const std::unordered_map<std::string, std::variant<bool, std::string, double>>& values) override;
+    std::shared_ptr<Promise<bool>> pushDidRegisterWithToken(const std::shared_ptr<ArrayBuffer>& deviceToken) override;
+    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<PushPermissionResult>> pushRequestPermission() override;
+    std::shared_ptr<Promise<std::variant<nitro::NullType, bool>>> pushGetPermissionState() override;
 
   private:
     jni::global_ref<JHybridAcousticConnectRNSpec::JavaPart> _javaPart;

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

@@ -0,0 +1,66 @@
+///
+/// JPushErrorInfo.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PushErrorInfo.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::acousticconnectrn {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PushErrorInfo" and the the Kotlin data class "PushErrorInfo".
+   */
+  struct JPushErrorInfo final: public jni::JavaClass<JPushErrorInfo> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/PushErrorInfo;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PushErrorInfo by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PushErrorInfo toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCode = clazz->getField<jni::JDouble>("code");
+      jni::local_ref<jni::JDouble> code = this->getFieldValue(fieldCode);
+      static const auto fieldDomain = clazz->getField<jni::JString>("domain");
+      jni::local_ref<jni::JString> domain = this->getFieldValue(fieldDomain);
+      static const auto fieldMessage = clazz->getField<jni::JString>("message");
+      jni::local_ref<jni::JString> message = this->getFieldValue(fieldMessage);
+      return PushErrorInfo(
+        code != nullptr ? std::make_optional(code->value()) : std::nullopt,
+        domain != nullptr ? std::make_optional(domain->toStdString()) : std::nullopt,
+        message->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPushErrorInfo::javaobject> fromCpp(const PushErrorInfo& value) {
+      using JSignature = JPushErrorInfo(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.code.has_value() ? jni::JDouble::valueOf(value.code.value()) : nullptr,
+        value.domain.has_value() ? jni::make_jstring(value.domain.value()) : nullptr,
+        jni::make_jstring(value.message)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::acousticconnectrn

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

@@ -0,0 +1,66 @@
+///
+/// JPushPermissionResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PushPermissionResult.hpp"
+
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::acousticconnectrn {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PushPermissionResult" and the the Kotlin data class "PushPermissionResult".
+   */
+  struct JPushPermissionResult final: public jni::JavaClass<JPushPermissionResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/PushPermissionResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PushPermissionResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PushPermissionResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldGranted = clazz->getField<jboolean>("granted");
+      jboolean granted = this->getFieldValue(fieldGranted);
+      static const auto fieldError = clazz->getField<JVariant_NullType_String>("error");
+      jni::local_ref<JVariant_NullType_String> error = this->getFieldValue(fieldError);
+      return PushPermissionResult(
+        static_cast<bool>(granted),
+        error != nullptr ? std::make_optional(error->toCpp()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPushPermissionResult::javaobject> fromCpp(const PushPermissionResult& value) {
+      using JSignature = JPushPermissionResult(jboolean, jni::alias_ref<JVariant_NullType_String>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.granted,
+        value.error.has_value() ? JVariant_NullType_String::fromCpp(value.error.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::acousticconnectrn

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

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

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

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

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

@@ -11,6 +11,8 @@ import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.core.NullType
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -124,6 +126,34 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun logDialogCustomEvent(dialogId: String, eventName: String, values: Map<String, Variant_Boolean_String_Double>): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun pushDidRegisterWithToken(deviceToken: ArrayBuffer): Promise<Boolean>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun pushDidFailToRegister(error: PushErrorInfo): Promise<Boolean>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun pushDidReceiveNotification(userInfo: Map<String, Variant_Boolean_String_Double>): Promise<Boolean>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun pushDidReceiveResponse(actionIdentifier: String, userInfo: Map<String, Variant_Boolean_String_Double>): Promise<Boolean>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun pushDidReceiveAuthorization(granted: Variant_NullType_Boolean?, error: PushErrorInfo?): Promise<Boolean>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun pushRequestPermission(): Promise<PushPermissionResult>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun pushGetPermissionState(): Promise<Variant_NullType_Boolean>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

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

@@ -0,0 +1,61 @@
+///
+/// PushErrorInfo.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.acousticconnectrn
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "PushErrorInfo".
+ */
+@DoNotStrip
+@Keep
+data class PushErrorInfo(
+  @DoNotStrip
+  @Keep
+  val code: Double?,
+  @DoNotStrip
+  @Keep
+  val domain: String?,
+  @DoNotStrip
+  @Keep
+  val message: String
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is PushErrorInfo) return false
+    return Objects.deepEquals(this.code, other.code)
+      && Objects.deepEquals(this.domain, other.domain)
+      && Objects.deepEquals(this.message, other.message)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      code,
+      domain,
+      message
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(code: Double?, domain: String?, message: String): PushErrorInfo {
+      return PushErrorInfo(code, domain, message)
+    }
+  }
+}

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

@@ -0,0 +1,56 @@
+///
+/// PushPermissionResult.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.acousticconnectrn
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+import com.margelo.nitro.core.NullType
+
+/**
+ * Represents the JavaScript object/struct "PushPermissionResult".
+ */
+@DoNotStrip
+@Keep
+data class PushPermissionResult(
+  @DoNotStrip
+  @Keep
+  val granted: Boolean,
+  @DoNotStrip
+  @Keep
+  val error: Variant_NullType_String?
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is PushPermissionResult) return false
+    return Objects.deepEquals(this.granted, other.granted)
+      && Objects.deepEquals(this.error, other.error)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      granted,
+      error
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(granted: Boolean, error: Variant_NullType_String?): PushPermissionResult {
+      return PushPermissionResult(granted, error)
+    }
+  }
+}

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

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

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

@@ -14,6 +14,38 @@
 
 namespace margelo::nitro::acousticconnectrn::bridge::swift {
 
+  // pragma MARK: std::function<void(bool /* result */)>
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = AcousticConnectRN::Func_void_bool::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = AcousticConnectRN::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void {
+      swiftClosure.call(error);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const PushPermissionResult& /* result */)>
+  Func_void_PushPermissionResult create_Func_void_PushPermissionResult(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = AcousticConnectRN::Func_void_PushPermissionResult::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const PushPermissionResult& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // 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 {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridAcousticConnectRNSpec>
   std::shared_ptr<HybridAcousticConnectRNSpec> create_std__shared_ptr_HybridAcousticConnectRNSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     AcousticConnectRN::HybridAcousticConnectRNSpec_cxx swiftPart = AcousticConnectRN::HybridAcousticConnectRNSpec_cxx::fromUnsafe(swiftUnsafePointer);