munim-bluetooth 0.3.26 → 0.4.0

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

@@ -19,26 +19,56 @@ namespace margelo::nitro::munimbluetooth { struct AdvertisingOptions; }
 namespace margelo::nitro::munimbluetooth { struct AdvertisingDataTypes; }
 // Forward declaration of `GATTService` to properly resolve imports.
 namespace margelo::nitro::munimbluetooth { struct GATTService; }
+// 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 `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 `MultipeerPeer` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct MultipeerPeer; }
 
 #include "AdvertisingOptions.hpp"
 #include "AdvertisingDataTypes.hpp"
 #include <NitroModules/Promise.hpp>
 #include "GATTService.hpp"
 #include <vector>
-#include "ScanOptions.hpp"
-#include <optional>
 #include <string>
+#include <optional>
+#include "BluetoothCapabilities.hpp"
+#include "ScanOptions.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 "MultipeerPeer.hpp"
 
 namespace margelo::nitro::munimbluetooth {
 
@@ -76,21 +106,50 @@ namespace margelo::nitro::munimbluetooth {
       virtual std::shared_ptr<Promise<AdvertisingDataTypes>> getAdvertisingData() = 0;
       virtual void stopAdvertising() = 0;
       virtual void setServices(const std::vector<GATTService>& services) = 0;
+      virtual std::shared_ptr<Promise<void>> updateCharacteristicValue(const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& value, std::optional<bool> notify) = 0;
       virtual std::shared_ptr<Promise<bool>> isBluetoothEnabled() = 0;
       virtual std::shared_ptr<Promise<bool>> requestBluetoothPermission() = 0;
+      virtual std::shared_ptr<Promise<BluetoothCapabilities>> getCapabilities() = 0;
       virtual void startScan(const std::optional<ScanOptions>& options) = 0;
       virtual void stopScan() = 0;
       virtual std::shared_ptr<Promise<void>> connect(const std::string& deviceId) = 0;
       virtual void disconnect(const std::string& deviceId) = 0;
       virtual std::shared_ptr<Promise<std::vector<GATTService>>> discoverServices(const std::string& deviceId) = 0;
       virtual std::shared_ptr<Promise<CharacteristicValue>> readCharacteristic(const std::string& deviceId, const std::string& serviceUUID, const std::string& characteristicUUID) = 0;
+      virtual std::shared_ptr<Promise<DescriptorValue>> readDescriptor(const std::string& deviceId, const std::string& serviceUUID, const std::string& characteristicUUID, const std::string& descriptorUUID) = 0;
       virtual 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) = 0;
+      virtual 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) = 0;
       virtual void subscribeToCharacteristic(const std::string& deviceId, const std::string& serviceUUID, const std::string& characteristicUUID) = 0;
       virtual void unsubscribeFromCharacteristic(const std::string& deviceId, const std::string& serviceUUID, const std::string& characteristicUUID) = 0;
       virtual std::shared_ptr<Promise<std::vector<std::string>>> getConnectedDevices() = 0;
       virtual std::shared_ptr<Promise<double>> readRSSI(const std::string& deviceId) = 0;
