munim-wifi 0.1.0

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

@@ -0,0 +1,262 @@
+///
+/// JHybridMunimWifiSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridMunimWifiSpec.hpp"
+
+// Forward declaration of `WifiNetwork` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct WifiNetwork; }
+// Forward declaration of `WifiFingerprint` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct WifiFingerprint; }
+// Forward declaration of `Location` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct Location; }
+// Forward declaration of `ChannelInfo` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct ChannelInfo; }
+// Forward declaration of `ScanOptions` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct ScanOptions; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "WifiNetwork.hpp"
+#include <vector>
+#include "JWifiNetwork.hpp"
+#include <string>
+#include <optional>
+#include "WifiFingerprint.hpp"
+#include "JWifiFingerprint.hpp"
+#include "Location.hpp"
+#include "JLocation.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "JVariant_NullType_Double.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JVariant_NullType_String.hpp"
+#include "ChannelInfo.hpp"
+#include "JVariant_NullType_ChannelInfo.hpp"
+#include "JChannelInfo.hpp"
+#include "JVariant_NullType_WifiNetwork.hpp"
+#include "ScanOptions.hpp"
+#include "JScanOptions.hpp"
+
+namespace margelo::nitro::munimwifi {
+
+  jni::local_ref<JHybridMunimWifiSpec::jhybriddata> JHybridMunimWifiSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridMunimWifiSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridMunimWifiSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridMunimWifiSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  bool JHybridMunimWifiSpec::equals(const std::shared_ptr<HybridObject>& other) {
+    if (auto otherCast = std::dynamic_pointer_cast<JHybridMunimWifiSpec>(other)) {
+      return _javaPart == otherCast->_javaPart;
+    }
+    return false;
+  }
+
+  void JHybridMunimWifiSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridMunimWifiSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<bool>> JHybridMunimWifiSpec::isWifiEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("isWifiEnabled");
+    auto __result = method(_javaPart);
+    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>> JHybridMunimWifiSpec::requestWifiPermission() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("requestWifiPermission");
+    auto __result = method(_javaPart);
+    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<std::vector<WifiNetwork>>> JHybridMunimWifiSpec::scanNetworks(const std::optional<ScanOptions>& options) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JScanOptions> /* options */)>("scanNetworks");
+    auto __result = method(_javaPart, options.has_value() ? JScanOptions::fromCpp(options.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<std::vector<WifiNetwork>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JWifiNetwork>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<WifiNetwork> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __result->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  void JHybridMunimWifiSpec::startScan(const std::optional<ScanOptions>& options) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JScanOptions> /* options */)>("startScan");
+    method(_javaPart, options.has_value() ? JScanOptions::fromCpp(options.value()) : nullptr);
+  }
+  void JHybridMunimWifiSpec::stopScan() {
+    static const auto method = javaClassStatic()->getMethod<void()>("stopScan");
+    method(_javaPart);
+  }
+  std::shared_ptr<Promise<std::vector<std::string>>> JHybridMunimWifiSpec::getSSIDs() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getSSIDs");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::vector<std::string>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<jni::JString>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __result->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }());
+      });
+      __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<WifiFingerprint>> JHybridMunimWifiSpec::getWifiFingerprint() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getWifiFingerprint");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<WifiFingerprint>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JWifiFingerprint>(__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, double>>> JHybridMunimWifiSpec::getRSSI(const std::string& ssid) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* ssid */)>("getRSSI");
+    auto __result = method(_javaPart, jni::make_jstring(ssid));
+    return [&]() {
+      auto __promise = Promise<std::variant<nitro::NullType, double>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_Double>(__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, std::string>>> JHybridMunimWifiSpec::getBSSID(const std::string& ssid) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* ssid */)>("getBSSID");
+    auto __result = method(_javaPart, jni::make_jstring(ssid));
+    return [&]() {
+      auto __promise = Promise<std::variant<nitro::NullType, std::string>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_String>(__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, ChannelInfo>>> JHybridMunimWifiSpec::getChannelInfo(const std::string& ssid) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* ssid */)>("getChannelInfo");
+    auto __result = method(_javaPart, jni::make_jstring(ssid));
+    return [&]() {
+      auto __promise = Promise<std::variant<nitro::NullType, ChannelInfo>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_ChannelInfo>(__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, WifiNetwork>>> JHybridMunimWifiSpec::getNetworkInfo(const std::string& ssid) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* ssid */)>("getNetworkInfo");
+    auto __result = method(_javaPart, jni::make_jstring(ssid));
+    return [&]() {
+      auto __promise = Promise<std::variant<nitro::NullType, WifiNetwork>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_WifiNetwork>(__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;
+    }();
+  }
+  void JHybridMunimWifiSpec::addListener(const std::string& eventName) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* eventName */)>("addListener");
+    method(_javaPart, jni::make_jstring(eventName));
+  }
+  void JHybridMunimWifiSpec::removeListeners(double count) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* count */)>("removeListeners");
+    method(_javaPart, count);
+  }
+
+} // namespace margelo::nitro::munimwifi

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

