react-native-push-signal 0.1.0 → 0.1.2

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pushsignal/AndroidFirebaseConfig.kt

@@ -20,34 +20,34 @@ import java.util.Objects
 data class AndroidFirebaseConfig(
   @DoNotStrip
   @Keep
-  val projectId: String?,
+  val project_id: String?,
   @DoNotStrip
   @Keep
-  val applicationId: String?,
+  val mobilesdk_app_id: String?,
   @DoNotStrip
   @Keep
-  val apiKey: String?,
+  val current_key: String?,
   @DoNotStrip
   @Keep
-  val gcmSenderId: String?
+  val project_number: String?
 ) {
   /* primary constructor */
 
   override fun equals(other: Any?): Boolean {
     if (this === other) return true
     if (other !is AndroidFirebaseConfig) return false
-    return Objects.deepEquals(this.projectId, other.projectId)
-      && Objects.deepEquals(this.applicationId, other.applicationId)
-      && Objects.deepEquals(this.apiKey, other.apiKey)
-      && Objects.deepEquals(this.gcmSenderId, other.gcmSenderId)
+    return Objects.deepEquals(this.project_id, other.project_id)
+      && Objects.deepEquals(this.mobilesdk_app_id, other.mobilesdk_app_id)
+      && Objects.deepEquals(this.current_key, other.current_key)
+      && Objects.deepEquals(this.project_number, other.project_number)
   }
 
   override fun hashCode(): Int {
     return arrayOf<Any?>(
-      projectId,
-      applicationId,
-      apiKey,
-      gcmSenderId
+      project_id,
+      mobilesdk_app_id,
+      current_key,
+      project_number
     ).contentDeepHashCode()
   }
 
@@ -59,8 +59,8 @@ data class AndroidFirebaseConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(projectId: String?, applicationId: String?, apiKey: String?, gcmSenderId: String?): AndroidFirebaseConfig {
-      return AndroidFirebaseConfig(projectId, applicationId, apiKey, gcmSenderId)
+    private fun fromCpp(project_id: String?, mobilesdk_app_id: String?, current_key: String?, project_number: String?): AndroidFirebaseConfig {
+      return AndroidFirebaseConfig(project_id, mobilesdk_app_id, current_key, project_number)
     }
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pushsignal/Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage.kt

@@ -0,0 +1,78 @@
+///
+/// Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage.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.pushsignal
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+
+/**
+ * Represents the JavaScript callback `(message: struct) => std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage: (PushMessage) -> Promise<Promise<Boolean>> {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(message: PushMessage): Promise<Promise<Boolean>>
+}
+
+/**
+ * Represents the JavaScript callback `(message: struct) => std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_cxx: Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(message: PushMessage): Promise<Promise<Boolean>>
+    = invoke_cxx(message)
+
+  private external fun invoke_cxx(message: PushMessage): Promise<Promise<Boolean>>
+}
+
+/**
+ * Represents the JavaScript callback `(message: struct) => std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>`.
+ * This is implemented in Java/Kotlin, via a `(PushMessage) -> Promise<Promise<Boolean>>`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_java(private val function: (PushMessage) -> Promise<Promise<Boolean>>): Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage {
+  @DoNotStrip
+  @Keep
+  override fun invoke(message: PushMessage): Promise<Promise<Boolean>> {
+    return this.function(message)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pushsignal/HybridPushSignalSpec.kt

@@ -32,25 +32,17 @@ abstract class HybridPushSignalSpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun initialize(config: AndroidFirebaseConfig): Unit
-  
-  @DoNotStrip
-  @Keep
-  abstract fun getPermissionStatus(): Promise<PermissionStatus>
-  
-  @DoNotStrip
-  @Keep
-  abstract fun requestPermission(): Promise<PermissionStatus>
+  abstract fun initialize(config: AndroidFirebaseConfig): Promise<Unit>
   
   @DoNotStrip
   @Keep
   abstract fun getCredentials(): Promise<PushCredentials>
   
-  abstract fun setOnMessage(callback: (message: PushMessage) -> Unit): Unit
+  abstract fun setOnMessage(callback: (message: PushMessage) -> Promise<Promise<Boolean>>): Unit
   
   @DoNotStrip
   @Keep
-  private fun setOnMessage_cxx(callback: Func_void_PushMessage): Unit {
+  private fun setOnMessage_cxx(callback: Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage): Unit {
     val __result = setOnMessage(callback)
     return __result
   }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pushsignal/PushPlatform.kt

@@ -17,7 +17,7 @@ import com.facebook.proguard.annotations.DoNotStrip
 @Keep
 enum class PushPlatform(@DoNotStrip @Keep val value: Int) {
   IOS(0),
-  ANDROID(1);
+  ANDROID_OS(1);
 
   companion object
 }

package/nitrogen/generated/android/pushsignalOnLoad.cpp

@@ -16,6 +16,7 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridPushSignalSpec.hpp"
+#include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage.hpp"
 #include "JFunc_void_PushMessage.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
@@ -42,6 +43,7 @@ void registerAllNatives() {
 
   // Register native JNI methods
   margelo::nitro::pushsignal::JHybridPushSignalSpec::CxxPart::registerNatives();
+  margelo::nitro::pushsignal::JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_cxx::registerNatives();
   margelo::nitro::pushsignal::JFunc_void_PushMessage_cxx::registerNatives();
 
   // Register Nitro Hybrid Objects

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

@@ -14,11 +14,11 @@
 
 namespace margelo::nitro::pushsignal::bridge::swift {
 
-  // pragma MARK: std::function<void(PermissionStatus /* result */)>
-  Func_void_PermissionStatus create_Func_void_PermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = PushSignal::Func_void_PermissionStatus::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](PermissionStatus result) mutable -> void {
-      swiftClosure.call(static_cast<int>(result));
+  // pragma MARK: std::function<void()>
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = PushSignal::Func_void::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
+      swiftClosure.call();
     };
   }
   
