munim-bluetooth 0.3.26 → 0.4.0

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

@@ -14,14 +14,42 @@ namespace margelo::nitro::munimbluetooth { struct AdvertisingDataTypes; }
 namespace margelo::nitro::munimbluetooth { struct AdvertisingOptions; }
 // Forward declaration of `BackgroundSessionOptions` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { struct BackgroundSessionOptions; }
+// Forward declaration of `BluetoothCapabilities` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct BluetoothCapabilities; }
+// Forward declaration of `BluetoothPhyOption` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class BluetoothPhyOption; }
+// Forward declaration of `BluetoothPhy` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class BluetoothPhy; }
+// Forward declaration of `BondState` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class BondState; }
 // Forward declaration of `CharacteristicValue` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { struct CharacteristicValue; }
+// Forward declaration of `DescriptorValue` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct DescriptorValue; }
+// Forward declaration of `ExtendedAdvertisingOptions` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct ExtendedAdvertisingOptions; }
 // Forward declaration of `GATTCharacteristic` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { struct GATTCharacteristic; }
+// Forward declaration of `GATTDescriptor` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct GATTDescriptor; }
 // Forward declaration of `GATTService` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { struct GATTService; }
 // Forward declaration of `HybridMunimBluetoothSpec` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { class HybridMunimBluetoothSpec; }
+// Forward declaration of `L2CAPChannel` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct L2CAPChannel; }
+// Forward declaration of `MultipeerDiscoveryInfoEntry` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct MultipeerDiscoveryInfoEntry; }
+// Forward declaration of `MultipeerEncryptionPreference` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class MultipeerEncryptionPreference; }
+// Forward declaration of `MultipeerPeerState` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class MultipeerPeerState; }
+// Forward declaration of `MultipeerPeer` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct MultipeerPeer; }
+// Forward declaration of `MultipeerSessionOptions` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct MultipeerSessionOptions; }
+// Forward declaration of `PhyStatus` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct PhyStatus; }
 // Forward declaration of `ScanMode` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { enum class ScanMode; }
 // Forward declaration of `ScanOptions` to properly resolve imports.
@@ -35,10 +63,24 @@ namespace margelo::nitro::munimbluetooth { enum class WriteType; }
 #include "AdvertisingDataTypes.hpp"
 #include "AdvertisingOptions.hpp"
 #include "BackgroundSessionOptions.hpp"
+#include "BluetoothCapabilities.hpp"
+#include "BluetoothPhy.hpp"
+#include "BluetoothPhyOption.hpp"
+#include "BondState.hpp"
 #include "CharacteristicValue.hpp"
+#include "DescriptorValue.hpp"
+#include "ExtendedAdvertisingOptions.hpp"
 #include "GATTCharacteristic.hpp"
+#include "GATTDescriptor.hpp"
 #include "GATTService.hpp"
 #include "HybridMunimBluetoothSpec.hpp"
+#include "L2CAPChannel.hpp"
+#include "MultipeerDiscoveryInfoEntry.hpp"
+#include "MultipeerEncryptionPreference.hpp"
+#include "MultipeerPeer.hpp"
+#include "MultipeerPeerState.hpp"
+#include "MultipeerSessionOptions.hpp"
+#include "PhyStatus.hpp"
 #include "ScanMode.hpp"
 #include "ScanOptions.hpp"
 #include "ServiceDataEntry.hpp"

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

@@ -22,16 +22,44 @@ namespace margelo::nitro::munimbluetooth { struct ServiceDataEntry; }
 namespace margelo::nitro::munimbluetooth { struct GATTService; }
 // Forward declaration of `GATTCharacteristic` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { struct GATTCharacteristic; }
+// Forward declaration of `GATTDescriptor` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct GATTDescriptor; }
+// Forward declaration of `BluetoothCapabilities` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct BluetoothCapabilities; }
 // Forward declaration of `ScanOptions` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { struct ScanOptions; }
 // Forward declaration of `ScanMode` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { enum class ScanMode; }
 // Forward declaration of `CharacteristicValue` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { struct CharacteristicValue; }
+// Forward declaration of `DescriptorValue` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct DescriptorValue; }
 // Forward declaration of `WriteType` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { enum class WriteType; }
+// Forward declaration of `BluetoothPhy` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class BluetoothPhy; }
+// Forward declaration of `BluetoothPhyOption` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class BluetoothPhyOption; }
+// Forward declaration of `PhyStatus` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct PhyStatus; }
+// Forward declaration of `BondState` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class BondState; }
+// Forward declaration of `ExtendedAdvertisingOptions` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct ExtendedAdvertisingOptions; }
+// Forward declaration of `L2CAPChannel` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct L2CAPChannel; }
 // Forward declaration of `BackgroundSessionOptions` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { struct BackgroundSessionOptions; }
