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

package/nitrogen/generated/android/c++/JBleIOSErrorCode.hpp

@@ -0,0 +1,92 @@
+///
+/// JBleIOSErrorCode.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 <fbjni/fbjni.h>
+#include "BleIOSErrorCode.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "BleIOSErrorCode" and the the Kotlin enum "BleIOSErrorCode".
+   */
+  struct JBleIOSErrorCode final: public jni::JavaClass<JBleIOSErrorCode> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/BleIOSErrorCode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum BleIOSErrorCode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BleIOSErrorCode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("_ordinal");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<BleIOSErrorCode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JBleIOSErrorCode> fromCpp(BleIOSErrorCode value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldUNKNOWN = clazz->getStaticField<JBleIOSErrorCode>("UNKNOWN");
+      static const auto fieldINVALIDPARAMETERS = clazz->getStaticField<JBleIOSErrorCode>("INVALIDPARAMETERS");
+      static const auto fieldINVALIDHANDLE = clazz->getStaticField<JBleIOSErrorCode>("INVALIDHANDLE");
+      static const auto fieldNOTCONNECTED = clazz->getStaticField<JBleIOSErrorCode>("NOTCONNECTED");
+      static const auto fieldOUTOFSPACE = clazz->getStaticField<JBleIOSErrorCode>("OUTOFSPACE");
+      static const auto fieldOPERATIONCANCELLED = clazz->getStaticField<JBleIOSErrorCode>("OPERATIONCANCELLED");
+      static const auto fieldCONNECTIONTIMEOUT = clazz->getStaticField<JBleIOSErrorCode>("CONNECTIONTIMEOUT");
+      static const auto fieldPERIPHERALDISCONNECTED = clazz->getStaticField<JBleIOSErrorCode>("PERIPHERALDISCONNECTED");
+      static const auto fieldUUIDNOTALLOWED = clazz->getStaticField<JBleIOSErrorCode>("UUIDNOTALLOWED");
+      static const auto fieldALREADYADVERTISING = clazz->getStaticField<JBleIOSErrorCode>("ALREADYADVERTISING");
+      static const auto fieldCONNECTIONFAILED = clazz->getStaticField<JBleIOSErrorCode>("CONNECTIONFAILED");
+      static const auto fieldCONNECTIONLIMITREACHED = clazz->getStaticField<JBleIOSErrorCode>("CONNECTIONLIMITREACHED");
+      static const auto fieldUNKNOWNDEVICE = clazz->getStaticField<JBleIOSErrorCode>("UNKNOWNDEVICE");
+      
+      switch (value) {
+        case BleIOSErrorCode::UNKNOWN:
+          return clazz->getStaticFieldValue(fieldUNKNOWN);
+        case BleIOSErrorCode::INVALIDPARAMETERS:
+          return clazz->getStaticFieldValue(fieldINVALIDPARAMETERS);
+        case BleIOSErrorCode::INVALIDHANDLE:
+          return clazz->getStaticFieldValue(fieldINVALIDHANDLE);
+        case BleIOSErrorCode::NOTCONNECTED:
+          return clazz->getStaticFieldValue(fieldNOTCONNECTED);
+        case BleIOSErrorCode::OUTOFSPACE:
+          return clazz->getStaticFieldValue(fieldOUTOFSPACE);
+        case BleIOSErrorCode::OPERATIONCANCELLED:
+          return clazz->getStaticFieldValue(fieldOPERATIONCANCELLED);
+        case BleIOSErrorCode::CONNECTIONTIMEOUT:
+          return clazz->getStaticFieldValue(fieldCONNECTIONTIMEOUT);
+        case BleIOSErrorCode::PERIPHERALDISCONNECTED:
+          return clazz->getStaticFieldValue(fieldPERIPHERALDISCONNECTED);
+        case BleIOSErrorCode::UUIDNOTALLOWED:
+          return clazz->getStaticFieldValue(fieldUUIDNOTALLOWED);
+        case BleIOSErrorCode::ALREADYADVERTISING:
+          return clazz->getStaticFieldValue(fieldALREADYADVERTISING);
+        case BleIOSErrorCode::CONNECTIONFAILED:
+          return clazz->getStaticFieldValue(fieldCONNECTIONFAILED);
+        case BleIOSErrorCode::CONNECTIONLIMITREACHED:
+          return clazz->getStaticFieldValue(fieldCONNECTIONLIMITREACHED);
+        case BleIOSErrorCode::UNKNOWNDEVICE:
+          return clazz->getStaticFieldValue(fieldUNKNOWNDEVICE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JBleManagerNitroOptions.hpp

@@ -0,0 +1,54 @@
+///
+/// JBleManagerNitroOptions.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 <fbjni/fbjni.h>
+#include "BleManagerNitroOptions.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BleManagerNitroOptions" and the the Kotlin data class "BleManagerNitroOptions".
+   */
+  struct JBleManagerNitroOptions final: public jni::JavaClass<JBleManagerNitroOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/BleManagerNitroOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BleManagerNitroOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BleManagerNitroOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldRestoreStateIdentifier = clazz->getField<jni::JString>("restoreStateIdentifier");
+      jni::local_ref<jni::JString> restoreStateIdentifier = this->getFieldValue(fieldRestoreStateIdentifier);
+      return BleManagerNitroOptions(
+        restoreStateIdentifier != nullptr ? std::make_optional(restoreStateIdentifier->toStdString()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JBleManagerNitroOptions::javaobject> fromCpp(const BleManagerNitroOptions& value) {
+      return newInstance(
+        value.restoreStateIdentifier.has_value() ? jni::make_jstring(value.restoreStateIdentifier.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JBleRestoredState.hpp

@@ -0,0 +1,76 @@
+///
+/// JBleRestoredState.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 <fbjni/fbjni.h>
+#include "BleRestoredState.hpp"
+
+#include "JNativeDevice.hpp"
+#include "JServiceDataEntry.hpp"
+#include "NativeDevice.hpp"
+#include "ServiceDataEntry.hpp"
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BleRestoredState" and the the Kotlin data class "BleRestoredState".
+   */
+  struct JBleRestoredState final: public jni::JavaClass<JBleRestoredState> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/BleRestoredState;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BleRestoredState by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BleRestoredState toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldConnectedPeripherals = clazz->getField<jni::JArrayClass<JNativeDevice>>("connectedPeripherals");
+      jni::local_ref<jni::JArrayClass<JNativeDevice>> connectedPeripherals = this->getFieldValue(fieldConnectedPeripherals);
+      return BleRestoredState(
+        [&]() {
+          size_t __size = connectedPeripherals->size();
+          std::vector<NativeDevice> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = connectedPeripherals->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JBleRestoredState::javaobject> fromCpp(const BleRestoredState& value) {
+      return newInstance(
+        [&]() {
+          size_t __size = value.connectedPeripherals.size();
+          jni::local_ref<jni::JArrayClass<JNativeDevice>> __array = jni::JArrayClass<JNativeDevice>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.connectedPeripherals[__i];
+            __array->setElement(__i, *JNativeDevice::fromCpp(__element));
+          }
+          return __array;
+        }()
+      );
+    }
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JCharacteristicSubscriptionType.hpp

@@ -0,0 +1,59 @@
+///
+/// JCharacteristicSubscriptionType.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 <fbjni/fbjni.h>
+#include "CharacteristicSubscriptionType.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "CharacteristicSubscriptionType" and the the Kotlin enum "CharacteristicSubscriptionType".
+   */
+  struct JCharacteristicSubscriptionType final: public jni::JavaClass<JCharacteristicSubscriptionType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/CharacteristicSubscriptionType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum CharacteristicSubscriptionType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CharacteristicSubscriptionType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("_ordinal");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<CharacteristicSubscriptionType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JCharacteristicSubscriptionType> fromCpp(CharacteristicSubscriptionType value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldNOTIFICATION = clazz->getStaticField<JCharacteristicSubscriptionType>("NOTIFICATION");
+      static const auto fieldINDICATION = clazz->getStaticField<JCharacteristicSubscriptionType>("INDICATION");
+      
+      switch (value) {
+        case CharacteristicSubscriptionType::NOTIFICATION:
+          return clazz->getStaticFieldValue(fieldNOTIFICATION);
+        case CharacteristicSubscriptionType::INDICATION:
+          return clazz->getStaticFieldValue(fieldINDICATION);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JConnectionOptions.hpp

@@ -0,0 +1,61 @@
+///
+/// JConnectionOptions.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 <fbjni/fbjni.h>
+#include "ConnectionOptions.hpp"
+
+
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ConnectionOptions" and the the Kotlin data class "ConnectionOptions".
+   */
+  struct JConnectionOptions final: public jni::JavaClass<JConnectionOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/ConnectionOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ConnectionOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ConnectionOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAutoConnect = clazz->getField<jboolean>("autoConnect");
+      jboolean autoConnect = this->getFieldValue(fieldAutoConnect);
+      static const auto fieldRequestMTU = clazz->getField<double>("requestMTU");
+      double requestMTU = this->getFieldValue(fieldRequestMTU);
+      static const auto fieldTimeout = clazz->getField<double>("timeout");
+      double timeout = this->getFieldValue(fieldTimeout);
+      return ConnectionOptions(
+        static_cast<bool>(autoConnect),
+        requestMTU,
+        timeout
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JConnectionOptions::javaobject> fromCpp(const ConnectionOptions& value) {
+      return newInstance(
+        value.autoConnect,
+        value.requestMTU,
+        value.timeout
+      );
+    }
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JConnectionPriority.hpp

@@ -0,0 +1,62 @@
+///
+/// JConnectionPriority.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 <fbjni/fbjni.h>
+#include "ConnectionPriority.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ConnectionPriority" and the the Kotlin enum "ConnectionPriority".
+   */
+  struct JConnectionPriority final: public jni::JavaClass<JConnectionPriority> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/ConnectionPriority;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ConnectionPriority.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ConnectionPriority toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("_ordinal");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ConnectionPriority>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JConnectionPriority> fromCpp(ConnectionPriority value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldBALANCED = clazz->getStaticField<JConnectionPriority>("BALANCED");
+      static const auto fieldHIGH = clazz->getStaticField<JConnectionPriority>("HIGH");
+      static const auto fieldLOWPOWER = clazz->getStaticField<JConnectionPriority>("LOWPOWER");
+      
+      switch (value) {
+        case ConnectionPriority::BALANCED:
+          return clazz->getStaticFieldValue(fieldBALANCED);
+        case ConnectionPriority::HIGH:
+          return clazz->getStaticFieldValue(fieldHIGH);
+        case ConnectionPriority::LOWPOWER:
+          return clazz->getStaticFieldValue(fieldLOWPOWER);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JFunc_void.hpp

@@ -0,0 +1,74 @@
+///
+/// JFunc_void.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JFunc_void_State.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_State.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include "State.hpp"
+#include "JState.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(newState: State) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_State: public jni::JavaClass<JFunc_void_State> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_State;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_State` instance holds through JNI.
+     */
+    void invoke(State newState) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JState> /* newState */)>("invoke");
+      method(self(), JState::fromCpp(newState));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_State that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_State_cxx final: public jni::HybridClass<JFunc_void_State_cxx, JFunc_void_State> {
+  public:
+    static jni::local_ref<JFunc_void_State::javaobject> fromCpp(const std::function<void(State /* newState */)>& func) {
+      return JFunc_void_State_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_State_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JState> newState) {
+      _func(newState->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(State /* newState */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_State_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_State_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_State_cxx(const std::function<void(State /* newState */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(State /* newState */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

package/nitrogen/generated/android/c++/JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_.hpp

@@ -0,0 +1,88 @@
+///
+/// JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <optional>
+#include "NativeBleError.hpp"
+#include "NativeCharacteristic.hpp"
+#include "JNativeBleError.hpp"
+#include "BleErrorCode.hpp"
+#include "JBleErrorCode.hpp"
+#include "BleATTErrorCode.hpp"
+#include "JBleATTErrorCode.hpp"
+#include "BleIOSErrorCode.hpp"
+#include "JBleIOSErrorCode.hpp"
+#include "BleAndroidErrorCode.hpp"
+#include "JBleAndroidErrorCode.hpp"
+#include <string>
+#include "JNativeCharacteristic.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(error: NativeBleError?, characteristic: NativeCharacteristic?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_: public jni::JavaClass<JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_` instance holds through JNI.
+     */
+    void invoke(const std::optional<NativeBleError>& error, const std::optional<NativeCharacteristic>& characteristic) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JNativeBleError> /* error */, jni::alias_ref<JNativeCharacteristic> /* characteristic */)>("invoke");
+      method(self(), error.has_value() ? JNativeBleError::fromCpp(error.value()) : nullptr, characteristic.has_value() ? JNativeCharacteristic::fromCpp(characteristic.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__cxx final: public jni::HybridClass<JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__cxx, JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_> {
+  public:
+    static jni::local_ref<JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_::javaobject> fromCpp(const std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>& func) {
+      return JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JNativeBleError> error, jni::alias_ref<JNativeCharacteristic> characteristic) {
+      _func(error != nullptr ? std::make_optional(error->toCpp()) : std::nullopt, characteristic != nullptr ? std::make_optional(characteristic->toCpp()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__cxx(const std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble