react-native-ble-nitro 1.0.0-beta.5 → 1.0.0-beta.7

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

@@ -0,0 +1,77 @@
+///
+/// ConnectionOptions.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
+
+
+
+
+
+namespace margelo::nitro::co::zyke::ble {
+
+  /**
+   * A struct which can be represented as a JavaScript object (ConnectionOptions).
+   */
+  struct ConnectionOptions {
+  public:
+    bool autoConnect     SWIFT_PRIVATE;
+    double requestMTU     SWIFT_PRIVATE;
+    double timeout     SWIFT_PRIVATE;
+
+  public:
+    ConnectionOptions() = default;
+    explicit ConnectionOptions(bool autoConnect, double requestMTU, double timeout): autoConnect(autoConnect), requestMTU(requestMTU), timeout(timeout) {}
+  };
+
+} // namespace margelo::nitro::co::zyke::ble
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::co::zyke::ble;
+
+  // C++ ConnectionOptions <> JS ConnectionOptions (object)
+  template <>
+  struct JSIConverter<ConnectionOptions> final {
+    static inline ConnectionOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return ConnectionOptions(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "autoConnect")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "requestMTU")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "timeout"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const ConnectionOptions& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "autoConnect", JSIConverter<bool>::toJSI(runtime, arg.autoConnect));
+      obj.setProperty(runtime, "requestMTU", JSIConverter<double>::toJSI(runtime, arg.requestMTU));
+      obj.setProperty(runtime, "timeout", JSIConverter<double>::toJSI(runtime, arg.timeout));
+      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, "autoConnect"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "requestMTU"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "timeout"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,65 @@
+///
+/// ConnectionPriority.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 <cmath>
+#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
+
+namespace margelo::nitro::co::zyke::ble {
+
+  /**
+   * An enum which can be represented as a JavaScript enum (ConnectionPriority).
+   */
+  enum class ConnectionPriority {
+    BALANCED      SWIFT_NAME(balanced) = 0,
+    HIGH      SWIFT_NAME(high) = 1,
+    LOWPOWER      SWIFT_NAME(lowpower) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::co::zyke::ble
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::co::zyke::ble;
+
+  // C++ ConnectionPriority <> JS ConnectionPriority (enum)
+  template <>
+  struct JSIConverter<ConnectionPriority> final {
+    static inline ConnectionPriority fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<ConnectionPriority>(enumValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, ConnectionPriority arg) {
+      int enumValue = static_cast<int>(arg);
+      return JSIConverter<int>::toJSI(runtime, enumValue);
+    }
+    static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+      if (!value.isNumber()) {
+        return false;
+      }
+      double integer;
+      double fraction = modf(value.getNumber(), &integer);
+      if (fraction != 0.0) {
+        // It is some kind of floating point number - our enums are ints.
+        return false;
+      }
+      // Check if we are within the bounds of the enum.
+      return integer >= 0 && integer <= 2;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,51 @@
+///
+/// HybridBleManagerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridBleManagerSpec.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  void HybridBleManagerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("destroy", &HybridBleManagerSpec::destroy);
+      prototype.registerHybridMethod("initialize", &HybridBleManagerSpec::initialize);
+      prototype.registerHybridMethod("getRestoredState", &HybridBleManagerSpec::getRestoredState);
+      prototype.registerHybridMethod("setLogLevel", &HybridBleManagerSpec::setLogLevel);
+      prototype.registerHybridMethod("logLevel", &HybridBleManagerSpec::logLevel);
+      prototype.registerHybridMethod("cancelTransaction", &HybridBleManagerSpec::cancelTransaction);
+      prototype.registerHybridMethod("enable", &HybridBleManagerSpec::enable);
+      prototype.registerHybridMethod("disable", &HybridBleManagerSpec::disable);
+      prototype.registerHybridMethod("state", &HybridBleManagerSpec::state);
+      prototype.registerHybridMethod("onStateChange", &HybridBleManagerSpec::onStateChange);
+      prototype.registerHybridMethod("startDeviceScan", &HybridBleManagerSpec::startDeviceScan);
+      prototype.registerHybridMethod("stopDeviceScan", &HybridBleManagerSpec::stopDeviceScan);
+      prototype.registerHybridMethod("requestConnectionPriorityForDevice", &HybridBleManagerSpec::requestConnectionPriorityForDevice);
+      prototype.registerHybridMethod("readRSSIForDevice", &HybridBleManagerSpec::readRSSIForDevice);
+      prototype.registerHybridMethod("requestMTUForDevice", &HybridBleManagerSpec::requestMTUForDevice);
+      prototype.registerHybridMethod("devices", &HybridBleManagerSpec::devices);
+      prototype.registerHybridMethod("connectedDevices", &HybridBleManagerSpec::connectedDevices);
+      prototype.registerHybridMethod("connectToDevice", &HybridBleManagerSpec::connectToDevice);
+      prototype.registerHybridMethod("cancelDeviceConnection", &HybridBleManagerSpec::cancelDeviceConnection);
+      prototype.registerHybridMethod("onDeviceDisconnected", &HybridBleManagerSpec::onDeviceDisconnected);
+      prototype.registerHybridMethod("isDeviceConnected", &HybridBleManagerSpec::isDeviceConnected);
+      prototype.registerHybridMethod("discoverAllServicesAndCharacteristicsForDevice", &HybridBleManagerSpec::discoverAllServicesAndCharacteristicsForDevice);
+      prototype.registerHybridMethod("servicesForDevice", &HybridBleManagerSpec::servicesForDevice);
+      prototype.registerHybridMethod("characteristicsForDevice", &HybridBleManagerSpec::characteristicsForDevice);
+      prototype.registerHybridMethod("readCharacteristicForDevice", &HybridBleManagerSpec::readCharacteristicForDevice);
+      prototype.registerHybridMethod("writeCharacteristicWithResponseForDevice", &HybridBleManagerSpec::writeCharacteristicWithResponseForDevice);
+      prototype.registerHybridMethod("writeCharacteristicWithoutResponseForDevice", &HybridBleManagerSpec::writeCharacteristicWithoutResponseForDevice);
+      prototype.registerHybridMethod("monitorCharacteristicForDevice", &HybridBleManagerSpec::monitorCharacteristicForDevice);
+      prototype.registerHybridMethod("descriptorsForDevice", &HybridBleManagerSpec::descriptorsForDevice);
+      prototype.registerHybridMethod("readDescriptorForDevice", &HybridBleManagerSpec::readDescriptorForDevice);
+      prototype.registerHybridMethod("writeDescriptorForDevice", &HybridBleManagerSpec::writeDescriptorForDevice);
+    });
+  }
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,137 @@
+///
+/// HybridBleManagerSpec.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/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// 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 `LogLevel` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class LogLevel; }
+// 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 `ScanOptions` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ScanOptions; }
+// Forward declaration of `NativeBleError` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct NativeBleError; }
+// Forward declaration of `NativeDevice` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct NativeDevice; }
+// Forward declaration of `ConnectionPriority` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class ConnectionPriority; }
+// Forward declaration of `ConnectionOptions` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ConnectionOptions; }
+// Forward declaration of `NativeService` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct NativeService; }
+// Forward declaration of `NativeCharacteristic` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct NativeCharacteristic; }
+// Forward declaration of `CharacteristicSubscriptionType` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class CharacteristicSubscriptionType; }
+// Forward declaration of `NativeDescriptor` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct NativeDescriptor; }
+
+#include <NitroModules/Promise.hpp>
+#include "BleManagerNitroOptions.hpp"
+#include <optional>
+#include "BleRestoredState.hpp"
+#include "LogLevel.hpp"
+#include <string>
+#include "State.hpp"
+#include "Subscription.hpp"
+#include <functional>
+#include <vector>
+#include "ScanOptions.hpp"
+#include "NativeBleError.hpp"
+#include "NativeDevice.hpp"
+#include "ConnectionPriority.hpp"
+#include "ConnectionOptions.hpp"
+#include "NativeService.hpp"
+#include "NativeCharacteristic.hpp"
+#include "CharacteristicSubscriptionType.hpp"
+#include "NativeDescriptor.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `BleManager`
+   * Inherit this class to create instances of `HybridBleManagerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridBleManager: public HybridBleManagerSpec {
+   * public:
+   *   HybridBleManager(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridBleManagerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridBleManagerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridBleManagerSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> destroy() = 0;
+      virtual std::shared_ptr<Promise<void>> initialize(const BleManagerNitroOptions& options) = 0;
+      virtual std::shared_ptr<Promise<std::optional<BleRestoredState>>> getRestoredState() = 0;
+      virtual std::shared_ptr<Promise<LogLevel>> setLogLevel(LogLevel logLevel) = 0;
+      virtual std::shared_ptr<Promise<LogLevel>> logLevel() = 0;
+      virtual std::shared_ptr<Promise<void>> cancelTransaction(const std::string& transactionId) = 0;
+      virtual std::shared_ptr<Promise<void>> enable(const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<void>> disable(const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<State>> state() = 0;
+      virtual Subscription onStateChange(const std::function<void(State /* newState */)>& listener, std::optional<bool> emitCurrentState) = 0;
+      virtual std::shared_ptr<Promise<void>> startDeviceScan(const std::optional<std::vector<std::string>>& uuids, const std::optional<ScanOptions>& options, const std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeDevice>& /* scannedDevice */)>& listener) = 0;
+      virtual std::shared_ptr<Promise<void>> stopDeviceScan() = 0;
+      virtual std::shared_ptr<Promise<NativeDevice>> requestConnectionPriorityForDevice(const std::string& deviceIdentifier, ConnectionPriority connectionPriority, const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<NativeDevice>> readRSSIForDevice(const std::string& deviceIdentifier, const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<NativeDevice>> requestMTUForDevice(const std::string& deviceIdentifier, double mtu, const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<std::vector<NativeDevice>>> devices(const std::vector<std::string>& deviceIdentifiers) = 0;
+      virtual std::shared_ptr<Promise<std::vector<NativeDevice>>> connectedDevices(const std::vector<std::string>& serviceUUIDs) = 0;
+      virtual std::shared_ptr<Promise<NativeDevice>> connectToDevice(const std::string& deviceIdentifier, const std::optional<ConnectionOptions>& options) = 0;
+      virtual std::shared_ptr<Promise<NativeDevice>> cancelDeviceConnection(const std::string& deviceIdentifier) = 0;
+      virtual Subscription onDeviceDisconnected(const std::string& deviceIdentifier, const std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeDevice>& /* device */)>& listener) = 0;
+      virtual std::shared_ptr<Promise<bool>> isDeviceConnected(const std::string& deviceIdentifier) = 0;
+      virtual std::shared_ptr<Promise<NativeDevice>> discoverAllServicesAndCharacteristicsForDevice(const std::string& deviceIdentifier, const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<std::vector<NativeService>>> servicesForDevice(const std::string& deviceIdentifier) = 0;
+      virtual std::shared_ptr<Promise<std::vector<NativeCharacteristic>>> characteristicsForDevice(const std::string& deviceIdentifier, const std::string& serviceUUID) = 0;
+      virtual std::shared_ptr<Promise<NativeCharacteristic>> readCharacteristicForDevice(const std::string& deviceIdentifier, const std::string& serviceUUID, const std::string& characteristicUUID, const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<NativeCharacteristic>> writeCharacteristicWithResponseForDevice(const std::string& deviceIdentifier, const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& base64Value, const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<NativeCharacteristic>> writeCharacteristicWithoutResponseForDevice(const std::string& deviceIdentifier, const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& base64Value, const std::optional<std::string>& transactionId) = 0;
+      virtual Subscription monitorCharacteristicForDevice(const std::string& deviceIdentifier, const std::string& serviceUUID, const std::string& characteristicUUID, const std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>& listener, const std::optional<std::string>& transactionId, std::optional<CharacteristicSubscriptionType> subscriptionType) = 0;
+      virtual std::shared_ptr<Promise<std::vector<NativeDescriptor>>> descriptorsForDevice(const std::string& deviceIdentifier, const std::string& serviceUUID, const std::string& characteristicUUID) = 0;
+      virtual std::shared_ptr<Promise<NativeDescriptor>> readDescriptorForDevice(const std::string& deviceIdentifier, const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& descriptorUUID, const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<NativeDescriptor>> writeDescriptorForDevice(const std::string& deviceIdentifier, const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& descriptorUUID, const std::string& valueBase64, const std::optional<std::string>& transactionId) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "BleManager";
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,39 @@
+///
+/// HybridCharacteristicSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCharacteristicSpec.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  void HybridCharacteristicSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("id", &HybridCharacteristicSpec::getId);
+      prototype.registerHybridGetter("uuid", &HybridCharacteristicSpec::getUuid);
+      prototype.registerHybridGetter("serviceID", &HybridCharacteristicSpec::getServiceID);
+      prototype.registerHybridGetter("serviceUUID", &HybridCharacteristicSpec::getServiceUUID);
+      prototype.registerHybridGetter("deviceID", &HybridCharacteristicSpec::getDeviceID);
+      prototype.registerHybridGetter("isReadable", &HybridCharacteristicSpec::getIsReadable);
+      prototype.registerHybridGetter("isWritableWithResponse", &HybridCharacteristicSpec::getIsWritableWithResponse);
+      prototype.registerHybridGetter("isWritableWithoutResponse", &HybridCharacteristicSpec::getIsWritableWithoutResponse);
+      prototype.registerHybridGetter("isNotifiable", &HybridCharacteristicSpec::getIsNotifiable);
+      prototype.registerHybridGetter("isNotifying", &HybridCharacteristicSpec::getIsNotifying);
+      prototype.registerHybridGetter("isIndicatable", &HybridCharacteristicSpec::getIsIndicatable);
+      prototype.registerHybridGetter("value", &HybridCharacteristicSpec::getValue);
+      prototype.registerHybridMethod("read", &HybridCharacteristicSpec::read);
+      prototype.registerHybridMethod("writeWithResponse", &HybridCharacteristicSpec::writeWithResponse);
+      prototype.registerHybridMethod("writeWithoutResponse", &HybridCharacteristicSpec::writeWithoutResponse);
+      prototype.registerHybridMethod("monitor", &HybridCharacteristicSpec::monitor);
+      prototype.registerHybridMethod("descriptors", &HybridCharacteristicSpec::descriptors);
+      prototype.registerHybridMethod("readDescriptor", &HybridCharacteristicSpec::readDescriptor);
+      prototype.registerHybridMethod("writeDescriptor", &HybridCharacteristicSpec::writeDescriptor);
+    });
+  }
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,101 @@
+///
+/// HybridCharacteristicSpec.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/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridCharacteristicSpec` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { class HybridCharacteristicSpec; }
+// Forward declaration of `Subscription` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct Subscription; }
+// 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 `CharacteristicSubscriptionType` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class CharacteristicSubscriptionType; }
+// Forward declaration of `NativeDescriptor` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct NativeDescriptor; }
+
+#include <string>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridCharacteristicSpec.hpp"
+#include "Subscription.hpp"
+#include <functional>
+#include "NativeBleError.hpp"
+#include "NativeCharacteristic.hpp"
+#include "CharacteristicSubscriptionType.hpp"
+#include <vector>
+#include "NativeDescriptor.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Characteristic`
+   * Inherit this class to create instances of `HybridCharacteristicSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCharacteristic: public HybridCharacteristicSpec {
+   * public:
+   *   HybridCharacteristic(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCharacteristicSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCharacteristicSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCharacteristicSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getId() = 0;
+      virtual std::string getUuid() = 0;
+      virtual double getServiceID() = 0;
+      virtual std::string getServiceUUID() = 0;
+      virtual std::string getDeviceID() = 0;
+      virtual bool getIsReadable() = 0;
+      virtual bool getIsWritableWithResponse() = 0;
+      virtual bool getIsWritableWithoutResponse() = 0;
+      virtual bool getIsNotifiable() = 0;
+      virtual bool getIsNotifying() = 0;
+      virtual bool getIsIndicatable() = 0;
+      virtual std::optional<std::string> getValue() = 0;
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>> read(const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>> writeWithResponse(const std::string& valueBase64, const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>> writeWithoutResponse(const std::string& valueBase64, const std::optional<std::string>& transactionId) = 0;
+      virtual Subscription monitor(const std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>& listener, const std::optional<std::string>& transactionId, std::optional<CharacteristicSubscriptionType> subscriptionType) = 0;
+      virtual std::shared_ptr<Promise<std::vector<NativeDescriptor>>> descriptors() = 0;
+      virtual std::shared_ptr<Promise<NativeDescriptor>> readDescriptor(const std::string& descriptorUUID, const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<NativeDescriptor>> writeDescriptor(const std::string& descriptorUUID, const std::string& valueBase64, const std::optional<std::string>& transactionId) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Characteristic";
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,30 @@
+///
+/// HybridDescriptorSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridDescriptorSpec.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  void HybridDescriptorSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("id", &HybridDescriptorSpec::getId);
+      prototype.registerHybridGetter("uuid", &HybridDescriptorSpec::getUuid);
+      prototype.registerHybridGetter("characteristicID", &HybridDescriptorSpec::getCharacteristicID);
+      prototype.registerHybridGetter("characteristicUUID", &HybridDescriptorSpec::getCharacteristicUUID);
+      prototype.registerHybridGetter("serviceID", &HybridDescriptorSpec::getServiceID);
+      prototype.registerHybridGetter("serviceUUID", &HybridDescriptorSpec::getServiceUUID);
+      prototype.registerHybridGetter("deviceID", &HybridDescriptorSpec::getDeviceID);
+      prototype.registerHybridGetter("value", &HybridDescriptorSpec::getValue);
+      prototype.registerHybridMethod("read", &HybridDescriptorSpec::read);
+      prototype.registerHybridMethod("write", &HybridDescriptorSpec::write);
+    });
+  }
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,75 @@
+///
+/// HybridDescriptorSpec.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/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridDescriptorSpec` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { class HybridDescriptorSpec; }
+
+#include <string>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridDescriptorSpec.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Descriptor`
+   * Inherit this class to create instances of `HybridDescriptorSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridDescriptor: public HybridDescriptorSpec {
+   * public:
+   *   HybridDescriptor(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridDescriptorSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridDescriptorSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridDescriptorSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getId() = 0;
+      virtual std::string getUuid() = 0;
+      virtual double getCharacteristicID() = 0;
+      virtual std::string getCharacteristicUUID() = 0;
+      virtual double getServiceID() = 0;
+      virtual std::string getServiceUUID() = 0;
+      virtual std::string getDeviceID() = 0;
+      virtual std::optional<std::string> getValue() = 0;
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>> read(const std::optional<std::string>& transactionId) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>> write(const std::string& valueBase64, const std::optional<std::string>& transactionId) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Descriptor";
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,50 @@
+///
+/// HybridDeviceSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridDeviceSpec.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  void HybridDeviceSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("id", &HybridDeviceSpec::getId);
+      prototype.registerHybridGetter("deviceName", &HybridDeviceSpec::getDeviceName);
+      prototype.registerHybridGetter("rssi", &HybridDeviceSpec::getRssi);
+      prototype.registerHybridGetter("mtu", &HybridDeviceSpec::getMtu);
+      prototype.registerHybridGetter("manufacturerData", &HybridDeviceSpec::getManufacturerData);
+      prototype.registerHybridGetter("rawScanRecord", &HybridDeviceSpec::getRawScanRecord);
+      prototype.registerHybridGetter("serviceData", &HybridDeviceSpec::getServiceData);
+      prototype.registerHybridGetter("serviceUUIDs", &HybridDeviceSpec::getServiceUUIDs);
+      prototype.registerHybridGetter("localName", &HybridDeviceSpec::getLocalName);
+      prototype.registerHybridGetter("txPowerLevel", &HybridDeviceSpec::getTxPowerLevel);
+      prototype.registerHybridGetter("solicitedServiceUUIDs", &HybridDeviceSpec::getSolicitedServiceUUIDs);
+      prototype.registerHybridGetter("isConnectable", &HybridDeviceSpec::getIsConnectable);
+      prototype.registerHybridGetter("overflowServiceUUIDs", &HybridDeviceSpec::getOverflowServiceUUIDs);
+      prototype.registerHybridMethod("requestConnectionPriority", &HybridDeviceSpec::requestConnectionPriority);
+      prototype.registerHybridMethod("readRSSI", &HybridDeviceSpec::readRSSI);
+      prototype.registerHybridMethod("requestMTU", &HybridDeviceSpec::requestMTU);
+      prototype.registerHybridMethod("connect", &HybridDeviceSpec::connect);
+      prototype.registerHybridMethod("cancelConnection", &HybridDeviceSpec::cancelConnection);
+      prototype.registerHybridMethod("isConnected", &HybridDeviceSpec::isConnected);
+      prototype.registerHybridMethod("onDisconnected", &HybridDeviceSpec::onDisconnected);
+      prototype.registerHybridMethod("discoverAllServicesAndCharacteristics", &HybridDeviceSpec::discoverAllServicesAndCharacteristics);
+      prototype.registerHybridMethod("services", &HybridDeviceSpec::services);
+      prototype.registerHybridMethod("characteristicsForService", &HybridDeviceSpec::characteristicsForService);
+      prototype.registerHybridMethod("readCharacteristicForService", &HybridDeviceSpec::readCharacteristicForService);
+      prototype.registerHybridMethod("writeCharacteristicWithResponseForService", &HybridDeviceSpec::writeCharacteristicWithResponseForService);
+      prototype.registerHybridMethod("writeCharacteristicWithoutResponseForService", &HybridDeviceSpec::writeCharacteristicWithoutResponseForService);
+      prototype.registerHybridMethod("monitorCharacteristicForService", &HybridDeviceSpec::monitorCharacteristicForService);
+      prototype.registerHybridMethod("descriptorsForService", &HybridDeviceSpec::descriptorsForService);
+      prototype.registerHybridMethod("readDescriptorForService", &HybridDeviceSpec::readDescriptorForService);
+      prototype.registerHybridMethod("writeDescriptorForService", &HybridDeviceSpec::writeDescriptorForService);
+    });
+  }
+
+} // namespace margelo::nitro::co::zyke::ble