+// Forward declaration of `MultipeerSessionOptions` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct MultipeerSessionOptions; }
+// Forward declaration of `MultipeerDiscoveryInfoEntry` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct MultipeerDiscoveryInfoEntry; }
+// Forward declaration of `MultipeerEncryptionPreference` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class MultipeerEncryptionPreference; }
+// Forward declaration of `MultipeerPeer` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct MultipeerPeer; }
+// Forward declaration of `MultipeerPeerState` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class MultipeerPeerState; }
 
 #include "AdvertisingOptions.hpp"
 #include <string>
@@ -42,11 +70,25 @@ namespace margelo::nitro::munimbluetooth { struct BackgroundSessionOptions; }
 #include <NitroModules/Promise.hpp>
 #include "GATTService.hpp"
 #include "GATTCharacteristic.hpp"
+#include "GATTDescriptor.hpp"
+#include "BluetoothCapabilities.hpp"
 #include "ScanOptions.hpp"
 #include "ScanMode.hpp"
 #include "CharacteristicValue.hpp"
+#include "DescriptorValue.hpp"
 #include "WriteType.hpp"
+#include "BluetoothPhy.hpp"
+#include "BluetoothPhyOption.hpp"
+#include "PhyStatus.hpp"
+#include "BondState.hpp"
+#include "ExtendedAdvertisingOptions.hpp"
+#include "L2CAPChannel.hpp"
 #include "BackgroundSessionOptions.hpp"
+#include "MultipeerSessionOptions.hpp"
+#include "MultipeerDiscoveryInfoEntry.hpp"
+#include "MultipeerEncryptionPreference.hpp"
+#include "MultipeerPeer.hpp"
+#include "MultipeerPeerState.hpp"
 
 #include "MunimBluetooth-Swift-Cxx-Umbrella.hpp"
 
@@ -130,6 +172,14 @@ namespace margelo::nitro::munimbluetooth {
         std::rethrow_exception(__result.error());
       }
     }