+      virtual std::shared_ptr<Promise<double>> requestMTU(const std::string& deviceId, double mtu) = 0;
+      virtual std::shared_ptr<Promise<void>> setPreferredPhy(const std::string& deviceId, BluetoothPhy txPhy, BluetoothPhy rxPhy, std::optional<BluetoothPhyOption> phyOption) = 0;
+      virtual std::shared_ptr<Promise<PhyStatus>> readPhy(const std::string& deviceId) = 0;
+      virtual std::shared_ptr<Promise<BondState>> getBondState(const std::string& deviceId) = 0;
+      virtual std::shared_ptr<Promise<BondState>> createBond(const std::string& deviceId) = 0;
+      virtual std::shared_ptr<Promise<BondState>> removeBond(const std::string& deviceId) = 0;
+      virtual std::shared_ptr<Promise<std::string>> startExtendedAdvertising(const ExtendedAdvertisingOptions& options) = 0;
+      virtual void stopExtendedAdvertising(const std::string& advertisingId) = 0;
+      virtual std::shared_ptr<Promise<L2CAPChannel>> publishL2CAPChannel(std::optional<bool> encryptionRequired) = 0;
+      virtual void unpublishL2CAPChannel(double psm) = 0;
+      virtual std::shared_ptr<Promise<L2CAPChannel>> openL2CAPChannel(const std::string& deviceId, double psm) = 0;
+      virtual void closeL2CAPChannel(const std::string& channelId) = 0;
+      virtual std::shared_ptr<Promise<void>> sendL2CAPData(const std::string& channelId, const std::string& value) = 0;
+      virtual void startClassicScan() = 0;
+      virtual void stopClassicScan() = 0;
+      virtual std::shared_ptr<Promise<void>> connectClassic(const std::string& deviceId, const std::optional<std::string>& serviceUUID) = 0;
+      virtual std::shared_ptr<Promise<void>> startClassicServer(const std::optional<std::string>& serviceUUID, const std::optional<std::string>& serviceName) = 0;
+      virtual void stopClassicServer(const std::optional<std::string>& serviceUUID) = 0;
+      virtual void disconnectClassic(const std::string& deviceId) = 0;
+      virtual std::shared_ptr<Promise<void>> writeClassic(const std::string& deviceId, const std::string& value) = 0;
       virtual void startBackgroundSession(const BackgroundSessionOptions& options) = 0;
       virtual void stopBackgroundSession() = 0;
+      virtual void startMultipeerSession(const MultipeerSessionOptions& options) = 0;
+      virtual void stopMultipeerSession() = 0;
+      virtual void inviteMultipeerPeer(const std::string& peerId) = 0;
+      virtual std::shared_ptr<Promise<std::vector<MultipeerPeer>>> getMultipeerPeers() = 0;
+      virtual std::shared_ptr<Promise<void>> sendMultipeerMessage(const std::string& value, const std::optional<std::vector<std::string>>& peerIds, std::optional<bool> reliable) = 0;
       virtual void addListener(const std::string& eventName) = 0;
       virtual void removeListeners(double count) = 0;
 

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