@@ -0,0 +1,78 @@
+///
+/// HybridMunimWifiSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridMunimWifiSpec.hpp"
+
+
+
+
+namespace margelo::nitro::munimwifi {
+
+  using namespace facebook;
+
+  class JHybridMunimWifiSpec: public jni::HybridClass<JHybridMunimWifiSpec, JHybridObject>,
+                              public virtual HybridMunimWifiSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/munimwifi/HybridMunimWifiSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridMunimWifiSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridMunimWifiSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridMunimWifiSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    bool equals(const std::shared_ptr<HybridObject>& other) override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridMunimWifiSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<bool>> isWifiEnabled() override;
+    std::shared_ptr<Promise<bool>> requestWifiPermission() override;
+    std::shared_ptr<Promise<std::vector<WifiNetwork>>> scanNetworks(const std::optional<ScanOptions>& options) override;
+    void startScan(const std::optional<ScanOptions>& options) override;
+    void stopScan() override;
+    std::shared_ptr<Promise<std::vector<std::string>>> getSSIDs() override;
+    std::shared_ptr<Promise<WifiFingerprint>> getWifiFingerprint() override;
+    std::shared_ptr<Promise<std::variant<nitro::NullType, double>>> getRSSI(const std::string& ssid) override;
+    std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> getBSSID(const std::string& ssid) override;
+    std::shared_ptr<Promise<std::variant<nitro::NullType, ChannelInfo>>> getChannelInfo(const std::string& ssid) override;
+    std::shared_ptr<Promise<std::variant<nitro::NullType, WifiNetwork>>> getNetworkInfo(const std::string& ssid) override;
+    void addListener(const std::string& eventName) override;
+    void removeListeners(double count) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridMunimWifiSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::munimwifi

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

@@ -0,0 +1,61 @@
+///
+/// JLocation.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 "Location.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::munimwifi {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Location" and the the Kotlin data class "Location".
+   */
+  struct JLocation final: public jni::JavaClass<JLocation> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/munimwifi/Location;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Location by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Location toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLatitude = clazz->getField<jni::JDouble>("latitude");
+      jni::local_ref<jni::JDouble> latitude = this->getFieldValue(fieldLatitude);
+      static const auto fieldLongitude = clazz->getField<jni::JDouble>("longitude");
+      jni::local_ref<jni::JDouble> longitude = this->getFieldValue(fieldLongitude);
+      return Location(
+        latitude != nullptr ? std::make_optional(latitude->value()) : std::nullopt,
+        longitude != nullptr ? std::make_optional(longitude->value()) : 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<JLocation::javaobject> fromCpp(const Location& value) {
+      using JSignature = JLocation(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.latitude.has_value() ? jni::JDouble::valueOf(value.latitude.value()) : nullptr,
+        value.longitude.has_value() ? jni::JDouble::valueOf(value.longitude.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::munimwifi

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

@@ -0,0 +1,61 @@
+///
+/// JScanOptions.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 "ScanOptions.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::munimwifi {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ScanOptions" and the the Kotlin data class "ScanOptions".
+   */
+  struct JScanOptions final: public jni::JavaClass<JScanOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/munimwifi/ScanOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ScanOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ScanOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMaxResults = clazz->getField<jni::JDouble>("maxResults");
+      jni::local_ref<jni::JDouble> maxResults = this->getFieldValue(fieldMaxResults);
+      static const auto fieldTimeout = clazz->getField<jni::JDouble>("timeout");
+      jni::local_ref<jni::JDouble> timeout = this->getFieldValue(fieldTimeout);
+      return ScanOptions(
+        maxResults != nullptr ? std::make_optional(maxResults->value()) : std::nullopt,
+        timeout != nullptr ? std::make_optional(timeout->value()) : 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<JScanOptions::javaobject> fromCpp(const ScanOptions& value) {
+      using JSignature = JScanOptions(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.maxResults.has_value() ? jni::JDouble::valueOf(value.maxResults.value()) : nullptr,
+        value.timeout.has_value() ? jni::JDouble::valueOf(value.timeout.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::munimwifi

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

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

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

@@ -0,0 +1,71 @@
+///
+/// JVariant_NullType_ChannelInfo.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 "ChannelInfo.hpp"
+#include <variant>
+#include <NitroModules/JNull.hpp>
+#include "JChannelInfo.hpp"
+
+namespace margelo::nitro::munimwifi {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_ChannelInfo".
+   */
+  class JVariant_NullType_ChannelInfo: public jni::JavaClass<JVariant_NullType_ChannelInfo> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/munimwifi/Variant_NullType_ChannelInfo;";
+
+    static jni::local_ref<JVariant_NullType_ChannelInfo> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_ChannelInfo(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_ChannelInfo> create_1(jni::alias_ref<JChannelInfo> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_ChannelInfo(jni::alias_ref<JChannelInfo>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_ChannelInfo> fromCpp(const std::variant<nitro::NullType, ChannelInfo>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(JChannelInfo::fromCpp(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, ChannelInfo> toCpp() const;
+  };
+
+  namespace JVariant_NullType_ChannelInfo_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_ChannelInfo> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/munimwifi/Variant_NullType_ChannelInfo$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_ChannelInfo> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/munimwifi/Variant_NullType_ChannelInfo$Second;";
+    
+      [[nodiscard]] jni::local_ref<JChannelInfo> getValue() const {
+        static const auto field = javaClassStatic()->getField<JChannelInfo>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_ChannelInfo_impl
+} // namespace margelo::nitro::munimwifi

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

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

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

@@ -0,0 +1,69 @@
+///
+/// JVariant_NullType_Double.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::munimwifi {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Double".
+   */
+  class JVariant_NullType_Double: public jni::JavaClass<JVariant_NullType_Double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/munimwifi/Variant_NullType_Double;";
+
+    static jni::local_ref<JVariant_NullType_Double> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Double(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_Double> create_1(double value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Double(double)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_Double> fromCpp(const std::variant<nitro::NullType, double>& 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, double> toCpp() const;
+  };
+
+  namespace JVariant_NullType_Double_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_Double> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/munimwifi/Variant_NullType_Double$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_Double> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/munimwifi/Variant_NullType_Double$Second;";
+    
+      [[nodiscard]] double getValue() const {
+        static const auto field = javaClassStatic()->getField<double>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_Double_impl
+} // namespace margelo::nitro::munimwifi