react-native-ble-nitro 1.0.0-beta.0 → 1.0.0-beta.10

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

@@ -0,0 +1,192 @@
+///
+/// HybridCharacteristicSpecSwift.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 "HybridCharacteristicSpec.hpp"
+
+// Forward declaration of `HybridCharacteristicSpec_cxx` to properly resolve imports.
+namespace BleNitro { class HybridCharacteristicSpec_cxx; }
+
+// 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 `BleErrorCode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class BleErrorCode; }
+// Forward declaration of `BleATTErrorCode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class BleATTErrorCode; }
+// Forward declaration of `BleIOSErrorCode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class BleIOSErrorCode; }
+// Forward declaration of `BleAndroidErrorCode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class BleAndroidErrorCode; }
+// 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 "BleErrorCode.hpp"
+#include "BleATTErrorCode.hpp"
+#include "BleIOSErrorCode.hpp"
+#include "BleAndroidErrorCode.hpp"
+#include "CharacteristicSubscriptionType.hpp"
+#include <vector>
+#include "NativeDescriptor.hpp"
+
+#include "BleNitro-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  /**
+   * The C++ part of HybridCharacteristicSpec_cxx.swift.
+   *
+   * HybridCharacteristicSpecSwift (C++) accesses HybridCharacteristicSpec_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, HybridCharacteristicSpec_cxx can directly inherit from the C++ class HybridCharacteristicSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridCharacteristicSpecSwift: public virtual HybridCharacteristicSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridCharacteristicSpecSwift(const BleNitro::HybridCharacteristicSpec_cxx& swiftPart):
+      HybridObject(HybridCharacteristicSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline BleNitro::HybridCharacteristicSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    // Get memory pressure
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+
+  public:
+    // Properties
+    inline double getId() noexcept override {
+      return _swiftPart.getId();
+    }
+    inline std::string getUuid() noexcept override {
+      auto __result = _swiftPart.getUuid();
+      return __result;
+    }
+    inline double getServiceID() noexcept override {
+      return _swiftPart.getServiceID();
+    }
+    inline std::string getServiceUUID() noexcept override {
+      auto __result = _swiftPart.getServiceUUID();
+      return __result;
+    }
+    inline std::string getDeviceID() noexcept override {
+      auto __result = _swiftPart.getDeviceID();
+      return __result;
+    }
+    inline bool getIsReadable() noexcept override {
+      return _swiftPart.isReadable();
+    }
+    inline bool getIsWritableWithResponse() noexcept override {
+      return _swiftPart.isWritableWithResponse();
+    }
+    inline bool getIsWritableWithoutResponse() noexcept override {
+      return _swiftPart.isWritableWithoutResponse();
+    }
+    inline bool getIsNotifiable() noexcept override {
+      return _swiftPart.isNotifiable();
+    }
+    inline bool getIsNotifying() noexcept override {
+      return _swiftPart.isNotifying();
+    }
+    inline bool getIsIndicatable() noexcept override {
+      return _swiftPart.isIndicatable();
+    }
+    inline std::optional<std::string> getValue() noexcept override {
+      auto __result = _swiftPart.getValue();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>> read(const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.read(transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>> writeWithResponse(const std::string& valueBase64, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.writeWithResponse(valueBase64, transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>> writeWithoutResponse(const std::string& valueBase64, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.writeWithoutResponse(valueBase64, transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline 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) override {
+      auto __result = _swiftPart.monitor(listener, transactionId, subscriptionType);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<NativeDescriptor>>> descriptors() override {
+      auto __result = _swiftPart.descriptors();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeDescriptor>> readDescriptor(const std::string& descriptorUUID, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.readDescriptor(descriptorUUID, transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeDescriptor>> writeDescriptor(const std::string& descriptorUUID, const std::string& valueBase64, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.writeDescriptor(descriptorUUID, valueBase64, transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    BleNitro::HybridCharacteristicSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/ios/c++/HybridDescriptorSpecSwift.cpp

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

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

@@ -0,0 +1,112 @@
+///
+/// HybridDescriptorSpecSwift.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 "HybridDescriptorSpec.hpp"
+
+// Forward declaration of `HybridDescriptorSpec_cxx` to properly resolve imports.
+namespace BleNitro { class HybridDescriptorSpec_cxx; }
+
+// 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"
+
+#include "BleNitro-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  /**
+   * The C++ part of HybridDescriptorSpec_cxx.swift.
+   *
+   * HybridDescriptorSpecSwift (C++) accesses HybridDescriptorSpec_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, HybridDescriptorSpec_cxx can directly inherit from the C++ class HybridDescriptorSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridDescriptorSpecSwift: public virtual HybridDescriptorSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridDescriptorSpecSwift(const BleNitro::HybridDescriptorSpec_cxx& swiftPart):
+      HybridObject(HybridDescriptorSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline BleNitro::HybridDescriptorSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    // Get memory pressure
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+
+  public:
+    // Properties
+    inline double getId() noexcept override {
+      return _swiftPart.getId();
+    }
+    inline std::string getUuid() noexcept override {
+      auto __result = _swiftPart.getUuid();
+      return __result;
+    }
+    inline double getCharacteristicID() noexcept override {
+      return _swiftPart.getCharacteristicID();
+    }
+    inline std::string getCharacteristicUUID() noexcept override {
+      auto __result = _swiftPart.getCharacteristicUUID();
+      return __result;
+    }
+    inline double getServiceID() noexcept override {
+      return _swiftPart.getServiceID();
+    }
+    inline std::string getServiceUUID() noexcept override {
+      auto __result = _swiftPart.getServiceUUID();
+      return __result;
+    }
+    inline std::string getDeviceID() noexcept override {
+      auto __result = _swiftPart.getDeviceID();
+      return __result;
+    }
+    inline std::optional<std::string> getValue() noexcept override {
+      auto __result = _swiftPart.getValue();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>> read(const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.read(transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>> write(const std::string& valueBase64, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.write(valueBase64, transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    BleNitro::HybridDescriptorSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/ios/c++/HybridDeviceSpecSwift.cpp

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

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

@@ -0,0 +1,294 @@
+///
+/// HybridDeviceSpecSwift.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 "HybridDeviceSpec.hpp"
+
+// Forward declaration of `HybridDeviceSpec_cxx` to properly resolve imports.
+namespace BleNitro { class HybridDeviceSpec_cxx; }
+
+// Forward declaration of `ServiceDataEntry` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ServiceDataEntry; }
+// 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 `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 `BleErrorCode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class BleErrorCode; }
+// Forward declaration of `BleATTErrorCode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class BleATTErrorCode; }
+// Forward declaration of `BleIOSErrorCode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class BleIOSErrorCode; }
+// Forward declaration of `BleAndroidErrorCode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class BleAndroidErrorCode; }
+// 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 <string>
+#include <optional>
+#include <vector>
+#include "ServiceDataEntry.hpp"
+#include <NitroModules/Promise.hpp>
+#include "NativeDevice.hpp"
+#include "ConnectionPriority.hpp"
+#include "ConnectionOptions.hpp"
+#include "Subscription.hpp"
+#include <functional>
+#include "NativeBleError.hpp"
+#include "BleErrorCode.hpp"
+#include "BleATTErrorCode.hpp"
+#include "BleIOSErrorCode.hpp"
+#include "BleAndroidErrorCode.hpp"
+#include "NativeService.hpp"
+#include "NativeCharacteristic.hpp"
+#include "CharacteristicSubscriptionType.hpp"
+#include "NativeDescriptor.hpp"
+
+#include "BleNitro-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  /**
+   * The C++ part of HybridDeviceSpec_cxx.swift.
+   *
+   * HybridDeviceSpecSwift (C++) accesses HybridDeviceSpec_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, HybridDeviceSpec_cxx can directly inherit from the C++ class HybridDeviceSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridDeviceSpecSwift: public virtual HybridDeviceSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridDeviceSpecSwift(const BleNitro::HybridDeviceSpec_cxx& swiftPart):
+      HybridObject(HybridDeviceSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline BleNitro::HybridDeviceSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    // Get memory pressure
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+
+  public:
+    // Properties
+    inline std::string getId() noexcept override {
+      auto __result = _swiftPart.getId();
+      return __result;
+    }
+    inline std::optional<std::string> getDeviceName() noexcept override {
+      auto __result = _swiftPart.getDeviceName();
+      return __result;
+    }
+    inline std::optional<double> getRssi() noexcept override {
+      auto __result = _swiftPart.getRssi();
+      return __result;
+    }
+    inline double getMtu() noexcept override {
+      return _swiftPart.getMtu();
+    }
+    inline std::optional<std::string> getManufacturerData() noexcept override {
+      auto __result = _swiftPart.getManufacturerData();
+      return __result;
+    }
+    inline std::string getRawScanRecord() noexcept override {
+      auto __result = _swiftPart.getRawScanRecord();
+      return __result;
+    }
+    inline std::optional<std::vector<ServiceDataEntry>> getServiceData() noexcept override {
+      auto __result = _swiftPart.getServiceData();
+      return __result;
+    }
+    inline std::optional<std::vector<std::string>> getServiceUUIDs() noexcept override {
+      auto __result = _swiftPart.getServiceUUIDs();
+      return __result;
+    }
+    inline std::optional<std::string> getLocalName() noexcept override {
+      auto __result = _swiftPart.getLocalName();
+      return __result;
+    }
+    inline std::optional<double> getTxPowerLevel() noexcept override {
+      auto __result = _swiftPart.getTxPowerLevel();
+      return __result;
+    }
+    inline std::optional<std::vector<std::string>> getSolicitedServiceUUIDs() noexcept override {
+      auto __result = _swiftPart.getSolicitedServiceUUIDs();
+      return __result;
+    }
+    inline std::optional<bool> getIsConnectable() noexcept override {
+      auto __result = _swiftPart.getIsConnectable();
+      return __result;
+    }
+    inline std::optional<std::vector<std::string>> getOverflowServiceUUIDs() noexcept override {
+      auto __result = _swiftPart.getOverflowServiceUUIDs();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<NativeDevice>> requestConnectionPriority(ConnectionPriority connectionPriority, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.requestConnectionPriority(static_cast<int>(connectionPriority), transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeDevice>> readRSSI(const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.readRSSI(transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeDevice>> requestMTU(double mtu, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.requestMTU(std::forward<decltype(mtu)>(mtu), transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeDevice>> connect(const std::optional<ConnectionOptions>& options) override {
+      auto __result = _swiftPart.connect(options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeDevice>> cancelConnection() override {
+      auto __result = _swiftPart.cancelConnection();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> isConnected() override {
+      auto __result = _swiftPart.isConnected();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline Subscription onDisconnected(const std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeDevice>& /* device */)>& listener) override {
+      auto __result = _swiftPart.onDisconnected(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeDevice>> discoverAllServicesAndCharacteristics(const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.discoverAllServicesAndCharacteristics(transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<NativeService>>> services() override {
+      auto __result = _swiftPart.services();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<NativeCharacteristic>>> characteristicsForService(const std::string& serviceUUID) override {
+      auto __result = _swiftPart.characteristicsForService(serviceUUID);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeCharacteristic>> readCharacteristicForService(const std::string& serviceUUID, const std::string& characteristicUUID, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.readCharacteristicForService(serviceUUID, characteristicUUID, transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeCharacteristic>> writeCharacteristicWithResponseForService(const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& valueBase64, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.writeCharacteristicWithResponseForService(serviceUUID, characteristicUUID, valueBase64, transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeCharacteristic>> writeCharacteristicWithoutResponseForService(const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& valueBase64, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.writeCharacteristicWithoutResponseForService(serviceUUID, characteristicUUID, valueBase64, transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline Subscription monitorCharacteristicForService(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) override {
+      auto __result = _swiftPart.monitorCharacteristicForService(serviceUUID, characteristicUUID, listener, transactionId, subscriptionType);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<NativeDescriptor>>> descriptorsForService(const std::string& serviceUUID, const std::string& characteristicUUID) override {
+      auto __result = _swiftPart.descriptorsForService(serviceUUID, characteristicUUID);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeDescriptor>> readDescriptorForService(const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& descriptorUUID, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.readDescriptorForService(serviceUUID, characteristicUUID, descriptorUUID, transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<NativeDescriptor>> writeDescriptorForService(const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& descriptorUUID, const std::string& valueBase64, const std::optional<std::string>& transactionId) override {
+      auto __result = _swiftPart.writeDescriptorForService(serviceUUID, characteristicUUID, descriptorUUID, valueBase64, transactionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    BleNitro::HybridDeviceSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/ios/c++/HybridServiceSpecSwift.cpp

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