@@ -0,0 +1,92 @@
+///
+/// L2CAPChannel.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::munimbluetooth {
+
+  /**
+   * A struct which can be represented as a JavaScript object (L2CAPChannel).
+   */
+  struct L2CAPChannel final {
+  public:
+    std::string id     SWIFT_PRIVATE;
+    double psm     SWIFT_PRIVATE;
+    std::optional<std::string> deviceId     SWIFT_PRIVATE;
+
+  public:
+    L2CAPChannel() = default;
+    explicit L2CAPChannel(std::string id, double psm, std::optional<std::string> deviceId): id(id), psm(psm), deviceId(deviceId) {}
+
+  public:
+    friend bool operator==(const L2CAPChannel& lhs, const L2CAPChannel& rhs) = default;
+  };
+
+} // namespace margelo::nitro::munimbluetooth
+
+namespace margelo::nitro {
+
+  // C++ L2CAPChannel <> JS L2CAPChannel (object)
+  template <>
+  struct JSIConverter<margelo::nitro::munimbluetooth::L2CAPChannel> final {
+    static inline margelo::nitro::munimbluetooth::L2CAPChannel fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::munimbluetooth::L2CAPChannel(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "id"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "psm"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "deviceId")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::munimbluetooth::L2CAPChannel& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "id"), JSIConverter<std::string>::toJSI(runtime, arg.id));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "psm"), JSIConverter<double>::toJSI(runtime, arg.psm));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "deviceId"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.deviceId));
+      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 (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "id")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "psm")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "deviceId")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,87 @@
+///
+/// MultipeerDiscoveryInfoEntry.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::munimbluetooth {
+
+  /**
+   * A struct which can be represented as a JavaScript object (MultipeerDiscoveryInfoEntry).
+   */
+  struct MultipeerDiscoveryInfoEntry final {
+  public:
+    std::string key     SWIFT_PRIVATE;
+    std::string value     SWIFT_PRIVATE;
+
+  public:
+    MultipeerDiscoveryInfoEntry() = default;
+    explicit MultipeerDiscoveryInfoEntry(std::string key, std::string value): key(key), value(value) {}
+
+  public:
+    friend bool operator==(const MultipeerDiscoveryInfoEntry& lhs, const MultipeerDiscoveryInfoEntry& rhs) = default;
+  };
+
+} // namespace margelo::nitro::munimbluetooth
+
+namespace margelo::nitro {
+
+  // C++ MultipeerDiscoveryInfoEntry <> JS MultipeerDiscoveryInfoEntry (object)
+  template <>
+  struct JSIConverter<margelo::nitro::munimbluetooth::MultipeerDiscoveryInfoEntry> final {
+    static inline margelo::nitro::munimbluetooth::MultipeerDiscoveryInfoEntry fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::munimbluetooth::MultipeerDiscoveryInfoEntry(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "key"))),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "value")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::munimbluetooth::MultipeerDiscoveryInfoEntry& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "key"), JSIConverter<std::string>::toJSI(runtime, arg.key));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "value"), JSIConverter<std::string>::toJSI(runtime, arg.value));
+      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 (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "key")))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "value")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,80 @@
+///
+/// MultipeerEncryptionPreference.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#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::munimbluetooth {
+
+  /**
+   * An enum which can be represented as a JavaScript union (MultipeerEncryptionPreference).
+   */
+  enum class MultipeerEncryptionPreference {
+    NONE      SWIFT_NAME(none) = 0,
+    OPTIONAL      SWIFT_NAME(optional) = 1,
+    REQUIRED      SWIFT_NAME(required) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::munimbluetooth
+
+namespace margelo::nitro {
+
+  // C++ MultipeerEncryptionPreference <> JS MultipeerEncryptionPreference (union)
+  template <>
+  struct JSIConverter<margelo::nitro::munimbluetooth::MultipeerEncryptionPreference> final {
+    static inline margelo::nitro::munimbluetooth::MultipeerEncryptionPreference fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"): return margelo::nitro::munimbluetooth::MultipeerEncryptionPreference::NONE;
+        case hashString("optional"): return margelo::nitro::munimbluetooth::MultipeerEncryptionPreference::OPTIONAL;
+        case hashString("required"): return margelo::nitro::munimbluetooth::MultipeerEncryptionPreference::REQUIRED;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum MultipeerEncryptionPreference - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::munimbluetooth::MultipeerEncryptionPreference arg) {
+      switch (arg) {
+        case margelo::nitro::munimbluetooth::MultipeerEncryptionPreference::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
+        case margelo::nitro::munimbluetooth::MultipeerEncryptionPreference::OPTIONAL: return JSIConverter<std::string>::toJSI(runtime, "optional");
+        case margelo::nitro::munimbluetooth::MultipeerEncryptionPreference::REQUIRED: return JSIConverter<std::string>::toJSI(runtime, "required");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert MultipeerEncryptionPreference to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"):
+        case hashString("optional"):
+        case hashString("required"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,102 @@
+///
+/// MultipeerPeer.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `MultipeerPeerState` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { enum class MultipeerPeerState; }
+// Forward declaration of `MultipeerDiscoveryInfoEntry` to properly resolve imports.
+namespace margelo::nitro::munimbluetooth { struct MultipeerDiscoveryInfoEntry; }
+
+#include <string>
+#include "MultipeerPeerState.hpp"
+#include "MultipeerDiscoveryInfoEntry.hpp"
+#include <vector>
+#include <optional>
+
+namespace margelo::nitro::munimbluetooth {
+
+  /**
+   * A struct which can be represented as a JavaScript object (MultipeerPeer).
+   */
+  struct MultipeerPeer final {
+  public:
+    std::string id     SWIFT_PRIVATE;
+    std::string displayName     SWIFT_PRIVATE;
+    MultipeerPeerState state     SWIFT_PRIVATE;
+    std::optional<std::vector<MultipeerDiscoveryInfoEntry>> discoveryInfo     SWIFT_PRIVATE;
+
+  public:
+    MultipeerPeer() = default;
+    explicit MultipeerPeer(std::string id, std::string displayName, MultipeerPeerState state, std::optional<std::vector<MultipeerDiscoveryInfoEntry>> discoveryInfo): id(id), displayName(displayName), state(state), discoveryInfo(discoveryInfo) {}
+
+  public:
+    friend bool operator==(const MultipeerPeer& lhs, const MultipeerPeer& rhs) = default;
+  };
+
+} // namespace margelo::nitro::munimbluetooth
+
+namespace margelo::nitro {
+
+  // C++ MultipeerPeer <> JS MultipeerPeer (object)
+  template <>
+  struct JSIConverter<margelo::nitro::munimbluetooth::MultipeerPeer> final {
+    static inline margelo::nitro::munimbluetooth::MultipeerPeer fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::munimbluetooth::MultipeerPeer(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "id"))),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "displayName"))),
+        JSIConverter<margelo::nitro::munimbluetooth::MultipeerPeerState>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "state"))),
+        JSIConverter<std::optional<std::vector<margelo::nitro::munimbluetooth::MultipeerDiscoveryInfoEntry>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "discoveryInfo")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::munimbluetooth::MultipeerPeer& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "id"), JSIConverter<std::string>::toJSI(runtime, arg.id));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "displayName"), JSIConverter<std::string>::toJSI(runtime, arg.displayName));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "state"), JSIConverter<margelo::nitro::munimbluetooth::MultipeerPeerState>::toJSI(runtime, arg.state));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "discoveryInfo"), JSIConverter<std::optional<std::vector<margelo::nitro::munimbluetooth::MultipeerDiscoveryInfoEntry>>>::toJSI(runtime, arg.discoveryInfo));
+      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 (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "id")))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "displayName")))) return false;
+      if (!JSIConverter<margelo::nitro::munimbluetooth::MultipeerPeerState>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "state")))) return false;
+      if (!JSIConverter<std::optional<std::vector<margelo::nitro::munimbluetooth::MultipeerDiscoveryInfoEntry>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "discoveryInfo")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,80 @@
+///
+/// MultipeerPeerState.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#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::munimbluetooth {
+
+  /**
+   * An enum which can be represented as a JavaScript union (MultipeerPeerState).
+   */
+  enum class MultipeerPeerState {
+    NOTCONNECTED      SWIFT_NAME(notconnected) = 0,
+    CONNECTING      SWIFT_NAME(connecting) = 1,
+    CONNECTED      SWIFT_NAME(connected) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::munimbluetooth
+
+namespace margelo::nitro {
+
+  // C++ MultipeerPeerState <> JS MultipeerPeerState (union)
+  template <>
+  struct JSIConverter<margelo::nitro::munimbluetooth::MultipeerPeerState> final {
+    static inline margelo::nitro::munimbluetooth::MultipeerPeerState fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("notConnected"): return margelo::nitro::munimbluetooth::MultipeerPeerState::NOTCONNECTED;
+        case hashString("connecting"): return margelo::nitro::munimbluetooth::MultipeerPeerState::CONNECTING;
+        case hashString("connected"): return margelo::nitro::munimbluetooth::MultipeerPeerState::CONNECTED;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum MultipeerPeerState - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::munimbluetooth::MultipeerPeerState arg) {
+      switch (arg) {
+        case margelo::nitro::munimbluetooth::MultipeerPeerState::NOTCONNECTED: return JSIConverter<std::string>::toJSI(runtime, "notConnected");
+        case margelo::nitro::munimbluetooth::MultipeerPeerState::CONNECTING: return JSIConverter<std::string>::toJSI(runtime, "connecting");
+        case margelo::nitro::munimbluetooth::MultipeerPeerState::CONNECTED: return JSIConverter<std::string>::toJSI(runtime, "connected");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert MultipeerPeerState to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("notConnected"):
+        case hashString("connecting"):
+        case hashString("connected"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro