react-native-ble-nitro 1.0.0-beta.8 → 1.0.0

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

@@ -8,86 +8,26 @@
 #pragma once
 
 // Forward declarations of C++ defined types
-// Forward declaration of `BleATTErrorCode` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class BleATTErrorCode; }
-// Forward declaration of `BleAndroidErrorCode` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class BleAndroidErrorCode; }
-// Forward declaration of `BleErrorCode` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class BleErrorCode; }
-// Forward declaration of `BleIOSErrorCode` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class BleIOSErrorCode; }
-// Forward declaration of `BleManagerNitroOptions` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct BleManagerNitroOptions; }
-// Forward declaration of `BleRestoredState` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct BleRestoredState; }
-// Forward declaration of `CharacteristicSubscriptionType` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class CharacteristicSubscriptionType; }
-// Forward declaration of `ConnectionOptions` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct ConnectionOptions; }
-// Forward declaration of `ConnectionPriority` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class ConnectionPriority; }
-// Forward declaration of `HybridBleManagerSpec` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { class HybridBleManagerSpec; }
-// Forward declaration of `HybridCharacteristicSpec` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { class HybridCharacteristicSpec; }
-// Forward declaration of `HybridDescriptorSpec` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { class HybridDescriptorSpec; }
-// Forward declaration of `HybridDeviceSpec` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { class HybridDeviceSpec; }
-// Forward declaration of `HybridServiceSpec` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { class HybridServiceSpec; }
-// Forward declaration of `LogLevel` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class LogLevel; }
-// Forward declaration of `NativeBleError` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct NativeBleError; }
-// Forward declaration of `NativeCharacteristic` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct NativeCharacteristic; }
-// Forward declaration of `NativeDescriptor` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct NativeDescriptor; }
-// Forward declaration of `NativeDevice` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct NativeDevice; }
-// Forward declaration of `NativeService` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct NativeService; }
-// Forward declaration of `ScanCallbackType` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class ScanCallbackType; }
-// Forward declaration of `ScanMode` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class ScanMode; }
-// Forward declaration of `ScanOptions` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct ScanOptions; }
-// Forward declaration of `ServiceDataEntry` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct ServiceDataEntry; }
-// Forward declaration of `State` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class State; }
-// Forward declaration of `Subscription` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct Subscription; }
+// Forward declaration of `BLEDevice` to properly resolve imports.
+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 `HybridNativeBleNitroSpec` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { class HybridNativeBleNitroSpec; }
+// Forward declaration of `ManufacturerDataEntry` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ManufacturerDataEntry; }
+// Forward declaration of `ManufacturerData` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ManufacturerData; }
+// Forward declaration of `ScanFilter` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 
 // Include C++ defined types
