react-native-ble-nitro 1.0.0 → 1.1.0

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

@@ -15,24 +15,23 @@ public protocol HybridNativeBleNitroSpec_protocol: HybridObject {
 
   // Methods
   func startScan(filter: ScanFilter, callback: @escaping (_ device: BLEDevice) -> Void) throws -> Void
-  func stopScan(callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func isScanning(callback: @escaping (_ result: Bool) -> Void) throws -> Void
-  func getConnectedDevices(callback: @escaping (_ devices: [BLEDevice]) -> Void) throws -> Void
+  func stopScan() throws -> Bool
+  func isScanning() throws -> Bool
+  func getConnectedDevices(services: [String]) throws -> [BLEDevice]
   func connect(deviceId: String, callback: @escaping (_ success: Bool, _ deviceId: String, _ error: String) -> Void, disconnectCallback: ((_ deviceId: String, _ interrupted: Bool, _ error: String) -> Void)?) throws -> Void
   func disconnect(deviceId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func isConnected(deviceId: String, callback: @escaping (_ result: Bool) -> Void) throws -> Void
+  func isConnected(deviceId: String) throws -> Bool
   func discoverServices(deviceId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func getServices(deviceId: String, callback: @escaping (_ result: [String]) -> Void) throws -> Void
-  func getCharacteristics(deviceId: String, serviceId: String, callback: @escaping (_ result: [String]) -> Void) throws -> Void
+  func getServices(deviceId: String) throws -> [String]
+  func getCharacteristics(deviceId: String, serviceId: String) throws -> [String]
   func readCharacteristic(deviceId: String, serviceId: String, characteristicId: String, callback: @escaping (_ success: Bool, _ data: [Double], _ error: String) -> Void) throws -> Void
   func writeCharacteristic(deviceId: String, serviceId: String, characteristicId: String, data: [Double], withResponse: Bool, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
   func subscribeToCharacteristic(deviceId: String, serviceId: String, characteristicId: String, updateCallback: @escaping (_ characteristicId: String, _ data: [Double]) -> Void, resultCallback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
   func unsubscribeFromCharacteristic(deviceId: String, serviceId: String, characteristicId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func isBluetoothEnabled(callback: @escaping (_ result: Bool) -> Void) throws -> Void
   func requestBluetoothEnable(callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func state(callback: @escaping (_ state: BLEState) -> Void) throws -> Void
-  func subscribeToStateChange(stateCallback: @escaping (_ state: BLEState) -> Void, resultCallback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func unsubscribeFromStateChange(resultCallback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
+  func state() throws -> BLEState
+  func subscribeToStateChange(stateCallback: @escaping (_ state: BLEState) -> Void) throws -> OperationResult
+  func unsubscribeFromStateChange() throws -> OperationResult
   func openSettings() throws -> Promise<Void>
 }
 

package/nitrogen/generated/ios/swift/HybridNativeBleNitroSpec_cxx.swift

@@ -126,56 +126,44 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func stopScan(callback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
+  public final func stopScan() -> bridge.Result_bool_ {
     do {
-      try self.__implementation.stopScan(callback: { () -> (Bool, String) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool_std__string(callback)
-        return { (__success: Bool, __error: String) -> Void in
-          __wrappedFunction.call(__success, std.string(__error))
-        }
-      }())
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.stopScan()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_bool_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func isScanning(callback: bridge.Func_void_bool) -> bridge.Result_void_ {
+  public final func isScanning() -> bridge.Result_bool_ {
     do {
-      try self.__implementation.isScanning(callback: { () -> (Bool) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool(callback)
-        return { (__result: Bool) -> Void in
-          __wrappedFunction.call(__result)
-        }
-      }())
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.isScanning()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_bool_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func getConnectedDevices(callback: bridge.Func_void_std__vector_BLEDevice_) -> bridge.Result_void_ {
+  public final func getConnectedDevices(services: bridge.std__vector_std__string_) -> bridge.Result_std__vector_BLEDevice__ {
     do {
-      try self.__implementation.getConnectedDevices(callback: { () -> ([BLEDevice]) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_std__vector_BLEDevice_(callback)
-        return { (__devices: [BLEDevice]) -> Void in
-          __wrappedFunction.call({ () -> bridge.std__vector_BLEDevice_ in
-            var __vector = bridge.create_std__vector_BLEDevice_(__devices.count)
-            for __item in __devices {
-              __vector.push_back(__item)
-            }
-            return __vector
-          }())
+      let __result = try self.__implementation.getConnectedDevices(services: services.map({ __item in String(__item) }))
+      let __resultCpp = { () -> bridge.std__vector_BLEDevice_ in
+        var __vector = bridge.create_std__vector_BLEDevice_(__result.count)
+        for __item in __result {
+          __vector.push_back(__item)
         }
-      }())
-      return bridge.create_Result_void_()
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_BLEDevice__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__vector_BLEDevice__(__exceptionPtr)
     }
   }
   
@@ -223,18 +211,14 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func isConnected(deviceId: std.string, callback: bridge.Func_void_bool) -> bridge.Result_void_ {
+  public final func isConnected(deviceId: std.string) -> bridge.Result_bool_ {
     do {
-      try self.__implementation.isConnected(deviceId: String(deviceId), callback: { () -> (Bool) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool(callback)
-        return { (__result: Bool) -> Void in
-          __wrappedFunction.call(__result)
-        }
-      }())
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.isConnected(deviceId: String(deviceId))
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_bool_(__exceptionPtr)
     }
   }
   
@@ -255,46 +239,38 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func getServices(deviceId: std.string, callback: bridge.Func_void_std__vector_std__string_) -> bridge.Result_void_ {
+  public final func getServices(deviceId: std.string) -> bridge.Result_std__vector_std__string__ {
     do {
-      try self.__implementation.getServices(deviceId: String(deviceId), callback: { () -> ([String]) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_std__vector_std__string_(callback)
-        return { (__result: [String]) -> Void in
-          __wrappedFunction.call({ () -> bridge.std__vector_std__string_ in
-            var __vector = bridge.create_std__vector_std__string_(__result.count)
-            for __item in __result {
-              __vector.push_back(std.string(__item))
-            }
-            return __vector
-          }())
+      let __result = try self.__implementation.getServices(deviceId: String(deviceId))
+      let __resultCpp = { () -> bridge.std__vector_std__string_ in
+        var __vector = bridge.create_std__vector_std__string_(__result.count)
+        for __item in __result {
+          __vector.push_back(std.string(__item))
         }
-      }())
-      return bridge.create_Result_void_()
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_std__string__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__vector_std__string__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func getCharacteristics(deviceId: std.string, serviceId: std.string, callback: bridge.Func_void_std__vector_std__string_) -> bridge.Result_void_ {
+  public final func getCharacteristics(deviceId: std.string, serviceId: std.string) -> bridge.Result_std__vector_std__string__ {
     do {
-      try self.__implementation.getCharacteristics(deviceId: String(deviceId), serviceId: String(serviceId), callback: { () -> ([String]) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_std__vector_std__string_(callback)
-        return { (__result: [String]) -> Void in
-          __wrappedFunction.call({ () -> bridge.std__vector_std__string_ in
-            var __vector = bridge.create_std__vector_std__string_(__result.count)
-            for __item in __result {
-              __vector.push_back(std.string(__item))
-            }
-            return __vector
-          }())
+      let __result = try self.__implementation.getCharacteristics(deviceId: String(deviceId), serviceId: String(serviceId))
+      let __resultCpp = { () -> bridge.std__vector_std__string_ in
+        var __vector = bridge.create_std__vector_std__string_(__result.count)
+        for __item in __result {
+          __vector.push_back(std.string(__item))
         }
-      }())
-      return bridge.create_Result_void_()
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_std__string__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__vector_std__string__(__exceptionPtr)
     }
   }
   
@@ -379,22 +355,6 @@ open class HybridNativeBleNitroSpec_cxx {
     }
   }
   
-  @inline(__always)
-  public final func isBluetoothEnabled(callback: bridge.Func_void_bool) -> bridge.Result_void_ {
-    do {
-      try self.__implementation.isBluetoothEnabled(callback: { () -> (Bool) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool(callback)
-        return { (__result: Bool) -> Void in
-          __wrappedFunction.call(__result)
-        }
-      }())
-      return bridge.create_Result_void_()
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
-    }
-  }
-  
   @inline(__always)
   public final func requestBluetoothEnable(callback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
     do {
@@ -412,55 +372,43 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func state(callback: bridge.Func_void_BLEState) -> bridge.Result_void_ {
+  public final func state() -> bridge.Result_BLEState_ {
     do {
-      try self.__implementation.state(callback: { () -> (BLEState) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_BLEState(callback)
-        return { (__state: BLEState) -> Void in
-          __wrappedFunction.call(__state.rawValue)
-        }
-      }())
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.state()
+      let __resultCpp = __result
+      return bridge.create_Result_BLEState_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_BLEState_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func subscribeToStateChange(stateCallback: bridge.Func_void_BLEState, resultCallback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
+  public final func subscribeToStateChange(stateCallback: bridge.Func_void_BLEState) -> bridge.Result_OperationResult_ {
     do {
-      try self.__implementation.subscribeToStateChange(stateCallback: { () -> (BLEState) -> Void in
+      let __result = try self.__implementation.subscribeToStateChange(stateCallback: { () -> (BLEState) -> Void in
         let __wrappedFunction = bridge.wrap_Func_void_BLEState(stateCallback)
         return { (__state: BLEState) -> Void in
           __wrappedFunction.call(__state.rawValue)
         }
-      }(), resultCallback: { () -> (Bool, String) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool_std__string(resultCallback)
-        return { (__success: Bool, __error: String) -> Void in
-          __wrappedFunction.call(__success, std.string(__error))
-        }
       }())
-      return bridge.create_Result_void_()
+      let __resultCpp = __result
+      return bridge.create_Result_OperationResult_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_OperationResult_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func unsubscribeFromStateChange(resultCallback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
+  public final func unsubscribeFromStateChange() -> bridge.Result_OperationResult_ {
     do {
-      try self.__implementation.unsubscribeFromStateChange(resultCallback: { () -> (Bool, String) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool_std__string(resultCallback)
-        return { (__success: Bool, __error: String) -> Void in
-          __wrappedFunction.call(__success, std.string(__error))
-        }
-      }())
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.unsubscribeFromStateChange()
+      let __resultCpp = __result
+      return bridge.create_Result_OperationResult_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_OperationResult_(__exceptionPtr)
     }
   }
   

package/nitrogen/generated/ios/swift/OperationResult.swift

@@ -0,0 +1,64 @@
+///
+/// OperationResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `OperationResult`, backed by a C++ struct.
+ */
+public typealias OperationResult = margelo.nitro.co.zyke.ble.OperationResult
+
+public extension OperationResult {
+  private typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
+
+  /**
+   * Create a new instance of `OperationResult`.
+   */
+  init(success: Bool, error: String?) {
+    self.init(success, { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = error {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var success: Bool {
+    @inline(__always)
+    get {
+      return self.__success
+    }
+    @inline(__always)
+    set {
+      self.__success = newValue
+    }
+  }
+  
+  var error: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if let __unwrapped = self.__error.value {
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__error = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

package/nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.cpp

@@ -28,7 +28,6 @@ namespace margelo::nitro::co::zyke::ble {
       prototype.registerHybridMethod("writeCharacteristic", &HybridNativeBleNitroSpec::writeCharacteristic);
       prototype.registerHybridMethod("subscribeToCharacteristic", &HybridNativeBleNitroSpec::subscribeToCharacteristic);
       prototype.registerHybridMethod("unsubscribeFromCharacteristic", &HybridNativeBleNitroSpec::unsubscribeFromCharacteristic);
-      prototype.registerHybridMethod("isBluetoothEnabled", &HybridNativeBleNitroSpec::isBluetoothEnabled);
       prototype.registerHybridMethod("requestBluetoothEnable", &HybridNativeBleNitroSpec::requestBluetoothEnable);
       prototype.registerHybridMethod("state", &HybridNativeBleNitroSpec::state);
       prototype.registerHybridMethod("subscribeToStateChange", &HybridNativeBleNitroSpec::subscribeToStateChange);

package/nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.hpp

@@ -19,14 +19,17 @@ namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
 // Forward declaration of `BLEState` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
+// Forward declaration of `OperationResult` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 
 #include "ScanFilter.hpp"
 #include "BLEDevice.hpp"
 #include <functional>
-#include <string>
 #include <vector>
+#include <string>
 #include <optional>
 #include "BLEState.hpp"
+#include "OperationResult.hpp"
 #include <NitroModules/Promise.hpp>
 
 namespace margelo::nitro::co::zyke::ble {
@@ -61,24 +64,23 @@ namespace margelo::nitro::co::zyke::ble {
     public:
       // Methods
       virtual void startScan(const ScanFilter& filter, const std::function<void(const BLEDevice& /* device */)>& callback) = 0;
-      virtual void stopScan(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
-      virtual void isScanning(const std::function<void(bool /* result */)>& callback) = 0;
-      virtual void getConnectedDevices(const std::function<void(const std::vector<BLEDevice>& /* devices */)>& callback) = 0;
+      virtual bool stopScan() = 0;
+      virtual bool isScanning() = 0;
+      virtual std::vector<BLEDevice> getConnectedDevices(const std::vector<std::string>& services) = 0;
       virtual void connect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>& callback, const std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>& disconnectCallback) = 0;
       virtual void disconnect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
-      virtual void isConnected(const std::string& deviceId, const std::function<void(bool /* result */)>& callback) = 0;
+      virtual bool isConnected(const std::string& deviceId) = 0;
       virtual void discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
-      virtual void getServices(const std::string& deviceId, const std::function<void(const std::vector<std::string>& /* result */)>& callback) = 0;
-      virtual void getCharacteristics(const std::string& deviceId, const std::string& serviceId, const std::function<void(const std::vector<std::string>& /* result */)>& callback) = 0;
+      virtual std::vector<std::string> getServices(const std::string& deviceId) = 0;
+      virtual std::vector<std::string> getCharacteristics(const std::string& deviceId, const std::string& serviceId) = 0;
       virtual void readCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>& callback) = 0;
       virtual void writeCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::vector<double>& data, bool withResponse, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
       virtual void subscribeToCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(const std::string& /* characteristicId */, const std::vector<double>& /* data */)>& updateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) = 0;
       virtual void unsubscribeFromCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
-      virtual void isBluetoothEnabled(const std::function<void(bool /* result */)>& callback) = 0;
       virtual void requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
-      virtual void state(const std::function<void(BLEState /* state */)>& callback) = 0;
-      virtual void subscribeToStateChange(const std::function<void(BLEState /* state */)>& stateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) = 0;
-      virtual void unsubscribeFromStateChange(const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) = 0;
+      virtual BLEState state() = 0;
+      virtual OperationResult subscribeToStateChange(const std::function<void(BLEState /* state */)>& stateCallback) = 0;
+      virtual OperationResult unsubscribeFromStateChange() = 0;
       virtual std::shared_ptr<Promise<void>> openSettings() = 0;
 
     protected:

package/nitrogen/generated/shared/c++/OperationResult.hpp

@@ -0,0 +1,72 @@
+///
+/// OperationResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  /**
+   * A struct which can be represented as a JavaScript object (OperationResult).
+   */
+  struct OperationResult {
+  public:
+    bool success     SWIFT_PRIVATE;
+    std::optional<std::string> error     SWIFT_PRIVATE;
+
+  public:
+    OperationResult() = default;
+    explicit OperationResult(bool success, std::optional<std::string> error): success(success), error(error) {}
+  };
+
+} // namespace margelo::nitro::co::zyke::ble
+
+namespace margelo::nitro {
+
+  // C++ OperationResult <> JS OperationResult (object)
+  template <>
+  struct JSIConverter<margelo::nitro::co::zyke::ble::OperationResult> final {
+    static inline margelo::nitro::co::zyke::ble::OperationResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::co::zyke::ble::OperationResult(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "success")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "error"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::co::zyke::ble::OperationResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "success", JSIConverter<bool>::toJSI(runtime, arg.success));
+      obj.setProperty(runtime, "error", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.error));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "success"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "error"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "High-performance React Native BLE library built on Nitro Modules",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/__tests__/index.test.ts

@@ -51,20 +51,19 @@ describe('BleNitro', () => {
     );
   });
 
-  test('stopScan calls native and resolves', async () => {
-    mockNative.stopScan.mockImplementation((callback) => {
-      callback(true, '');
+  test('stopScan calls native and resolves', () => {
+    mockNative.stopScan.mockImplementation(() => {
+      // stopScan is void, no callback needed
     });
 
-    const result = await BleNitro.stopScan();
+    BleNitro.stopScan();
     
     expect(mockNative.stopScan).toHaveBeenCalled();
-    expect(result).toBe(true);
   });
 
   test('connect calls native and resolves with device id', async () => {
     const deviceId = 'test-device';
-    mockNative.connect.mockImplementation((id, callback, disconnectCallback) => {
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
       callback(true, id, '');
     });
 
@@ -75,21 +74,19 @@ describe('BleNitro', () => {
   });
 
   test('connect rejects on error', async () => {
-    mockNative.connect.mockImplementation((id, callback, disconnectCallback) => {
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
       callback(false, '', 'Connection failed');
     });
 
     await expect(BleNitro.connect('test')).rejects.toThrow('Connection failed');
   });
 
-  test('isBluetoothEnabled calls native', async () => {
-    mockNative.isBluetoothEnabled.mockImplementation((callback) => {
-      callback(true);
-    });
+  test('isBluetoothEnabled calls native', () => {
+    mockNative.state.mockReturnValue(5); // PoweredOn
 
-    const result = await BleNitro.isBluetoothEnabled();
+    const result = BleNitro.isBluetoothEnabled();
     
-    expect(mockNative.isBluetoothEnabled).toHaveBeenCalled();
+    expect(mockNative.state).toHaveBeenCalled();
     expect(result).toBe(true);
   });
 
@@ -101,13 +98,13 @@ describe('BleNitro', () => {
 
   test('readCharacteristic works after connection', async () => {
     // First connect
-    mockNative.connect.mockImplementation((id, callback, disconnectCallback) => {
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
       callback(true, id, '');
     });
     await BleNitro.connect('device');
 
     // Then read
-    mockNative.readCharacteristic.mockImplementation((device, service, char, callback) => {
+    mockNative.readCharacteristic.mockImplementation((_device: string, _service: string, _char: string, callback: (success: boolean, data: number[], error: string) => void) => {
       callback(true, [85], ''); // Battery level 85%
     });
 
@@ -125,38 +122,38 @@ describe('BleNitro', () => {
 
   test('disconnect calls native', async () => {
     // First connect
-    mockNative.connect.mockImplementation((id, callback, disconnectCallback) => {
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
       callback(true, id, '');
     });
     await BleNitro.connect('device');
 
     // Then disconnect
-    mockNative.disconnect.mockImplementation((id, callback) => {
+    mockNative.disconnect.mockImplementation((_id: string, callback: (success: boolean, error: string) => void) => {
       callback(true, '');
     });
 
     const result = await BleNitro.disconnect('device');
     
     expect(mockNative.disconnect).toHaveBeenCalledWith('device', expect.any(Function));
-    expect(result).toBe(true);
+    expect(result).toBe(undefined);
   });
 
   test('subscribeToCharacteristic calls callback', async () => {
     // First connect
-    mockNative.connect.mockImplementation((id, callback, disconnectCallback) => {
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
       callback(true, id, '');
     });
     await BleNitro.connect('device');
 
     // Mock subscription
-    mockNative.subscribeToCharacteristic.mockImplementation((device, service, char, updateCallback, resultCallback) => {
+    mockNative.subscribeToCharacteristic.mockImplementation((_device: string, _service: string, _char: string, updateCallback: (charId: string, data: number[]) => void, resultCallback: (success: boolean, error: string) => void) => {
       resultCallback(true, '');
       // Simulate notification
       updateCallback('char-id', [1, 2, 3]);
     });
 
     const notificationCallback = jest.fn();
-    await BleNitro.subscribeToCharacteristic('device', 'service', 'char', notificationCallback);
+    BleNitro.subscribeToCharacteristic('device', 'service', 'char', notificationCallback);
     
     expect(mockNative.subscribeToCharacteristic).toHaveBeenCalled();
     expect(notificationCallback).toHaveBeenCalledWith('char-id', [1, 2, 3]);
@@ -166,7 +163,7 @@ describe('BleNitro', () => {
     const deviceId = 'test-device-2'; // Use different device ID to avoid state conflicts
     const onDisconnect = jest.fn();
     
-    mockNative.connect.mockImplementation((id, callback, disconnectCallback) => {
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
       callback(true, id, '');
       // Simulate a disconnect event later  
       if (disconnectCallback) {