@@ -38,6 +38,31 @@ namespace margelo::nitro::pushsignal::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(bool /* result */)>
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = PushSignal::Func_void_bool::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = PushSignal::Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const PushMessage& message) mutable -> std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>> {
+      auto __result = swiftClosure.call(message);
+      return __result;
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>
+  Func_void_std__shared_ptr_Promise_bool__ create_Func_void_std__shared_ptr_Promise_bool__(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = PushSignal::Func_void_std__shared_ptr_Promise_bool__::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<Promise<bool>>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::function<void(const PushMessage& /* message */)>
   Func_void_PushMessage create_Func_void_PushMessage(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = PushSignal::Func_void_PushMessage::fromUnsafe(swiftClosureWrapper);

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

@@ -10,8 +10,6 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `HybridPushSignalSpec` to properly resolve imports.
 namespace margelo::nitro::pushsignal { class HybridPushSignalSpec; }
-// Forward declaration of `PermissionStatus` to properly resolve imports.
-namespace margelo::nitro::pushsignal { enum class PermissionStatus; }
 // Forward declaration of `PushCredentials` to properly resolve imports.
 namespace margelo::nitro::pushsignal { struct PushCredentials; }
 // Forward declaration of `PushEnvironment` to properly resolve imports.
@@ -27,7 +25,6 @@ namespace PushSignal { class HybridPushSignalSpec_cxx; }
 
 // Include C++ defined types
 #include "HybridPushSignalSpec.hpp"
-#include "PermissionStatus.hpp"
 #include "PushCredentials.hpp"
 #include "PushEnvironment.hpp"
 #include "PushMessage.hpp"
@@ -48,53 +45,38 @@ namespace PushSignal { class HybridPushSignalSpec_cxx; }
  */
 namespace margelo::nitro::pushsignal::bridge::swift {
 
-  // pragma MARK: std::optional<std::string>
+  // pragma MARK: std::shared_ptr<Promise<void>>
   /**
-   * Specialized version of `std::optional<std::string>`.
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
    */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
-    return std::optional<std::string>(value);
-  }
-  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return optional.has_value();
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
+    return Promise<void>::create();
   }
-  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return optional.value();
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<PermissionStatus>>
+  // pragma MARK: std::function<void()>
   /**
-   * Specialized version of `std::shared_ptr<Promise<PermissionStatus>>`.
+   * Specialized version of `std::function<void()>`.
    */
-  using std__shared_ptr_Promise_PermissionStatus__ = std::shared_ptr<Promise<PermissionStatus>>;
-  inline std::shared_ptr<Promise<PermissionStatus>> create_std__shared_ptr_Promise_PermissionStatus__() noexcept {
-    return Promise<PermissionStatus>::create();
-  }
-  inline PromiseHolder<PermissionStatus> wrap_std__shared_ptr_Promise_PermissionStatus__(std::shared_ptr<Promise<PermissionStatus>> promise) noexcept {
-    return PromiseHolder<PermissionStatus>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(PermissionStatus /* result */)>
-  /**
-   * Specialized version of `std::function<void(PermissionStatus)>`.
-   */
-  using Func_void_PermissionStatus = std::function<void(PermissionStatus /* result */)>;
+  using Func_void = std::function<void()>;
   /**
-   * Wrapper class for a `std::function<void(PermissionStatus / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
    */
-  class Func_void_PermissionStatus_Wrapper final {
+  class Func_void_Wrapper final {
   public:
-    explicit Func_void_PermissionStatus_Wrapper(std::function<void(PermissionStatus /* result */)>&& func): _function(std::make_unique<std::function<void(PermissionStatus /* result */)>>(std::move(func))) {}
-    inline void call(int result) const noexcept {
-      _function->operator()(static_cast<PermissionStatus>(result));
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
     }
   private:
-    std::unique_ptr<std::function<void(PermissionStatus /* result */)>> _function;
+    std::unique_ptr<std::function<void()>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_PermissionStatus create_Func_void_PermissionStatus(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_PermissionStatus_Wrapper wrap_Func_void_PermissionStatus(Func_void_PermissionStatus value) noexcept {
-    return Func_void_PermissionStatus_Wrapper(std::move(value));
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(value));
   }
   
   // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
@@ -119,6 +101,21 @@ namespace margelo::nitro::pushsignal::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<PushEnvironment>
   /**
    * Specialized version of `std::optional<PushEnvironment>`.
@@ -168,6 +165,40 @@ namespace margelo::nitro::pushsignal::bridge::swift {
     return Func_void_PushCredentials_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(bool /* result */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
+    inline void call(bool result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::unordered_map<std::string, std::string>
   /**
    * Specialized version of `std::unordered_map<std::string, std::string>`.
@@ -193,6 +224,63 @@ namespace margelo::nitro::pushsignal::bridge::swift {
     map.emplace(key, value);
   }
   
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& / * message * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>> call(PushMessage message) const noexcept {
+      auto __result = _function->operator()(message);
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_Promise_bool____ = std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>> create_std__shared_ptr_Promise_std__shared_ptr_Promise_bool____() noexcept {
+    return Promise<std::shared_ptr<Promise<bool>>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<Promise<bool>>> wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_bool____(std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<Promise<bool>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<Promise<bool>>&)>`.
+   */
+  using Func_void_std__shared_ptr_Promise_bool__ = std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<Promise<bool>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_Promise_bool___Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_Promise_bool___Wrapper(std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<Promise<bool>> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_Promise_bool__ create_Func_void_std__shared_ptr_Promise_bool__(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_Promise_bool___Wrapper wrap_Func_void_std__shared_ptr_Promise_bool__(Func_void_std__shared_ptr_Promise_bool__ value) noexcept {
+    return Func_void_std__shared_ptr_Promise_bool___Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::function<void(const PushMessage& /* message */)>
   /**
    * Specialized version of `std::function<void(const PushMessage&)>`.
@@ -227,22 +315,13 @@ namespace margelo::nitro::pushsignal::bridge::swift {
   using std__weak_ptr_HybridPushSignalSpec_ = std::weak_ptr<HybridPushSignalSpec>;
   inline std__weak_ptr_HybridPushSignalSpec_ weakify_std__shared_ptr_HybridPushSignalSpec_(const std::shared_ptr<HybridPushSignalSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: Result<void>
-  using Result_void_ = Result<void>;
-  inline Result_void_ create_Result_void_() noexcept {
-    return Result<void>::withValue();
-  }
-  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
-    return Result<void>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<PermissionStatus>>>
-  using Result_std__shared_ptr_Promise_PermissionStatus___ = Result<std::shared_ptr<Promise<PermissionStatus>>>;
-  inline Result_std__shared_ptr_Promise_PermissionStatus___ create_Result_std__shared_ptr_Promise_PermissionStatus___(const std::shared_ptr<Promise<PermissionStatus>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<PermissionStatus>>>::withValue(value);
+  // 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 {
+    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_PermissionStatus___ create_Result_std__shared_ptr_Promise_PermissionStatus___(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<PermissionStatus>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<PushCredentials>>>
@@ -253,5 +332,14 @@ namespace margelo::nitro::pushsignal::bridge::swift {
   inline Result_std__shared_ptr_Promise_PushCredentials___ create_Result_std__shared_ptr_Promise_PushCredentials___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<PushCredentials>>>::withError(error);
   }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
 
 } // namespace margelo::nitro::pushsignal::bridge::swift

package/nitrogen/generated/ios/PushSignal-Swift-Cxx-Umbrella.hpp

@@ -12,8 +12,6 @@
 namespace margelo::nitro::pushsignal { struct AndroidFirebaseConfig; }
 // Forward declaration of `HybridPushSignalSpec` to properly resolve imports.
 namespace margelo::nitro::pushsignal { class HybridPushSignalSpec; }
-// Forward declaration of `PermissionStatus` to properly resolve imports.
-namespace margelo::nitro::pushsignal { enum class PermissionStatus; }
 // Forward declaration of `PushCredentials` to properly resolve imports.
 namespace margelo::nitro::pushsignal { struct PushCredentials; }
 // Forward declaration of `PushEnvironment` to properly resolve imports.
@@ -26,7 +24,6 @@ namespace margelo::nitro::pushsignal { enum class PushPlatform; }
 // Include C++ defined types
 #include "AndroidFirebaseConfig.hpp"
 #include "HybridPushSignalSpec.hpp"
-#include "PermissionStatus.hpp"
 #include "PushCredentials.hpp"
 #include "PushEnvironment.hpp"
 #include "PushMessage.hpp"

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

@@ -14,8 +14,6 @@ namespace PushSignal { class HybridPushSignalSpec_cxx; }
 
 // Forward declaration of `AndroidFirebaseConfig` to properly resolve imports.
 namespace margelo::nitro::pushsignal { struct AndroidFirebaseConfig; }
-// Forward declaration of `PermissionStatus` to properly resolve imports.
-namespace margelo::nitro::pushsignal { enum class PermissionStatus; }
 // Forward declaration of `PushCredentials` to properly resolve imports.
 namespace margelo::nitro::pushsignal { struct PushCredentials; }
 // Forward declaration of `PushPlatform` to properly resolve imports.
@@ -25,11 +23,10 @@ namespace margelo::nitro::pushsignal { enum class PushEnvironment; }
 // Forward declaration of `PushMessage` to properly resolve imports.
 namespace margelo::nitro::pushsignal { struct PushMessage; }
 
+#include <NitroModules/Promise.hpp>
 #include "AndroidFirebaseConfig.hpp"
 #include <string>
 #include <optional>
-#include "PermissionStatus.hpp"
-#include <NitroModules/Promise.hpp>
 #include "PushCredentials.hpp"
 #include "PushPlatform.hpp"
 #include "PushEnvironment.hpp"
@@ -87,25 +84,11 @@ namespace margelo::nitro::pushsignal {
 
   public:
     // Methods
-    inline void initialize(const AndroidFirebaseConfig& config) override {
+    inline std::shared_ptr<Promise<void>> initialize(const AndroidFirebaseConfig& config) override {
       auto __result = _swiftPart.initialize(std::forward<decltype(config)>(config));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
-    }
-    inline std::shared_ptr<Promise<PermissionStatus>> getPermissionStatus() override {
-      auto __result = _swiftPart.getPermissionStatus();
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-      auto __value = std::move(__result.value());
-      return __value;
-    }
-    inline std::shared_ptr<Promise<PermissionStatus>> requestPermission() override {
-      auto __result = _swiftPart.requestPermission();
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
       auto __value = std::move(__result.value());
       return __value;
     }
@@ -117,7 +100,7 @@ namespace margelo::nitro::pushsignal {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void setOnMessage(const std::function<void(const PushMessage& /* message */)>& callback) override {
+    inline void setOnMessage(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>& callback) override {
       auto __result = _swiftPart.setOnMessage(callback);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());