-#include "BleATTErrorCode.hpp"
-#include "BleAndroidErrorCode.hpp"
-#include "BleErrorCode.hpp"
-#include "BleIOSErrorCode.hpp"
-#include "BleManagerNitroOptions.hpp"
-#include "BleRestoredState.hpp"
-#include "CharacteristicSubscriptionType.hpp"
-#include "ConnectionOptions.hpp"
-#include "ConnectionPriority.hpp"
-#include "HybridBleManagerSpec.hpp"
-#include "HybridCharacteristicSpec.hpp"
-#include "HybridDescriptorSpec.hpp"
-#include "HybridDeviceSpec.hpp"
-#include "HybridServiceSpec.hpp"
-#include "LogLevel.hpp"
-#include "NativeBleError.hpp"
-#include "NativeCharacteristic.hpp"
-#include "NativeDescriptor.hpp"
-#include "NativeDevice.hpp"
-#include "NativeService.hpp"
-#include "ScanCallbackType.hpp"
-#include "ScanMode.hpp"
-#include "ScanOptions.hpp"
-#include "ServiceDataEntry.hpp"
-#include "State.hpp"
-#include "Subscription.hpp"
+#include "BLEDevice.hpp"
+#include "BLEState.hpp"
+#include "HybridNativeBleNitroSpec.hpp"
+#include "ManufacturerData.hpp"
+#include "ManufacturerDataEntry.hpp"
+#include "ScanFilter.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
@@ -107,16 +47,8 @@ namespace margelo::nitro::co::zyke::ble { struct Subscription; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridBleManagerSpec_cxx` to properly resolve imports.
-namespace BleNitro { class HybridBleManagerSpec_cxx; }
-// Forward declaration of `HybridCharacteristicSpec_cxx` to properly resolve imports.
-namespace BleNitro { class HybridCharacteristicSpec_cxx; }
-// Forward declaration of `HybridDescriptorSpec_cxx` to properly resolve imports.
-namespace BleNitro { class HybridDescriptorSpec_cxx; }
-// Forward declaration of `HybridDeviceSpec_cxx` to properly resolve imports.
-namespace BleNitro { class HybridDeviceSpec_cxx; }
-// Forward declaration of `HybridServiceSpec_cxx` to properly resolve imports.
-namespace BleNitro { class HybridServiceSpec_cxx; }
+// Forward declaration of `HybridNativeBleNitroSpec_cxx` to properly resolve imports.
+namespace BleNitro { class HybridNativeBleNitroSpec_cxx; }
 
 // Include Swift defined types
 #if __has_include("BleNitro-Swift.h")

package/nitrogen/generated/ios/BleNitroAutolinking.mm

@@ -10,7 +10,7 @@
 #import "BleNitro-Swift-Cxx-Umbrella.hpp"
 #import <type_traits>
 
-#include "HybridBleManagerSpecSwift.hpp"
+#include "HybridNativeBleNitroSpecSwift.hpp"
 
 @interface BleNitroAutolinking : NSObject
 @end
@@ -22,9 +22,9 @@
   using namespace margelo::nitro::co::zyke::ble;
 
   HybridObjectRegistry::registerHybridObjectConstructor(
-    "BleManager",
+    "NativeBleNitro",
     []() -> std::shared_ptr<HybridObject> {
-      std::shared_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpec> hybridObject = BleNitro::BleNitroAutolinking::createBleManager();
+      std::shared_ptr<HybridNativeBleNitroSpec> hybridObject = BleNitro::BleNitroAutolinking::createNativeBleNitro();
       return hybridObject;
     }
   );

package/nitrogen/generated/ios/BleNitroAutolinking.swift

@@ -9,15 +9,15 @@ public final class BleNitroAutolinking {
   public typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
 
   /**
-   * Creates an instance of a Swift class that implements `HybridBleManagerSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridBleManagerSpec_cxx`)
+   * Creates an instance of a Swift class that implements `HybridNativeBleNitroSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridNativeBleNitroSpec_cxx`)
    *
    * This is generated by Nitrogen and will initialize the class specified
    * in the `"autolinking"` property of `nitro.json` (in this case, `BleNitroBleManager`).
    */
-  public static func createBleManager() -> bridge.std__shared_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_ {
+  public static func createNativeBleNitro() -> bridge.std__shared_ptr_HybridNativeBleNitroSpec_ {
     let hybridObject = BleNitroBleManager()
-    return { () -> bridge.std__shared_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_ in
+    return { () -> bridge.std__shared_ptr_HybridNativeBleNitroSpec_ in
       let __cxxWrapped = hybridObject.getCxxWrapper()
       return __cxxWrapped.getCxxPart()
     }()

package/nitrogen/generated/ios/c++/{HybridCharacteristicSpecSwift.cpp → HybridNativeBleNitroSpecSwift.cpp}

@@ -1,11 +1,11 @@
 ///
-/// HybridCharacteristicSpecSwift.cpp
+/// HybridNativeBleNitroSpecSwift.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
-#include "HybridCharacteristicSpecSwift.hpp"
+#include "HybridNativeBleNitroSpecSwift.hpp"
 
 namespace margelo::nitro::co::zyke::ble {
 } // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,205 @@
+///
+/// HybridNativeBleNitroSpecSwift.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 "HybridNativeBleNitroSpec.hpp"
+
+// Forward declaration of `HybridNativeBleNitroSpec_cxx` to properly resolve imports.
+namespace BleNitro { class HybridNativeBleNitroSpec_cxx; }
+
+// Forward declaration of `ScanFilter` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
+// Forward declaration of `BLEDevice` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
+// Forward declaration of `ManufacturerData` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ManufacturerData; }
+// Forward declaration of `ManufacturerDataEntry` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ManufacturerDataEntry; }
+// Forward declaration of `BLEState` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
+
+#include "ScanFilter.hpp"
+#include <string>
+#include <vector>
+#include "BLEDevice.hpp"
+#include <functional>
+#include "ManufacturerData.hpp"
+#include "ManufacturerDataEntry.hpp"
+#include <optional>
+#include "BLEState.hpp"
+#include <NitroModules/Promise.hpp>
+
+#include "BleNitro-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  /**
+   * The C++ part of HybridNativeBleNitroSpec_cxx.swift.
+   *
+   * HybridNativeBleNitroSpecSwift (C++) accesses HybridNativeBleNitroSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridNativeBleNitroSpec_cxx can directly inherit from the C++ class HybridNativeBleNitroSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNativeBleNitroSpecSwift: public virtual HybridNativeBleNitroSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNativeBleNitroSpecSwift(const BleNitro::HybridNativeBleNitroSpec_cxx& swiftPart):
+      HybridObject(HybridNativeBleNitroSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline BleNitro::HybridNativeBleNitroSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline void startScan(const ScanFilter& filter, const std::function<void(const BLEDevice& /* device */)>& callback) override {
+      auto __result = _swiftPart.startScan(filter, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void stopScan(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override {
+      auto __result = _swiftPart.stopScan(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void isScanning(const std::function<void(bool /* result */)>& callback) override {
+      auto __result = _swiftPart.isScanning(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void getConnectedDevices(const std::function<void(const std::vector<BLEDevice>& /* devices */)>& callback) override {
+      auto __result = _swiftPart.getConnectedDevices(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline 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) override {
+      auto __result = _swiftPart.connect(deviceId, callback, disconnectCallback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void disconnect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override {
+      auto __result = _swiftPart.disconnect(deviceId, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void isConnected(const std::string& deviceId, const std::function<void(bool /* result */)>& callback) override {
+      auto __result = _swiftPart.isConnected(deviceId, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override {
+      auto __result = _swiftPart.discoverServices(deviceId, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void getServices(const std::string& deviceId, const std::function<void(const std::vector<std::string>& /* result */)>& callback) override {
+      auto __result = _swiftPart.getServices(deviceId, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void getCharacteristics(const std::string& deviceId, const std::string& serviceId, const std::function<void(const std::vector<std::string>& /* result */)>& callback) override {
+      auto __result = _swiftPart.getCharacteristics(deviceId, serviceId, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline 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) override {
+      auto __result = _swiftPart.readCharacteristic(deviceId, serviceId, characteristicId, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline 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) override {
+      auto __result = _swiftPart.writeCharacteristic(deviceId, serviceId, characteristicId, data, std::forward<decltype(withResponse)>(withResponse), callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline 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) override {
+      auto __result = _swiftPart.subscribeToCharacteristic(deviceId, serviceId, characteristicId, updateCallback, resultCallback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline 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) override {
+      auto __result = _swiftPart.unsubscribeFromCharacteristic(deviceId, serviceId, characteristicId, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void isBluetoothEnabled(const std::function<void(bool /* result */)>& callback) override {
+      auto __result = _swiftPart.isBluetoothEnabled(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override {
+      auto __result = _swiftPart.requestBluetoothEnable(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void state(const std::function<void(BLEState /* state */)>& callback) override {
+      auto __result = _swiftPart.state(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void subscribeToStateChange(const std::function<void(BLEState /* state */)>& stateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) override {
+      auto __result = _swiftPart.subscribeToStateChange(stateCallback, resultCallback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void unsubscribeFromStateChange(const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) override {
+      auto __result = _swiftPart.unsubscribeFromStateChange(resultCallback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<void>> openSettings() override {
+      auto __result = _swiftPart.openSettings();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    BleNitro::HybridNativeBleNitroSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/ios/swift/BLEDevice.swift

@@ -0,0 +1,102 @@
+///
+/// BLEDevice.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 `BLEDevice`, backed by a C++ struct.
+ */
+public typealias BLEDevice = margelo.nitro.co.zyke.ble.BLEDevice
+
+public extension BLEDevice {
+  private typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
+
+  /**
+   * Create a new instance of `BLEDevice`.
+   */
+  init(id: String, name: String, rssi: Double, manufacturerData: ManufacturerData, serviceUUIDs: [String], isConnectable: Bool) {
+    self.init(std.string(id), std.string(name), rssi, manufacturerData, { () -> bridge.std__vector_std__string_ in
+      var __vector = bridge.create_std__vector_std__string_(serviceUUIDs.count)
+      for __item in serviceUUIDs {
+        __vector.push_back(std.string(__item))
+      }
+      return __vector
+    }(), isConnectable)
+  }
+
+  var id: String {
+    @inline(__always)
+    get {
+      return String(self.__id)
+    }
+    @inline(__always)
+    set {
+      self.__id = std.string(newValue)
+    }
+  }
+  
+  var name: String {
+    @inline(__always)
+    get {
+      return String(self.__name)
+    }
+    @inline(__always)
+    set {
+      self.__name = std.string(newValue)
+    }
+  }
+  
+  var rssi: Double {
+    @inline(__always)
+    get {
+      return self.__rssi
+    }
+    @inline(__always)
+    set {
+      self.__rssi = newValue
+    }
+  }
+  
+  var manufacturerData: ManufacturerData {
+    @inline(__always)
+    get {
+      return self.__manufacturerData
+    }
+    @inline(__always)
+    set {
+      self.__manufacturerData = newValue
+    }
+  }
+  
+  var serviceUUIDs: [String] {
+    @inline(__always)
+    get {
+      return self.__serviceUUIDs.map({ __item in String(__item) })
+    }
+    @inline(__always)
+    set {
+      self.__serviceUUIDs = { () -> bridge.std__vector_std__string_ in
+        var __vector = bridge.create_std__vector_std__string_(newValue.count)
+        for __item in newValue {
+          __vector.push_back(std.string(__item))
+        }
+        return __vector
+      }()
+    }
+  }
+  
+  var isConnectable: Bool {
+    @inline(__always)
+    get {
+      return self.__isConnectable
+    }
+    @inline(__always)
+    set {
+      self.__isConnectable = newValue
+    }
+  }
+}

package/nitrogen/generated/ios/swift/{State.swift → BLEState.swift}

@@ -1,18 +1,18 @@
 ///
-/// State.swift
+/// BLEState.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 `State`, backed by a C++ enum.
+ * Represents the JS enum `BLEState`, backed by a C++ enum.
  */
-public typealias State = margelo.nitro.co.zyke.ble.State
+public typealias BLEState = margelo.nitro.co.zyke.ble.BLEState
 
-public extension State {
+public extension BLEState {
   /**
-   * Get a State for the given String value, or
+   * Get a BLEState for the given String value, or
    * return `nil` if the given value was invalid/unknown.
    */
   init?(fromString string: String) {
@@ -35,7 +35,7 @@ public extension State {
   }
 
   /**
-   * Get the String value this State represents.
+   * Get the String value this BLEState represents.
    */
   var stringValue: String {
     switch self {

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

@@ -7,6 +7,7 @@
 
 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`.

package/nitrogen/generated/ios/swift/{Func_void_State.swift → Func_void_BLEDevice.swift}

@@ -1,5 +1,5 @@
 ///
-/// Func_void_State.swift
+/// Func_void_BLEDevice.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -7,22 +7,23 @@
 
 import NitroModules
 
+
 /**
- * Wraps a Swift `(_ newState: State) -> Void` as a class.
+ * Wraps a Swift `(_ device: BLEDevice) -> 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_State {
+public final class Func_void_BLEDevice {
   public typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
 
-  private let closure: (_ newState: State) -> Void
+  private let closure: (_ device: BLEDevice) -> Void
 
-  public init(_ closure: @escaping (_ newState: State) -> Void) {
+  public init(_ closure: @escaping (_ device: BLEDevice) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(newState: Int32) -> Void {
-    self.closure(margelo.nitro.co.zyke.ble.State(rawValue: newState)!)
+  public func call(device: BLEDevice) -> Void {
+    self.closure(device)
   }
 
   /**
@@ -35,12 +36,12 @@ public final class Func_void_State {
   }
 
   /**
-   * Casts an unsafe pointer to a `Func_void_State`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_void_State>`.
+   * Casts an unsafe pointer to a `Func_void_BLEDevice`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_BLEDevice>`.
    * This removes one strong reference from the object!
    */
   @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_State {
-    return Unmanaged<Func_void_State>.fromOpaque(pointer).takeRetainedValue()
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_BLEDevice {
+    return Unmanaged<Func_void_BLEDevice>.fromOpaque(pointer).takeRetainedValue()
   }
 }

package/nitrogen/generated/ios/swift/{Func_void_LogLevel.swift → Func_void_BLEState.swift}

@@ -1,5 +1,5 @@
 ///
-/// Func_void_LogLevel.swift
+/// Func_void_BLEState.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -7,22 +7,23 @@
 
 import NitroModules
 
+
 /**
- * Wraps a Swift `(_ value: LogLevel) -> Void` as a class.
+ * Wraps a Swift `(_ state: BLEState) -> 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_LogLevel {
+public final class Func_void_BLEState {
   public typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
 
-  private let closure: (_ value: LogLevel) -> Void
+  private let closure: (_ state: BLEState) -> Void
 
-  public init(_ closure: @escaping (_ value: LogLevel) -> Void) {
+  public init(_ closure: @escaping (_ state: BLEState) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(value: Int32) -> Void {
-    self.closure(margelo.nitro.co.zyke.ble.LogLevel(rawValue: value)!)
+  public func call(state: Int32) -> Void {
+    self.closure(margelo.nitro.co.zyke.ble.BLEState(rawValue: state)!)
   }
 
   /**
@@ -35,12 +36,12 @@ public final class Func_void_LogLevel {
   }
 
   /**
-   * Casts an unsafe pointer to a `Func_void_LogLevel`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_void_LogLevel>`.
+   * Casts an unsafe pointer to a `Func_void_BLEState`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_BLEState>`.
    * This removes one strong reference from the object!
    */
   @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_LogLevel {
-    return Unmanaged<Func_void_LogLevel>.fromOpaque(pointer).takeRetainedValue()
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_BLEState {
+    return Unmanaged<Func_void_BLEState>.fromOpaque(pointer).takeRetainedValue()
   }
 }

package/nitrogen/generated/ios/swift/Func_void_bool.swift

@@ -7,22 +7,23 @@
 
 import NitroModules
 
+
 /**
- * Wraps a Swift `(_ value: Bool) -> Void` as a class.
+ * Wraps a Swift `(_ result: Bool) -> 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_bool {
   public typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
 
-  private let closure: (_ value: Bool) -> Void
+  private let closure: (_ result: Bool) -> Void
 
-  public init(_ closure: @escaping (_ value: Bool) -> Void) {
+  public init(_ closure: @escaping (_ result: Bool) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(value: Bool) -> Void {
-    self.closure(value)
+  public func call(result: Bool) -> Void {
+    self.closure(result)
   }
 
   /**