munim-wifi 0.1.0 → 0.1.2

package/nitrogen/generated/android/kotlin/com/margelo/nitro/munimwifi/Variant_NullType_CurrentNetworkInfo.kt

@@ -0,0 +1,59 @@
+///
+/// Variant_NullType_CurrentNetworkInfo.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.munimwifi
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.NullType
+
+/**
+ * Represents the TypeScript variant "NullType | CurrentNetworkInfo".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class Variant_NullType_CurrentNetworkInfo {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: NullType): Variant_NullType_CurrentNetworkInfo()
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: CurrentNetworkInfo): Variant_NullType_CurrentNetworkInfo()
+
+  @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(): CurrentNetworkInfo? {
+    val value = (this as? Second)?.value ?: return null
+    return value
+  }
+
+  inline fun <R> match(first: (NullType) -> R, second: (CurrentNetworkInfo) -> R): R {
+    return when (this) {
+      is First -> first(value)
+      is Second -> second(value)
+    }
+  }
+
+  companion object {
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: NullType): Variant_NullType_CurrentNetworkInfo = First(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: CurrentNetworkInfo): Variant_NullType_CurrentNetworkInfo = Second(value)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/munimwifi/WifiNetwork.kt

@@ -25,10 +25,10 @@ data class WifiNetwork(
   val bssid: String,
   @DoNotStrip
   @Keep
-  val rssi: Double,
+  val rssi: Double?,
   @DoNotStrip
   @Keep
-  val frequency: Double,
+  val frequency: Double?,
   @DoNotStrip
   @Keep
   val channel: Double?,
@@ -52,7 +52,7 @@ data class WifiNetwork(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(ssid: String, bssid: String, rssi: Double, frequency: Double, channel: Double?, capabilities: String?, isSecure: Boolean?, timestamp: Double?): WifiNetwork {
+    private fun fromCpp(ssid: String, bssid: String, rssi: Double?, frequency: Double?, channel: Double?, capabilities: String?, isSecure: Boolean?, timestamp: Double?): WifiNetwork {
       return WifiNetwork(ssid, bssid, rssi, frequency, channel, capabilities, isSecure, timestamp)
     }
   }

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

@@ -86,6 +86,22 @@ namespace margelo::nitro::munimwifi::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, CurrentNetworkInfo>& /* result */)>
+  Func_void_std__variant_nitro__NullType__CurrentNetworkInfo_ create_Func_void_std__variant_nitro__NullType__CurrentNetworkInfo_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = MunimWifi::Func_void_std__variant_nitro__NullType__CurrentNetworkInfo_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::variant<nitro::NullType, CurrentNetworkInfo>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void()>
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = MunimWifi::Func_void::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
+      swiftClosure.call();
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridMunimWifiSpec>
   std::shared_ptr<HybridMunimWifiSpec> create_std__shared_ptr_HybridMunimWifiSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     MunimWifi::HybridMunimWifiSpec_cxx swiftPart = MunimWifi::HybridMunimWifiSpec_cxx::fromUnsafe(swiftUnsafePointer);

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

@@ -10,6 +10,8 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `ChannelInfo` to properly resolve imports.
 namespace margelo::nitro::munimwifi { struct ChannelInfo; }
+// Forward declaration of `CurrentNetworkInfo` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct CurrentNetworkInfo; }
 // Forward declaration of `HybridMunimWifiSpec` to properly resolve imports.
 namespace margelo::nitro::munimwifi { class HybridMunimWifiSpec; }
 // Forward declaration of `Location` to properly resolve imports.
@@ -27,6 +29,7 @@ namespace MunimWifi { class HybridMunimWifiSpec_cxx; }
 
 // Include C++ defined types
 #include "ChannelInfo.hpp"
+#include "CurrentNetworkInfo.hpp"
 #include "HybridMunimWifiSpec.hpp"
 #include "Location.hpp"
 #include "ScanOptions.hpp"