+    inline std::shared_ptr<Promise<void>> updateCharacteristicValue(const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& value, std::optional<bool> notify) override {
+      auto __result = _swiftPart.updateCharacteristicValue(serviceUUID, characteristicUUID, value, notify);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<bool>> isBluetoothEnabled() override {
       auto __result = _swiftPart.isBluetoothEnabled();
       if (__result.hasError()) [[unlikely]] {
@@ -146,6 +196,14 @@ namespace margelo::nitro::munimbluetooth {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<BluetoothCapabilities>> getCapabilities() override {
+      auto __result = _swiftPart.getCapabilities();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void startScan(const std::optional<ScanOptions>& options) override {
       auto __result = _swiftPart.startScan(options);
       if (__result.hasError()) [[unlikely]] {
@@ -188,6 +246,14 @@ namespace margelo::nitro::munimbluetooth {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<DescriptorValue>> readDescriptor(const std::string& deviceId, const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& descriptorUUID) override {
+      auto __result = _swiftPart.readDescriptor(deviceId, serviceUUID, characteristicUUID, descriptorUUID);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<void>> writeCharacteristic(const std::string& deviceId, const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& value, std::optional<WriteType> writeType) override {
       auto __result = _swiftPart.writeCharacteristic(deviceId, serviceUUID, characteristicUUID, value, writeType);
       if (__result.hasError()) [[unlikely]] {
@@ -196,6 +262,14 @@ namespace margelo::nitro::munimbluetooth {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<void>> writeDescriptor(const std::string& deviceId, const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& descriptorUUID, const std::string& value) override {
+      auto __result = _swiftPart.writeDescriptor(deviceId, serviceUUID, characteristicUUID, descriptorUUID, value);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void subscribeToCharacteristic(const std::string& deviceId, const std::string& serviceUUID, const std::string& characteristicUUID) override {
       auto __result = _swiftPart.subscribeToCharacteristic(deviceId, serviceUUID, characteristicUUID);
       if (__result.hasError()) [[unlikely]] {
@@ -224,6 +298,152 @@ namespace margelo::nitro::munimbluetooth {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<double>> requestMTU(const std::string& deviceId, double mtu) override {
+      auto __result = _swiftPart.requestMTU(deviceId, std::forward<decltype(mtu)>(mtu));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setPreferredPhy(const std::string& deviceId, BluetoothPhy txPhy, BluetoothPhy rxPhy, std::optional<BluetoothPhyOption> phyOption) override {
+      auto __result = _swiftPart.setPreferredPhy(deviceId, static_cast<int>(txPhy), static_cast<int>(rxPhy), phyOption);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<PhyStatus>> readPhy(const std::string& deviceId) override {
+      auto __result = _swiftPart.readPhy(deviceId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<BondState>> getBondState(const std::string& deviceId) override {
+      auto __result = _swiftPart.getBondState(deviceId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<BondState>> createBond(const std::string& deviceId) override {
+      auto __result = _swiftPart.createBond(deviceId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<BondState>> removeBond(const std::string& deviceId) override {
+      auto __result = _swiftPart.removeBond(deviceId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> startExtendedAdvertising(const ExtendedAdvertisingOptions& options) override {
+      auto __result = _swiftPart.startExtendedAdvertising(std::forward<decltype(options)>(options));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void stopExtendedAdvertising(const std::string& advertisingId) override {
+      auto __result = _swiftPart.stopExtendedAdvertising(advertisingId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<L2CAPChannel>> publishL2CAPChannel(std::optional<bool> encryptionRequired) override {
+      auto __result = _swiftPart.publishL2CAPChannel(encryptionRequired);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void unpublishL2CAPChannel(double psm) override {
+      auto __result = _swiftPart.unpublishL2CAPChannel(std::forward<decltype(psm)>(psm));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<L2CAPChannel>> openL2CAPChannel(const std::string& deviceId, double psm) override {
+      auto __result = _swiftPart.openL2CAPChannel(deviceId, std::forward<decltype(psm)>(psm));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void closeL2CAPChannel(const std::string& channelId) override {
+      auto __result = _swiftPart.closeL2CAPChannel(channelId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<void>> sendL2CAPData(const std::string& channelId, const std::string& value) override {
+      auto __result = _swiftPart.sendL2CAPData(channelId, value);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void startClassicScan() override {
+      auto __result = _swiftPart.startClassicScan();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void stopClassicScan() override {
+      auto __result = _swiftPart.stopClassicScan();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<void>> connectClassic(const std::string& deviceId, const std::optional<std::string>& serviceUUID) override {
+      auto __result = _swiftPart.connectClassic(deviceId, serviceUUID);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> startClassicServer(const std::optional<std::string>& serviceUUID, const std::optional<std::string>& serviceName) override {
+      auto __result = _swiftPart.startClassicServer(serviceUUID, serviceName);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void stopClassicServer(const std::optional<std::string>& serviceUUID) override {
+      auto __result = _swiftPart.stopClassicServer(serviceUUID);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void disconnectClassic(const std::string& deviceId) override {
+      auto __result = _swiftPart.disconnectClassic(deviceId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<void>> writeClassic(const std::string& deviceId, const std::string& value) override {
+      auto __result = _swiftPart.writeClassic(deviceId, value);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void startBackgroundSession(const BackgroundSessionOptions& options) override {
       auto __result = _swiftPart.startBackgroundSession(std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
@@ -236,6 +456,40 @@ namespace margelo::nitro::munimbluetooth {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void startMultipeerSession(const MultipeerSessionOptions& options) override {
+      auto __result = _swiftPart.startMultipeerSession(std::forward<decltype(options)>(options));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void stopMultipeerSession() override {
+      auto __result = _swiftPart.stopMultipeerSession();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void inviteMultipeerPeer(const std::string& peerId) override {
+      auto __result = _swiftPart.inviteMultipeerPeer(peerId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<std::vector<MultipeerPeer>>> getMultipeerPeers() override {
+      auto __result = _swiftPart.getMultipeerPeers();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> sendMultipeerMessage(const std::string& value, const std::optional<std::vector<std::string>>& peerIds, std::optional<bool> reliable) override {
+      auto __result = _swiftPart.sendMultipeerMessage(value, peerIds, reliable);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void addListener(const std::string& eventName) override {
       auto __result = _swiftPart.addListener(eventName);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/BluetoothCapabilities.swift

@@ -0,0 +1,89 @@
+///
+/// BluetoothCapabilities.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `BluetoothCapabilities`, backed by a C++ struct.
+ */
+public typealias BluetoothCapabilities = margelo.nitro.munimbluetooth.BluetoothCapabilities
+
+public extension BluetoothCapabilities {
+  private typealias bridge = margelo.nitro.munimbluetooth.bridge.swift
+
+  /**
+   * Create a new instance of `BluetoothCapabilities`.
+   */
+  init(platform: String, supportsBleCentral: Bool, supportsBlePeripheral: Bool, supportsDescriptors: Bool, supportsIncludedServices: Bool, supportsMtu: Bool, supportsPhy: Bool, supportsBonding: Bool, supportsExtendedAdvertising: Bool, supportsL2cap: Bool, supportsClassicBluetooth: Bool, supportsBackgroundBle: Bool, supportsMultipeerConnectivity: Bool) {
+    self.init(std.string(platform), supportsBleCentral, supportsBlePeripheral, supportsDescriptors, supportsIncludedServices, supportsMtu, supportsPhy, supportsBonding, supportsExtendedAdvertising, supportsL2cap, supportsClassicBluetooth, supportsBackgroundBle, supportsMultipeerConnectivity)
+  }
+
+  @inline(__always)
+  var platform: String {
+    return String(self.__platform)
+  }
+  
+  @inline(__always)
+  var supportsBleCentral: Bool {
+    return self.__supportsBleCentral
+  }
+  
+  @inline(__always)
+  var supportsBlePeripheral: Bool {
+    return self.__supportsBlePeripheral
+  }
+  
+  @inline(__always)
+  var supportsDescriptors: Bool {
+    return self.__supportsDescriptors
+  }
+  
+  @inline(__always)
+  var supportsIncludedServices: Bool {
+    return self.__supportsIncludedServices
+  }
+  
+  @inline(__always)
+  var supportsMtu: Bool {
+    return self.__supportsMtu
+  }
+  
+  @inline(__always)
+  var supportsPhy: Bool {
+    return self.__supportsPhy
+  }
+  
+  @inline(__always)
+  var supportsBonding: Bool {
+    return self.__supportsBonding
+  }
+  
+  @inline(__always)
+  var supportsExtendedAdvertising: Bool {
+    return self.__supportsExtendedAdvertising
+  }
+  
+  @inline(__always)
+  var supportsL2cap: Bool {
+    return self.__supportsL2cap
+  }
+  
+  @inline(__always)
+  var supportsClassicBluetooth: Bool {
+    return self.__supportsClassicBluetooth
+  }
+  
+  @inline(__always)
+  var supportsBackgroundBle: Bool {
+    return self.__supportsBackgroundBle
+  }
+  
+  @inline(__always)
+  var supportsMultipeerConnectivity: Bool {
+    return self.__supportsMultipeerConnectivity
+  }
+}

package/nitrogen/generated/ios/swift/BluetoothPhy.swift

@@ -0,0 +1,44 @@
+///
+/// BluetoothPhy.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `BluetoothPhy`, backed by a C++ enum.
+ */
+public typealias BluetoothPhy = margelo.nitro.munimbluetooth.BluetoothPhy
+
+public extension BluetoothPhy {
+  /**
+   * Get a BluetoothPhy for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "le1m":
+        self = .le1m
+      case "le2m":
+        self = .le2m
+      case "leCoded":
+        self = .lecoded
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this BluetoothPhy represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .le1m:
+        return "le1m"
+      case .le2m:
+        return "le2m"
+      case .lecoded:
+        return "leCoded"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/BluetoothPhyOption.swift

@@ -0,0 +1,44 @@
+///
+/// BluetoothPhyOption.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `BluetoothPhyOption`, backed by a C++ enum.
+ */
+public typealias BluetoothPhyOption = margelo.nitro.munimbluetooth.BluetoothPhyOption
+
+public extension BluetoothPhyOption {
+  /**
+   * Get a BluetoothPhyOption for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "none":
+        self = .none
+      case "s2":
+        self = .s2
+      case "s8":
+        self = .s8
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this BluetoothPhyOption represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .none:
+        return "none"
+      case .s2:
+        return "s2"
+      case .s8:
+        return "s8"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/BondState.swift

@@ -0,0 +1,48 @@
+///
+/// BondState.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `BondState`, backed by a C++ enum.
+ */
+public typealias BondState = margelo.nitro.munimbluetooth.BondState
+
+public extension BondState {
+  /**
+   * Get a BondState for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "none":
+        self = .none
+      case "bonding":
+        self = .bonding
+      case "bonded":
+        self = .bonded
+      case "unsupported":
+        self = .unsupported
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this BondState represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .none:
+        return "none"
+      case .bonding:
+        return "bonding"
+      case .bonded:
+        return "bonded"
+      case .unsupported:
+        return "unsupported"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/DescriptorValue.swift

@@ -0,0 +1,44 @@
+///
+/// DescriptorValue.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `DescriptorValue`, backed by a C++ struct.
+ */
+public typealias DescriptorValue = margelo.nitro.munimbluetooth.DescriptorValue
+
+public extension DescriptorValue {
+  private typealias bridge = margelo.nitro.munimbluetooth.bridge.swift
+
+  /**
+   * Create a new instance of `DescriptorValue`.
+   */
+  init(value: String, serviceUUID: String, characteristicUUID: String, descriptorUUID: String) {
+    self.init(std.string(value), std.string(serviceUUID), std.string(characteristicUUID), std.string(descriptorUUID))
+  }
+
+  @inline(__always)
+  var value: String {
+    return String(self.__value)
+  }
+  
+  @inline(__always)
+  var serviceUUID: String {
+    return String(self.__serviceUUID)
+  }
+  
+  @inline(__always)
+  var characteristicUUID: String {
+    return String(self.__characteristicUUID)
+  }
+  
+  @inline(__always)
+  var descriptorUUID: String {
+    return String(self.__descriptorUUID)
+  }
+}