@novastera-oss/nitro-metamask 0.3.3 → 0.4.2

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

@@ -0,0 +1,69 @@
+///
+/// JVariant_NullType_Long.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <variant>
+
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitrometamask {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Long".
+   */
+  class JVariant_NullType_Long: public jni::JavaClass<JVariant_NullType_Long> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrometamask/Variant_NullType_Long;";
+
+    static jni::local_ref<JVariant_NullType_Long> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Long(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_Long> create_1(int64_t value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Long(int64_t)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_Long> fromCpp(const std::variant<nitro::NullType, int64_t>& 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, int64_t> toCpp() const;
+  };
+
+  namespace JVariant_NullType_Long_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_Long> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrometamask/Variant_NullType_Long$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_Long> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrometamask/Variant_NullType_Long$Second;";
+    
+      [[nodiscard]] int64_t getValue() const {
+        static const auto field = javaClassStatic()->getField<int64_t>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_Long_impl
+} // namespace margelo::nitro::nitrometamask

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

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

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

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

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrometamask/ConnectResult.kt

@@ -22,7 +22,7 @@ data class ConnectResult(
   val address: String,
   @DoNotStrip
   @Keep
-  val chainId: Double
+  val chainId: Long
 ) {
   /* primary constructor */
 
@@ -34,7 +34,7 @@ data class ConnectResult(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(address: String, chainId: Double): ConnectResult {
+    private fun fromCpp(address: String, chainId: Long): ConnectResult {
       return ConnectResult(address, chainId)
     }
   }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrometamask/ConnectSignResult.kt

@@ -0,0 +1,44 @@
+///
+/// ConnectSignResult.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrometamask
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "ConnectSignResult".
+ */
+@DoNotStrip
+@Keep
+data class ConnectSignResult(
+  @DoNotStrip
+  @Keep
+  val signature: String,
+  @DoNotStrip
+  @Keep
+  val address: String,
+  @DoNotStrip
+  @Keep
+  val chainId: Long
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(signature: String, address: String, chainId: Long): ConnectSignResult {
+      return ConnectSignResult(signature, address, chainId)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrometamask/HybridNitroMetamaskSpec.kt

@@ -11,6 +11,7 @@ import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.NullType
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -48,7 +49,7 @@ abstract class HybridNitroMetamaskSpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun configure(dappUrl: String?): Unit
+  abstract fun configure(dappUrl: String?, deepLinkScheme: String?): Unit
   
   @DoNotStrip
   @Keep
@@ -60,7 +61,15 @@ abstract class HybridNitroMetamaskSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun connectSign(nonce: String, exp: Long): Promise<String>
+  abstract fun connectSign(nonce: String, exp: Long): Promise<ConnectSignResult>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getAddress(): Promise<Variant_NullType_String>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getChainId(): Promise<Variant_NullType_Long>
 
   private external fun initHybrid(): HybridData
 

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrometamask/Variant_NullType_Long.kt

@@ -0,0 +1,59 @@
+///
+/// Variant_NullType_Long.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrometamask
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.NullType
+
+/**
+ * Represents the TypeScript variant "NullType | Long".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class Variant_NullType_Long {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: NullType): Variant_NullType_Long()
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: Long): Variant_NullType_Long()
+
+  @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR)
+  inline fun <reified T> getAs(): T? = when (this) {
+    is First -> value as? T
+    is Second -> value as? T
+  }
+
+  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(): Long? {
+    val value = (this as? Second)?.value ?: return null
+    return value
+  }
+
+  inline fun <R> match(first: (NullType) -> R, second: (Long) -> R): R {
+    return when (this) {
+      is First -> first(value)
+      is Second -> second(value)
+    }
+  }
+
+  companion object {
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: NullType): Variant_NullType_Long = First(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: Long): Variant_NullType_Long = Second(value)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrometamask/Variant_NullType_String.kt

@@ -0,0 +1,59 @@
+///
+/// Variant_NullType_String.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrometamask
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.NullType
+
+/**
+ * Represents the TypeScript variant "NullType | String".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class Variant_NullType_String {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: NullType): Variant_NullType_String()
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: String): Variant_NullType_String()
+
+  @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR)
+  inline fun <reified T> getAs(): T? = when (this) {
+    is First -> value as? T
+    is Second -> value as? T
+  }
+
+  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(): String? {
+    val value = (this as? Second)?.value ?: return null
+    return value
+  }
+
+  inline fun <R> match(first: (NullType) -> R, second: (String) -> R): R {
+    return when (this) {
+      is First -> first(value)
+      is Second -> second(value)
+    }
+  }
+
+  companion object {
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: NullType): Variant_NullType_String = First(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: String): Variant_NullType_String = Second(value)
+  }
+}

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

@@ -38,6 +38,30 @@ namespace margelo::nitro::nitrometamask::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const ConnectSignResult& /* result */)>
+  Func_void_ConnectSignResult create_Func_void_ConnectSignResult(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroMetamask::Func_void_ConnectSignResult::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const ConnectSignResult& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>
+  Func_void_std__variant_nitro__NullType__std__string_ create_Func_void_std__variant_nitro__NullType__std__string_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroMetamask::Func_void_std__variant_nitro__NullType__std__string_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::variant<nitro::NullType, std::string>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, int64_t>& /* result */)>
+  Func_void_std__variant_nitro__NullType__int64_t_ create_Func_void_std__variant_nitro__NullType__int64_t_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroMetamask::Func_void_std__variant_nitro__NullType__int64_t_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::variant<nitro::NullType, int64_t>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridNitroMetamaskSpec>
   std::shared_ptr<HybridNitroMetamaskSpec> create_std__shared_ptr_HybridNitroMetamaskSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     NitroMetamask::HybridNitroMetamaskSpec_cxx swiftPart = NitroMetamask::HybridNitroMetamaskSpec_cxx::fromUnsafe(swiftUnsafePointer);

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

@@ -10,6 +10,8 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
+// Forward declaration of `ConnectSignResult` to properly resolve imports.
+namespace margelo::nitro::nitrometamask { struct ConnectSignResult; }
 // Forward declaration of `HybridNitroMetamaskSpec` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { class HybridNitroMetamaskSpec; }
 
@@ -19,7 +21,9 @@ namespace NitroMetamask { class HybridNitroMetamaskSpec_cxx; }
 
 // Include C++ defined types
 #include "ConnectResult.hpp"
+#include "ConnectSignResult.hpp"
 #include "HybridNitroMetamaskSpec.hpp"
+#include <NitroModules/Null.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -28,6 +32,7 @@ namespace NitroMetamask { class HybridNitroMetamaskSpec_cxx; }
 #include <memory>
 #include <optional>
 #include <string>
+#include <variant>
 
 /**
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
@@ -140,6 +145,166 @@ namespace margelo::nitro::nitrometamask::bridge::swift {
     return Func_void_std__string_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<ConnectSignResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<ConnectSignResult>>`.
+   */
+  using std__shared_ptr_Promise_ConnectSignResult__ = std::shared_ptr<Promise<ConnectSignResult>>;
+  inline std::shared_ptr<Promise<ConnectSignResult>> create_std__shared_ptr_Promise_ConnectSignResult__() noexcept {
+    return Promise<ConnectSignResult>::create();
+  }
+  inline PromiseHolder<ConnectSignResult> wrap_std__shared_ptr_Promise_ConnectSignResult__(std::shared_ptr<Promise<ConnectSignResult>> promise) noexcept {
+    return PromiseHolder<ConnectSignResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const ConnectSignResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const ConnectSignResult&)>`.
+   */
+  using Func_void_ConnectSignResult = std::function<void(const ConnectSignResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const ConnectSignResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_ConnectSignResult_Wrapper final {
+  public:
+    explicit Func_void_ConnectSignResult_Wrapper(std::function<void(const ConnectSignResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const ConnectSignResult& /* result */)>>(std::move(func))) {}
+    inline void call(ConnectSignResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const ConnectSignResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_ConnectSignResult create_Func_void_ConnectSignResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_ConnectSignResult_Wrapper wrap_Func_void_ConnectSignResult(Func_void_ConnectSignResult value) noexcept {
+    return Func_void_ConnectSignResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, std::string>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::string>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__std__string_ final {
+    std::variant<nitro::NullType, std::string> variant;
+    std__variant_nitro__NullType__std__string_(std::variant<nitro::NullType, std::string> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::string>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline std::string get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(const std::string& value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>`.
+   */
+  using std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___ = std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>;
+  inline std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___() noexcept {
+    return Promise<std::variant<nitro::NullType, std::string>>::create();
+  }
+  inline PromiseHolder<std::variant<nitro::NullType, std::string>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___(std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> promise) noexcept {
+    return PromiseHolder<std::variant<nitro::NullType, std::string>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, std::string>&)>`.
+   */
+  using Func_void_std__variant_nitro__NullType__std__string_ = std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, std::string>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__variant_nitro__NullType__std__string__Wrapper final {
+  public:
+    explicit Func_void_std__variant_nitro__NullType__std__string__Wrapper(std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<nitro::NullType, std::string> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, std::string>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__variant_nitro__NullType__std__string_ create_Func_void_std__variant_nitro__NullType__std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_nitro__NullType__std__string__Wrapper wrap_Func_void_std__variant_nitro__NullType__std__string_(Func_void_std__variant_nitro__NullType__std__string_ value) noexcept {
+    return Func_void_std__variant_nitro__NullType__std__string__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, int64_t>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, int64_t>`.
+   * 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__int64_t_ final {
+    std::variant<nitro::NullType, int64_t> variant;
+    std__variant_nitro__NullType__int64_t_(std::variant<nitro::NullType, int64_t> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, int64_t>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline int64_t get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__int64_t_ create_std__variant_nitro__NullType__int64_t_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__int64_t_(value);
+  }
+  inline std__variant_nitro__NullType__int64_t_ create_std__variant_nitro__NullType__int64_t_(int64_t value) noexcept {
+    return std__variant_nitro__NullType__int64_t_(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>>`.
+   */
+  using std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t___ = std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>>;
+  inline std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t___() noexcept {
+    return Promise<std::variant<nitro::NullType, int64_t>>::create();
+  }
+  inline PromiseHolder<std::variant<nitro::NullType, int64_t>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t___(std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>> promise) noexcept {
+    return PromiseHolder<std::variant<nitro::NullType, int64_t>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, int64_t>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, int64_t>&)>`.
+   */
+  using Func_void_std__variant_nitro__NullType__int64_t_ = std::function<void(const std::variant<nitro::NullType, int64_t>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, int64_t>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__variant_nitro__NullType__int64_t__Wrapper final {
+  public:
+    explicit Func_void_std__variant_nitro__NullType__int64_t__Wrapper(std::function<void(const std::variant<nitro::NullType, int64_t>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, int64_t>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<nitro::NullType, int64_t> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, int64_t>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__variant_nitro__NullType__int64_t_ create_Func_void_std__variant_nitro__NullType__int64_t_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_nitro__NullType__int64_t__Wrapper wrap_Func_void_std__variant_nitro__NullType__int64_t_(Func_void_std__variant_nitro__NullType__int64_t_ value) noexcept {
+    return Func_void_std__variant_nitro__NullType__int64_t__Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridNitroMetamaskSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridNitroMetamaskSpec>`.
@@ -178,5 +343,32 @@ namespace margelo::nitro::nitrometamask::bridge::swift {
   inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
   }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<ConnectSignResult>>>
+  using Result_std__shared_ptr_Promise_ConnectSignResult___ = Result<std::shared_ptr<Promise<ConnectSignResult>>>;
+  inline Result_std__shared_ptr_Promise_ConnectSignResult___ create_Result_std__shared_ptr_Promise_ConnectSignResult___(const std::shared_ptr<Promise<ConnectSignResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<ConnectSignResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_ConnectSignResult___ create_Result_std__shared_ptr_Promise_ConnectSignResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<ConnectSignResult>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>>
+  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____(const std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>>>
+  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t____ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t____(const std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::nitrometamask::bridge::swift

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

@@ -10,18 +10,23 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
+// Forward declaration of `ConnectSignResult` to properly resolve imports.
+namespace margelo::nitro::nitrometamask { struct ConnectSignResult; }
 // Forward declaration of `HybridNitroMetamaskSpec` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { class HybridNitroMetamaskSpec; }
 
 // Include C++ defined types
 #include "ConnectResult.hpp"
+#include "ConnectSignResult.hpp"
 #include "HybridNitroMetamaskSpec.hpp"
+#include <NitroModules/Null.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <memory>
 #include <optional>
 #include <string>
+#include <variant>
 
 // C++ helpers for Swift
 #include "NitroMetamask-Swift-Cxx-Bridge.hpp"