react-native-ble-nitro 1.2.0 → 1.3.0

package/nitrogen/generated/android/BleNitroOnLoad.cpp

@@ -16,7 +16,7 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridNativeBleNitroSpec.hpp"
-#include "JFunc_void_BLEDevice.hpp"
+#include "JFunc_void_std__optional_BLEDevice__std__optional_std__string_.hpp"
 #include "JFunc_void_bool_std__string_std__string.hpp"
 #include "JFunc_void_std__string_bool_std__string.hpp"
 #include "JFunc_void_bool_std__string.hpp"
@@ -35,7 +35,7 @@ int initialize(JavaVM* vm) {
   return facebook::jni::initialize(vm, [] {
     // Register native JNI methods
     margelo::nitro::co::zyke::ble::JHybridNativeBleNitroSpec::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_BLEDevice_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_bool_std__string_std__string_cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_std__string_bool_std__string_cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_bool_std__string_cxx::registerNatives();

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

@@ -0,0 +1,65 @@
+///
+/// JAndroidScanMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AndroidScanMode.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AndroidScanMode" and the the Kotlin enum "AndroidScanMode".
+   */
+  struct JAndroidScanMode final: public jni::JavaClass<JAndroidScanMode> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/AndroidScanMode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AndroidScanMode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AndroidScanMode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AndroidScanMode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAndroidScanMode> fromCpp(AndroidScanMode value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLOWLATENCY = clazz->getStaticField<JAndroidScanMode>("LOWLATENCY");
+      static const auto fieldBALANCED = clazz->getStaticField<JAndroidScanMode>("BALANCED");
+      static const auto fieldLOWPOWER = clazz->getStaticField<JAndroidScanMode>("LOWPOWER");
+      static const auto fieldOPPORTUNISTIC = clazz->getStaticField<JAndroidScanMode>("OPPORTUNISTIC");
+      
+      switch (value) {
+        case AndroidScanMode::LOWLATENCY:
+          return clazz->getStaticFieldValue(fieldLOWLATENCY);
+        case AndroidScanMode::BALANCED:
+          return clazz->getStaticFieldValue(fieldBALANCED);
+        case AndroidScanMode::LOWPOWER:
+          return clazz->getStaticFieldValue(fieldLOWPOWER);
+        case AndroidScanMode::OPPORTUNISTIC:
+          return clazz->getStaticFieldValue(fieldOPPORTUNISTIC);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,86 @@
+///
+/// JFunc_void_std__optional_BLEDevice__std__optional_std__string_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "BLEDevice.hpp"
+#include <optional>
+#include <string>
+#include <functional>
+#include "JBLEDevice.hpp"
+#include "ManufacturerData.hpp"
+#include "JManufacturerData.hpp"
+#include "ManufacturerDataEntry.hpp"
+#include <vector>
+#include "JManufacturerDataEntry.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(device: BLEDevice?, error: String?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__optional_BLEDevice__std__optional_std__string_: public jni::JavaClass<JFunc_void_std__optional_BLEDevice__std__optional_std__string_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__optional_BLEDevice__std__optional_std__string_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__optional_BLEDevice__std__optional_std__string_` instance holds through JNI.
+     */
+    void invoke(const std::optional<BLEDevice>& device, const std::optional<std::string>& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JBLEDevice> /* device */, jni::alias_ref<jni::JString> /* error */)>("invoke");
+      method(self(), device.has_value() ? JBLEDevice::fromCpp(device.value()) : nullptr, error.has_value() ? jni::make_jstring(error.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__optional_BLEDevice__std__optional_std__string_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx final: public jni::HybridClass<JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx, JFunc_void_std__optional_BLEDevice__std__optional_std__string_> {
+  public:
+    static jni::local_ref<JFunc_void_std__optional_BLEDevice__std__optional_std__string_::javaobject> fromCpp(const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& func) {
+      return JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JBLEDevice> device, jni::alias_ref<jni::JString> error) {
+      _func(device != nullptr ? std::make_optional(device->toCpp()) : std::nullopt, error != nullptr ? std::make_optional(error->toStdString()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__optional_BLEDevice__std__optional_std__string__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx(const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -21,6 +21,8 @@ namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
 namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 // Forward declaration of `ScanFilter` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
+// Forward declaration of `AndroidScanMode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class AndroidScanMode; }
 
 #include "BLEDevice.hpp"
 #include <vector>
@@ -42,8 +44,10 @@ namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 #include <NitroModules/JPromise.hpp>
 #include "ScanFilter.hpp"
 #include "JScanFilter.hpp"
+#include "AndroidScanMode.hpp"
+#include "JAndroidScanMode.hpp"
 #include <functional>
-#include "JFunc_void_BLEDevice.hpp"
+#include "JFunc_void_std__optional_BLEDevice__std__optional_std__string_.hpp"
 #include "JFunc_void_bool_std__string_std__string.hpp"
 #include "JFunc_void_std__string_bool_std__string.hpp"
 #include "JFunc_void_bool_std__string.hpp"
@@ -77,9 +81,9 @@ namespace margelo::nitro::co::zyke::ble {
   
 
   // Methods
-  void JHybridNativeBleNitroSpec::startScan(const ScanFilter& filter, const std::function<void(const BLEDevice& /* device */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JScanFilter> /* filter */, jni::alias_ref<JFunc_void_BLEDevice::javaobject> /* callback */)>("startScan_cxx");
-    method(_javaPart, JScanFilter::fromCpp(filter), JFunc_void_BLEDevice_cxx::fromCpp(callback));
+  void JHybridNativeBleNitroSpec::startScan(const ScanFilter& filter, const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JScanFilter> /* filter */, jni::alias_ref<JFunc_void_std__optional_BLEDevice__std__optional_std__string_::javaobject> /* callback */)>("startScan_cxx");
+    method(_javaPart, JScanFilter::fromCpp(filter), JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx::fromCpp(callback));
   }
   bool JHybridNativeBleNitroSpec::stopScan() {
     static const auto method = javaClassStatic()->getMethod<jboolean()>("stopScan");

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

@@ -53,7 +53,7 @@ namespace margelo::nitro::co::zyke::ble {
 
   public:
     // Methods
-    void startScan(const ScanFilter& filter, const std::function<void(const BLEDevice& /* device */)>& callback) override;
+    void startScan(const ScanFilter& filter, const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& callback) override;
     bool stopScan() override;
     bool isScanning() override;
     std::vector<BLEDevice> getConnectedDevices(const std::vector<std::string>& services) override;

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

@@ -10,6 +10,8 @@
 #include <fbjni/fbjni.h>
 #include "ScanFilter.hpp"
 
+#include "AndroidScanMode.hpp"
+#include "JAndroidScanMode.hpp"
 #include <string>
 #include <vector>
 
@@ -38,6 +40,8 @@ namespace margelo::nitro::co::zyke::ble {
       double rssiThreshold = this->getFieldValue(fieldRssiThreshold);
       static const auto fieldAllowDuplicates = clazz->getField<jboolean>("allowDuplicates");
       jboolean allowDuplicates = this->getFieldValue(fieldAllowDuplicates);
+      static const auto fieldAndroidScanMode = clazz->getField<JAndroidScanMode>("androidScanMode");
+      jni::local_ref<JAndroidScanMode> androidScanMode = this->getFieldValue(fieldAndroidScanMode);
       return ScanFilter(
         [&]() {
           size_t __size = serviceUUIDs->size();
@@ -50,7 +54,8 @@ namespace margelo::nitro::co::zyke::ble {
           return __vector;
         }(),
         rssiThreshold,
-        static_cast<bool>(allowDuplicates)
+        static_cast<bool>(allowDuplicates),
+        androidScanMode->toCpp()
       );
     }
 
@@ -71,7 +76,8 @@ namespace margelo::nitro::co::zyke::ble {
           return __array;
         }(),
         value.rssiThreshold,
-        value.allowDuplicates
+        value.allowDuplicates,
+        JAndroidScanMode::fromCpp(value.androidScanMode)
       );
     }
   };

package/nitrogen/generated/android/kotlin/com/margelo/nitro/co/zyke/ble/AndroidScanMode.kt

@@ -0,0 +1,23 @@
+///
+/// AndroidScanMode.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.co.zyke.ble
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "AndroidScanMode".
+ */
+@DoNotStrip
+@Keep
+enum class AndroidScanMode(@DoNotStrip @Keep val value: Int) {
+  LOWLATENCY(0),
+  BALANCED(1),
+  LOWPOWER(2),
+  OPPORTUNISTIC(3);
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/co/zyke/ble/{Func_void_BLEDevice.kt → Func_void_std__optional_BLEDevice__std__optional_std__string_.kt}

@@ -1,5 +1,5 @@
 ///
-/// Func_void_BLEDevice.kt
+/// Func_void_std__optional_BLEDevice__std__optional_std__string_.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -15,25 +15,25 @@ import dalvik.annotation.optimization.FastNative
 
 
 /**
- * Represents the JavaScript callback `(device: struct) => void`.
+ * Represents the JavaScript callback `(device: optional, error: optional) => void`.
  * 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_void_BLEDevice: (BLEDevice) -> Unit {
+fun interface Func_void_std__optional_BLEDevice__std__optional_std__string_: (BLEDevice?, String?) -> Unit {
   /**
    * 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(device: BLEDevice): Unit
+  override fun invoke(device: BLEDevice?, error: String?): Unit
 }
 
 /**
- * Represents the JavaScript callback `(device: struct) => void`.
+ * Represents the JavaScript callback `(device: optional, error: optional) => void`.
  * This is implemented in C++, via a `std::function<...>`.
  * The callback might be coming from JS.
  */
@@ -44,7 +44,7 @@ fun interface Func_void_BLEDevice: (BLEDevice) -> Unit {
   "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
   "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
 )
-class Func_void_BLEDevice_cxx: Func_void_BLEDevice {
+class Func_void_std__optional_BLEDevice__std__optional_std__string__cxx: Func_void_std__optional_BLEDevice__std__optional_std__string_ {
   @DoNotStrip
   @Keep
   private val mHybridData: HybridData
@@ -57,25 +57,25 @@ class Func_void_BLEDevice_cxx: Func_void_BLEDevice {
 
   @DoNotStrip
   @Keep
-  override fun invoke(device: BLEDevice): Unit
-    = invoke_cxx(device)
+  override fun invoke(device: BLEDevice?, error: String?): Unit
+    = invoke_cxx(device,error)
 
   @FastNative
-  private external fun invoke_cxx(device: BLEDevice): Unit
+  private external fun invoke_cxx(device: BLEDevice?, error: String?): Unit
 }
 
 /**
- * Represents the JavaScript callback `(device: struct) => void`.
- * This is implemented in Java/Kotlin, via a `(BLEDevice) -> Unit`.
+ * Represents the JavaScript callback `(device: optional, error: optional) => void`.
+ * This is implemented in Java/Kotlin, via a `(BLEDevice?, String?) -> Unit`.
  * The callback is always coming from native.
  */
 @DoNotStrip
 @Keep
 @Suppress("ClassName", "RedundantUnitReturnType", "unused")
-class Func_void_BLEDevice_java(private val function: (BLEDevice) -> Unit): Func_void_BLEDevice {
+class Func_void_std__optional_BLEDevice__std__optional_std__string__java(private val function: (BLEDevice?, String?) -> Unit): Func_void_std__optional_BLEDevice__std__optional_std__string_ {
   @DoNotStrip
   @Keep
-  override fun invoke(device: BLEDevice): Unit {
-    return this.function(device)
+  override fun invoke(device: BLEDevice?, error: String?): Unit {
+    return this.function(device, error)
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/co/zyke/ble/HybridNativeBleNitroSpec.kt

@@ -40,11 +40,11 @@ abstract class HybridNativeBleNitroSpec: HybridObject() {
   
 
   // Methods
-  abstract fun startScan(filter: ScanFilter, callback: (device: BLEDevice) -> Unit): Unit
+  abstract fun startScan(filter: ScanFilter, callback: (device: BLEDevice?, error: String?) -> Unit): Unit
   
   @DoNotStrip
   @Keep
-  private fun startScan_cxx(filter: ScanFilter, callback: Func_void_BLEDevice): Unit {
+  private fun startScan_cxx(filter: ScanFilter, callback: Func_void_std__optional_BLEDevice__std__optional_std__string_): Unit {
     val __result = startScan(filter, callback)
     return __result
   }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/co/zyke/ble/ScanFilter.kt

@@ -29,7 +29,10 @@ data class ScanFilter
     val rssiThreshold: Double,
     @DoNotStrip
     @Keep
-    val allowDuplicates: Boolean
+    val allowDuplicates: Boolean,
+    @DoNotStrip
+    @Keep
+    val androidScanMode: AndroidScanMode
   ) {
   /* main constructor */
 }

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

@@ -13,11 +13,11 @@
 
 namespace margelo::nitro::co::zyke::ble::bridge::swift {
 
-  // pragma MARK: std::function<void(const BLEDevice& /* device */)>
-  Func_void_BLEDevice create_Func_void_BLEDevice(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = BleNitro::Func_void_BLEDevice::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const BLEDevice& device) mutable -> void {
-      swiftClosure.call(device);
+  // pragma MARK: std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>
+  Func_void_std__optional_BLEDevice__std__optional_std__string_ create_Func_void_std__optional_BLEDevice__std__optional_std__string_(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_std__optional_BLEDevice__std__optional_std__string_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::optional<BLEDevice>& device, const std::optional<std::string>& error) mutable -> void {
+      swiftClosure.call(device, error);
     };
   }
   

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

@@ -76,26 +76,44 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::function<void(const BLEDevice& /* device */)>
+  // pragma MARK: std::optional<BLEDevice>
   /**
-   * Specialized version of `std::function<void(const BLEDevice&)>`.
+   * Specialized version of `std::optional<BLEDevice>`.
    */
-  using Func_void_BLEDevice = std::function<void(const BLEDevice& /* device */)>;
+  using std__optional_BLEDevice_ = std::optional<BLEDevice>;
+  inline std::optional<BLEDevice> create_std__optional_BLEDevice_(const BLEDevice& value) {
+    return std::optional<BLEDevice>(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) {
+    return std::optional<std::string>(value);
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>
   /**
-   * Wrapper class for a `std::function<void(const BLEDevice& / * device * /)>`, this can be used from Swift.
+   * Specialized version of `std::function<void(const std::optional<BLEDevice>&, const std::optional<std::string>&)>`.
    */
-  class Func_void_BLEDevice_Wrapper final {
+  using Func_void_std__optional_BLEDevice__std__optional_std__string_ = std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<BLEDevice>& / * device * /, const std::optional<std::string>& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_BLEDevice__std__optional_std__string__Wrapper final {
   public:
-    explicit Func_void_BLEDevice_Wrapper(std::function<void(const BLEDevice& /* device */)>&& func): _function(std::make_unique<std::function<void(const BLEDevice& /* device */)>>(std::move(func))) {}
-    inline void call(BLEDevice device) const {
-      _function->operator()(device);
+    explicit Func_void_std__optional_BLEDevice__std__optional_std__string__Wrapper(std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>>(std::move(func))) {}
+    inline void call(std::optional<BLEDevice> device, std::optional<std::string> error) const {
+      _function->operator()(device, error);
     }
   private:
-    std::unique_ptr<std::function<void(const BLEDevice& /* device */)>> _function;
+    std::unique_ptr<std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_BLEDevice create_Func_void_BLEDevice(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_BLEDevice_Wrapper wrap_Func_void_BLEDevice(Func_void_BLEDevice value) {
-    return Func_void_BLEDevice_Wrapper(std::move(value));
+  Func_void_std__optional_BLEDevice__std__optional_std__string_ create_Func_void_std__optional_BLEDevice__std__optional_std__string_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__optional_BLEDevice__std__optional_std__string__Wrapper wrap_Func_void_std__optional_BLEDevice__std__optional_std__string_(Func_void_std__optional_BLEDevice__std__optional_std__string_ value) {
+    return Func_void_std__optional_BLEDevice__std__optional_std__string__Wrapper(std::move(value));
   }
   
   // pragma MARK: std::vector<BLEDevice>
@@ -228,15 +246,6 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
     return Func_void_std__string_std__shared_ptr_ArrayBuffer__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) {
-    return std::optional<std::string>(value);
-  }
-  
   // pragma MARK: std::function<void(BLEState /* state */)>
   /**
    * Specialized version of `std::function<void(BLEState)>`.

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

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AndroidScanMode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class AndroidScanMode; }
 // Forward declaration of `ArrayBuffer` to properly resolve imports.
 namespace NitroModules { class ArrayBuffer; }
 // Forward declaration of `BLEDevice` to properly resolve imports.
@@ -26,6 +28,7 @@ namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 
 // Include C++ defined types
+#include "AndroidScanMode.hpp"
 #include "BLEDevice.hpp"
 #include "BLEState.hpp"
 #include "HybridNativeBleNitroSpec.hpp"

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

@@ -14,6 +14,8 @@ namespace BleNitro { class HybridNativeBleNitroSpec_cxx; }
 
 // Forward declaration of `ScanFilter` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
+// Forward declaration of `AndroidScanMode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class AndroidScanMode; }
 // Forward declaration of `BLEDevice` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
 // Forward declaration of `ManufacturerData` to properly resolve imports.
@@ -32,13 +34,14 @@ namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 #include "ScanFilter.hpp"
 #include <string>
 #include <vector>
+#include "AndroidScanMode.hpp"
 #include "BLEDevice.hpp"
+#include <optional>
 #include <functional>
 #include "ManufacturerData.hpp"
 #include "ManufacturerDataEntry.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/ArrayBufferHolder.hpp>
-#include <optional>
 #include "BLEState.hpp"
 #include "OperationResult.hpp"
 #include <NitroModules/Promise.hpp>
@@ -84,7 +87,7 @@ namespace margelo::nitro::co::zyke::ble {
 
   public:
     // Methods
-    inline void startScan(const ScanFilter& filter, const std::function<void(const BLEDevice& /* device */)>& callback) override {
+    inline void startScan(const ScanFilter& filter, const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& callback) override {
       auto __result = _swiftPart.startScan(filter, callback);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/AndroidScanMode.swift

@@ -0,0 +1,48 @@
+///
+/// AndroidScanMode.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS enum `AndroidScanMode`, backed by a C++ enum.
+ */
+public typealias AndroidScanMode = margelo.nitro.co.zyke.ble.AndroidScanMode
+
+public extension AndroidScanMode {
+  /**
+   * Get a AndroidScanMode for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "LowLatency":
+        self = .lowlatency
+      case "Balanced":
+        self = .balanced
+      case "LowPower":
+        self = .lowpower
+      case "Opportunistic":
+        self = .opportunistic
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AndroidScanMode represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .lowlatency:
+        return "LowLatency"
+      case .balanced:
+        return "Balanced"
+      case .lowpower:
+        return "LowPower"
+      case .opportunistic:
+        return "Opportunistic"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__optional_BLEDevice__std__optional_std__string_.swift

@@ -0,0 +1,59 @@
+///
+/// Func_void_std__optional_BLEDevice__std__optional_std__string_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+
+/**
+ * Wraps a Swift `(_ device: BLEDevice?, _ error: String?) -> 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__optional_BLEDevice__std__optional_std__string_ {
+  public typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
+
+  private let closure: (_ device: BLEDevice?, _ error: String?) -> Void
+
+  public init(_ closure: @escaping (_ device: BLEDevice?, _ error: String?) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(device: bridge.std__optional_BLEDevice_, error: bridge.std__optional_std__string_) -> Void {
+    self.closure({ () -> BLEDevice? in
+      if let __unwrapped = device.value {
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }(), { () -> String? in
+      if let __unwrapped = error.value {
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }())
+  }
+
+  /**
+   * 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__optional_BLEDevice__std__optional_std__string_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__optional_BLEDevice__std__optional_std__string_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__optional_BLEDevice__std__optional_std__string_ {
+    return Unmanaged<Func_void_std__optional_BLEDevice__std__optional_std__string_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridNativeBleNitroSpec.swift

@@ -14,7 +14,7 @@ public protocol HybridNativeBleNitroSpec_protocol: HybridObject {
   
 
   // Methods
-  func startScan(filter: ScanFilter, callback: @escaping (_ device: BLEDevice) -> Void) throws -> Void
+  func startScan(filter: ScanFilter, callback: @escaping (_ device: BLEDevice?, _ error: String?) -> Void) throws -> Void
   func stopScan() throws -> Bool
   func isScanning() throws -> Bool
   func getConnectedDevices(services: [String]) throws -> [BLEDevice]