@@ -557,6 +560,118 @@ namespace margelo::nitro::munimwifi::bridge::swift {
     return Func_void_std__variant_nitro__NullType__WifiNetwork__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<std::vector<std::string>>
+  /**
+   * Specialized version of `std::optional<std::vector<std::string>>`.
+   */
+  using std__optional_std__vector_std__string__ = std::optional<std::vector<std::string>>;
+  inline std::optional<std::vector<std::string>> create_std__optional_std__vector_std__string__(const std::vector<std::string>& value) noexcept {
+    return std::optional<std::vector<std::string>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<std::string> get_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, CurrentNetworkInfo>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, CurrentNetworkInfo>`.
+   * 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__CurrentNetworkInfo_ final {
+    std::variant<nitro::NullType, CurrentNetworkInfo> variant;
+    std__variant_nitro__NullType__CurrentNetworkInfo_(std::variant<nitro::NullType, CurrentNetworkInfo> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, CurrentNetworkInfo>() 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 CurrentNetworkInfo get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__CurrentNetworkInfo_ create_std__variant_nitro__NullType__CurrentNetworkInfo_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__CurrentNetworkInfo_(value);
+  }
+  inline std__variant_nitro__NullType__CurrentNetworkInfo_ create_std__variant_nitro__NullType__CurrentNetworkInfo_(const CurrentNetworkInfo& value) noexcept {
+    return std__variant_nitro__NullType__CurrentNetworkInfo_(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>>`.
+   */
+  using std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo___ = std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>>;
+  inline std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo___() noexcept {
+    return Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>::create();
+  }
+  inline PromiseHolder<std::variant<nitro::NullType, CurrentNetworkInfo>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo___(std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>> promise) noexcept {
+    return PromiseHolder<std::variant<nitro::NullType, CurrentNetworkInfo>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, CurrentNetworkInfo>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, CurrentNetworkInfo>&)>`.
+   */
+  using Func_void_std__variant_nitro__NullType__CurrentNetworkInfo_ = std::function<void(const std::variant<nitro::NullType, CurrentNetworkInfo>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, CurrentNetworkInfo>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__variant_nitro__NullType__CurrentNetworkInfo__Wrapper final {
+  public:
+    explicit Func_void_std__variant_nitro__NullType__CurrentNetworkInfo__Wrapper(std::function<void(const std::variant<nitro::NullType, CurrentNetworkInfo>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, CurrentNetworkInfo>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<nitro::NullType, CurrentNetworkInfo> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, CurrentNetworkInfo>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__variant_nitro__NullType__CurrentNetworkInfo_ create_Func_void_std__variant_nitro__NullType__CurrentNetworkInfo_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_nitro__NullType__CurrentNetworkInfo__Wrapper wrap_Func_void_std__variant_nitro__NullType__CurrentNetworkInfo_(Func_void_std__variant_nitro__NullType__CurrentNetworkInfo_ value) noexcept {
+    return Func_void_std__variant_nitro__NullType__CurrentNetworkInfo__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<void>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   */
+  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 PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    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()>> _function;
+  } SWIFT_NONCOPYABLE;
+  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::shared_ptr<HybridMunimWifiSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridMunimWifiSpec>`.
@@ -649,5 +764,23 @@ namespace margelo::nitro::munimwifi::bridge::swift {
   inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__WifiNetwork____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__WifiNetwork____(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, WifiNetwork>>>>::withError(error);
   }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>>>
+  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo____ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo____(const std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__CurrentNetworkInfo____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>>>::withError(error);
+  }
+  
+  // 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_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::munimwifi::bridge::swift

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

@@ -10,6 +10,10 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `ChannelInfo` to properly resolve imports.
 namespace margelo::nitro::munimwifi { struct ChannelInfo; }
+// Forward declaration of `ConnectionOptions` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct ConnectionOptions; }
+// Forward declaration of `CurrentNetworkInfo` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct CurrentNetworkInfo; }
 // Forward declaration of `HybridMunimWifiSpec` to properly resolve imports.
 namespace margelo::nitro::munimwifi { class HybridMunimWifiSpec; }
 // Forward declaration of `Location` to properly resolve imports.
@@ -23,6 +27,8 @@ namespace margelo::nitro::munimwifi { struct WifiNetwork; }
 
 // Include C++ defined types
 #include "ChannelInfo.hpp"
+#include "ConnectionOptions.hpp"
+#include "CurrentNetworkInfo.hpp"
 #include "HybridMunimWifiSpec.hpp"
 #include "Location.hpp"
 #include "ScanOptions.hpp"

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

@@ -22,6 +22,10 @@ namespace margelo::nitro::munimwifi { struct WifiFingerprint; }
 namespace margelo::nitro::munimwifi { struct Location; }
 // Forward declaration of `ChannelInfo` to properly resolve imports.
 namespace margelo::nitro::munimwifi { struct ChannelInfo; }
+// Forward declaration of `CurrentNetworkInfo` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct CurrentNetworkInfo; }
+// Forward declaration of `ConnectionOptions` to properly resolve imports.
+namespace margelo::nitro::munimwifi { struct ConnectionOptions; }
 
 #include <NitroModules/Promise.hpp>
 #include "WifiNetwork.hpp"
@@ -34,6 +38,8 @@ namespace margelo::nitro::munimwifi { struct ChannelInfo; }
 #include <NitroModules/Null.hpp>
 #include <variant>
 #include "ChannelInfo.hpp"
+#include "CurrentNetworkInfo.hpp"
+#include "ConnectionOptions.hpp"
 
 #include "MunimWifi-Swift-Cxx-Umbrella.hpp"
 
@@ -169,6 +175,38 @@ namespace margelo::nitro::munimwifi {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<std::variant<nitro::NullType, CurrentNetworkInfo>>> getCurrentNetwork() override {
+      auto __result = _swiftPart.getCurrentNetwork();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> connectToNetwork(const ConnectionOptions& options) override {
+      auto __result = _swiftPart.connectToNetwork(std::forward<decltype(options)>(options));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> disconnect() override {
+      auto __result = _swiftPart.disconnect();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> getIPAddress() override {
+      auto __result = _swiftPart.getIPAddress();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void addListener(const std::string& eventName) override {
       auto __result = _swiftPart.addListener(eventName);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/ConnectionOptions.swift

@@ -0,0 +1,66 @@
+///
+/// ConnectionOptions.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `ConnectionOptions`, backed by a C++ struct.
+ */
+public typealias ConnectionOptions = margelo.nitro.munimwifi.ConnectionOptions
+
+public extension ConnectionOptions {
+  private typealias bridge = margelo.nitro.munimwifi.bridge.swift
+
+  /**
+   * Create a new instance of `ConnectionOptions`.
+   */
+  init(ssid: String, password: String?, isWEP: Bool?) {
+    self.init(std.string(ssid), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = password {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = isWEP {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var ssid: String {
+    return String(self.__ssid)
+  }
+  
+  @inline(__always)
+  var password: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__password) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__password)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var isWEP: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__isWEP) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__isWEP)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+}

package/nitrogen/generated/ios/swift/CurrentNetworkInfo.swift

@@ -0,0 +1,113 @@
+///
+/// CurrentNetworkInfo.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `CurrentNetworkInfo`, backed by a C++ struct.
+ */
+public typealias CurrentNetworkInfo = margelo.nitro.munimwifi.CurrentNetworkInfo
+
+public extension CurrentNetworkInfo {
+  private typealias bridge = margelo.nitro.munimwifi.bridge.swift
+
+  /**
+   * Create a new instance of `CurrentNetworkInfo`.
+   */
+  init(ssid: String, bssid: String, ipAddress: String?, subnetMask: String?, gateway: String?, dnsServers: [String]?) {
+    self.init(std.string(ssid), std.string(bssid), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = ipAddress {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = subnetMask {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = gateway {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__vector_std__string__ in
+      if let __unwrappedValue = dnsServers {
+        return bridge.create_std__optional_std__vector_std__string__({ () -> bridge.std__vector_std__string_ in
+          var __vector = bridge.create_std__vector_std__string_(__unwrappedValue.count)
+          for __item in __unwrappedValue {
+            __vector.push_back(std.string(__item))
+          }
+          return __vector
+        }())
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var ssid: String {
+    return String(self.__ssid)
+  }
+  
+  @inline(__always)
+  var bssid: String {
+    return String(self.__bssid)
+  }
+  
+  @inline(__always)
+  var ipAddress: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__ipAddress) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__ipAddress)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var subnetMask: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__subnetMask) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__subnetMask)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var gateway: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__gateway) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__gateway)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var dnsServers: [String]? {
+    return { () -> [String]? in
+      if bridge.has_value_std__optional_std__vector_std__string__(self.__dnsServers) {
+        let __unwrapped = bridge.get_std__optional_std__vector_std__string__(self.__dnsServers)
+        return __unwrapped.map({ __item in String(__item) })
+      } else {
+        return nil
+      }
+    }()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `() -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void {
+  public typealias bridge = margelo.nitro.munimwifi.bridge.swift
+
+  private let closure: () -> Void
+
+  public init(_ closure: @escaping () -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call() -> Void {
+    self.closure()
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void {
+    return Unmanaged<Func_void>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__variant_nitro__NullType__CurrentNetworkInfo_.swift

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

package/nitrogen/generated/ios/swift/HybridMunimWifiSpec.swift

@@ -25,6 +25,10 @@ public protocol HybridMunimWifiSpec_protocol: HybridObject {
   func getBSSID(ssid: String) throws -> Promise<Variant_NullType_String>
   func getChannelInfo(ssid: String) throws -> Promise<Variant_NullType_ChannelInfo>
   func getNetworkInfo(ssid: String) throws -> Promise<Variant_NullType_WifiNetwork>
+  func getCurrentNetwork() throws -> Promise<Variant_NullType_CurrentNetworkInfo>
+  func connectToNetwork(options: ConnectionOptions) throws -> Promise<Void>
+  func disconnect() throws -> Promise<Void>
+  func getIPAddress() throws -> Promise<Variant_NullType_String>
   func addListener(eventName: String) throws -> Void
   func removeListeners(count: Double) throws -> Void
 }