react-native-ble-nitro 1.0.0-beta.9 → 1.1.0

package/nitrogen/generated/ios/BleNitro-Swift-Cxx-Bridge.hpp

@@ -8,92 +8,30 @@
 #pragma once
 
 // Forward declarations of C++ defined types
-// Forward declaration of `BleATTErrorCode` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class BleATTErrorCode; }
-// Forward declaration of `BleAndroidErrorCode` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class BleAndroidErrorCode; }
-// Forward declaration of `BleErrorCode` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class BleErrorCode; }
-// Forward declaration of `BleIOSErrorCode` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class BleIOSErrorCode; }
-// Forward declaration of `BleRestoredState` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct BleRestoredState; }
-// Forward declaration of `CharacteristicSubscriptionType` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class CharacteristicSubscriptionType; }
-// Forward declaration of `ConnectionOptions` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct ConnectionOptions; }
-// Forward declaration of `HybridBleManagerSpec` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { class HybridBleManagerSpec; }
-// Forward declaration of `HybridCharacteristicSpec` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { class HybridCharacteristicSpec; }
-// Forward declaration of `HybridDescriptorSpec` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { class HybridDescriptorSpec; }
-// Forward declaration of `HybridDeviceSpec` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { class HybridDeviceSpec; }
-// Forward declaration of `HybridServiceSpec` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { class HybridServiceSpec; }
-// Forward declaration of `LogLevel` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class LogLevel; }
-// 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 `NativeDescriptor` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct NativeDescriptor; }
-// Forward declaration of `NativeDevice` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct NativeDevice; }
-// Forward declaration of `NativeService` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct NativeService; }
-// Forward declaration of `ScanCallbackType` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class ScanCallbackType; }
-// Forward declaration of `ScanMode` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class ScanMode; }
-// Forward declaration of `ScanOptions` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct ScanOptions; }
-// Forward declaration of `ServiceDataEntry` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct ServiceDataEntry; }
-// Forward declaration of `State` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { enum class State; }
-// Forward declaration of `Subscription` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct Subscription; }
+// Forward declaration of `BLEDevice` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
+// Forward declaration of `BLEState` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
+// Forward declaration of `HybridNativeBleNitroSpec` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { class HybridNativeBleNitroSpec; }
+// Forward declaration of `ManufacturerDataEntry` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ManufacturerDataEntry; }
+// Forward declaration of `ManufacturerData` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ManufacturerData; }
+// Forward declaration of `OperationResult` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridBleManagerSpec_cxx` to properly resolve imports.
-namespace BleNitro { class HybridBleManagerSpec_cxx; }
-// Forward declaration of `HybridCharacteristicSpec_cxx` to properly resolve imports.
-namespace BleNitro { class HybridCharacteristicSpec_cxx; }
-// Forward declaration of `HybridDescriptorSpec_cxx` to properly resolve imports.
-namespace BleNitro { class HybridDescriptorSpec_cxx; }
-// Forward declaration of `HybridDeviceSpec_cxx` to properly resolve imports.
-namespace BleNitro { class HybridDeviceSpec_cxx; }
-// Forward declaration of `HybridServiceSpec_cxx` to properly resolve imports.
-namespace BleNitro { class HybridServiceSpec_cxx; }
+// Forward declaration of `HybridNativeBleNitroSpec_cxx` to properly resolve imports.
+namespace BleNitro { class HybridNativeBleNitroSpec_cxx; }
 
 // Include C++ defined types
-#include "BleATTErrorCode.hpp"
-#include "BleAndroidErrorCode.hpp"
-#include "BleErrorCode.hpp"
-#include "BleIOSErrorCode.hpp"
-#include "BleRestoredState.hpp"
-#include "CharacteristicSubscriptionType.hpp"
-#include "ConnectionOptions.hpp"
-#include "HybridBleManagerSpec.hpp"
-#include "HybridCharacteristicSpec.hpp"
-#include "HybridDescriptorSpec.hpp"
-#include "HybridDeviceSpec.hpp"
-#include "HybridServiceSpec.hpp"
-#include "LogLevel.hpp"
-#include "NativeBleError.hpp"
-#include "NativeCharacteristic.hpp"
-#include "NativeDescriptor.hpp"
-#include "NativeDevice.hpp"
-#include "NativeService.hpp"
-#include "ScanCallbackType.hpp"
-#include "ScanMode.hpp"
-#include "ScanOptions.hpp"
-#include "ServiceDataEntry.hpp"
-#include "State.hpp"
-#include "Subscription.hpp"
+#include "BLEDevice.hpp"
+#include "BLEState.hpp"
+#include "HybridNativeBleNitroSpec.hpp"
+#include "ManufacturerData.hpp"
+#include "ManufacturerDataEntry.hpp"
+#include "OperationResult.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -110,100 +48,6 @@ namespace BleNitro { class HybridServiceSpec_cxx; }
  */
 namespace margelo::nitro::co::zyke::ble::bridge::swift {
 
-  // pragma MARK: std::shared_ptr<Promise<void>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<void>>`.
-   */
-  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
-  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() {
-    return Promise<void>::create();
-  }
-  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) {
-    return PromiseHolder<void>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void()>
-  /**
-   * Specialized version of `std::function<void()>`.
-   */
-  using Func_void = std::function<void()>;
-  /**
-   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
-   */
-  class Func_void_Wrapper final {
-  public:
-    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
-    inline void call() const {
-      _function->operator()();
-    }
-  private:
-    std::unique_ptr<std::function<void()>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_Wrapper wrap_Func_void(Func_void value) {
-    return Func_void_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
-  /**
-   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
-   */
-  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__exception_ptr_Wrapper final {
-  public:
-    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
-    inline void call(std::exception_ptr error) const {
-      _function->operator()(error);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) {
-    return Func_void_std__exception_ptr_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::optional<std::string>
-  /**
-   * Specialized version of `std::optional<std::string>`.
-   */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) {
-    return std::optional<std::string>(value);
-  }
-  
-  // pragma MARK: std::optional<double>
-  /**
-   * Specialized version of `std::optional<double>`.
-   */
-  using std__optional_double_ = std::optional<double>;
-  inline std::optional<double> create_std__optional_double_(const double& value) {
-    return std::optional<double>(value);
-  }
-  
-  // pragma MARK: std::vector<ServiceDataEntry>
-  /**
-   * Specialized version of `std::vector<ServiceDataEntry>`.
-   */
-  using std__vector_ServiceDataEntry_ = std::vector<ServiceDataEntry>;
-  inline std::vector<ServiceDataEntry> create_std__vector_ServiceDataEntry_(size_t size) {
-    std::vector<ServiceDataEntry> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
-  // pragma MARK: std::optional<std::vector<ServiceDataEntry>>
-  /**
-   * Specialized version of `std::optional<std::vector<ServiceDataEntry>>`.
-   */
-  using std__optional_std__vector_ServiceDataEntry__ = std::optional<std::vector<ServiceDataEntry>>;
-  inline std::optional<std::vector<ServiceDataEntry>> create_std__optional_std__vector_ServiceDataEntry__(const std::vector<ServiceDataEntry>& value) {
-    return std::optional<std::vector<ServiceDataEntry>>(value);
-  }
-  
   // pragma MARK: std::vector<std::string>
   /**
    * Specialized version of `std::vector<std::string>`.
@@ -215,605 +59,332 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<std::vector<std::string>>
-  /**
-   * Specialized version of `std::optional<std::vector<std::string>>`.
-   */
-  using std__optional_std__vector_std__string__ = std::optional<std::vector<std::string>>;
-  inline std::optional<std::vector<std::string>> create_std__optional_std__vector_std__string__(const std::vector<std::string>& value) {
-    return std::optional<std::vector<std::string>>(value);
-  }
-  
-  // pragma MARK: std::optional<bool>
+  // pragma MARK: std::vector<double>
   /**
-   * Specialized version of `std::optional<bool>`.
+   * Specialized version of `std::vector<double>`.
    */
-  using std__optional_bool_ = std::optional<bool>;
-  inline std::optional<bool> create_std__optional_bool_(const bool& value) {
-    return std::optional<bool>(value);
-  }
-  
-  // pragma MARK: std::vector<NativeDevice>
-  /**
-   * Specialized version of `std::vector<NativeDevice>`.
-   */
-  using std__vector_NativeDevice_ = std::vector<NativeDevice>;
-  inline std::vector<NativeDevice> create_std__vector_NativeDevice_(size_t size) {
-    std::vector<NativeDevice> vector;
+  using std__vector_double_ = std::vector<double>;
+  inline std::vector<double> create_std__vector_double_(size_t size) {
+    std::vector<double> vector;
     vector.reserve(size);
     return vector;
   }
   
-  // pragma MARK: std::optional<BleRestoredState>
-  /**
-   * Specialized version of `std::optional<BleRestoredState>`.
-   */
-  using std__optional_BleRestoredState_ = std::optional<BleRestoredState>;
-  inline std::optional<BleRestoredState> create_std__optional_BleRestoredState_(const BleRestoredState& value) {
-    return std::optional<BleRestoredState>(value);
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::optional<BleRestoredState>>>
+  // pragma MARK: std::vector<ManufacturerDataEntry>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::optional<BleRestoredState>>>`.
+   * Specialized version of `std::vector<ManufacturerDataEntry>`.
    */
-  using std__shared_ptr_Promise_std__optional_BleRestoredState___ = std::shared_ptr<Promise<std::optional<BleRestoredState>>>;
-  inline std::shared_ptr<Promise<std::optional<BleRestoredState>>> create_std__shared_ptr_Promise_std__optional_BleRestoredState___() {
-    return Promise<std::optional<BleRestoredState>>::create();
-  }
-  inline PromiseHolder<std::optional<BleRestoredState>> wrap_std__shared_ptr_Promise_std__optional_BleRestoredState___(std::shared_ptr<Promise<std::optional<BleRestoredState>>> promise) {
-    return PromiseHolder<std::optional<BleRestoredState>>(std::move(promise));
+  using std__vector_ManufacturerDataEntry_ = std::vector<ManufacturerDataEntry>;
+  inline std::vector<ManufacturerDataEntry> create_std__vector_ManufacturerDataEntry_(size_t size) {
+    std::vector<ManufacturerDataEntry> vector;
+    vector.reserve(size);
+    return vector;
   }
   
-  // pragma MARK: std::function<void(const std::optional<BleRestoredState>& /* result */)>
+  // pragma MARK: std::function<void(const BLEDevice& /* device */)>
   /**
-   * Specialized version of `std::function<void(const std::optional<BleRestoredState>&)>`.
+   * Specialized version of `std::function<void(const BLEDevice&)>`.
    */
-  using Func_void_std__optional_BleRestoredState_ = std::function<void(const std::optional<BleRestoredState>& /* result */)>;
+  using Func_void_BLEDevice = std::function<void(const BLEDevice& /* device */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::optional<BleRestoredState>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const BLEDevice& / * device * /)>`, this can be used from Swift.
    */
-  class Func_void_std__optional_BleRestoredState__Wrapper final {
+  class Func_void_BLEDevice_Wrapper final {
   public:
-    explicit Func_void_std__optional_BleRestoredState__Wrapper(std::function<void(const std::optional<BleRestoredState>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<BleRestoredState>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<BleRestoredState> result) const {
-      _function->operator()(result);
+    explicit Func_void_BLEDevice_Wrapper(std::function<void(const BLEDevice& /* device */)>&& func): _function(std::make_unique<std::function<void(const BLEDevice& /* device */)>>(std::move(func))) {}
+    inline void call(BLEDevice device) const {
+      _function->operator()(device);
     }
   private:
-    std::unique_ptr<std::function<void(const std::optional<BleRestoredState>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const BLEDevice& /* device */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_BleRestoredState_ create_Func_void_std__optional_BleRestoredState_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__optional_BleRestoredState__Wrapper wrap_Func_void_std__optional_BleRestoredState_(Func_void_std__optional_BleRestoredState_ value) {
-    return Func_void_std__optional_BleRestoredState__Wrapper(std::move(value));
+  Func_void_BLEDevice create_Func_void_BLEDevice(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_BLEDevice_Wrapper wrap_Func_void_BLEDevice(Func_void_BLEDevice value) {
+    return Func_void_BLEDevice_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<LogLevel>>
+  // pragma MARK: std::vector<BLEDevice>
   /**
-   * Specialized version of `std::shared_ptr<Promise<LogLevel>>`.
+   * Specialized version of `std::vector<BLEDevice>`.
    */
-  using std__shared_ptr_Promise_LogLevel__ = std::shared_ptr<Promise<LogLevel>>;
-  inline std::shared_ptr<Promise<LogLevel>> create_std__shared_ptr_Promise_LogLevel__() {
-    return Promise<LogLevel>::create();
-  }
-  inline PromiseHolder<LogLevel> wrap_std__shared_ptr_Promise_LogLevel__(std::shared_ptr<Promise<LogLevel>> promise) {
-    return PromiseHolder<LogLevel>(std::move(promise));
+  using std__vector_BLEDevice_ = std::vector<BLEDevice>;
+  inline std::vector<BLEDevice> create_std__vector_BLEDevice_(size_t size) {
+    std::vector<BLEDevice> vector;
+    vector.reserve(size);
+    return vector;
   }
   
-  // pragma MARK: std::function<void(LogLevel /* result */)>
+  // pragma MARK: std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>
   /**
-   * Specialized version of `std::function<void(LogLevel)>`.
+   * Specialized version of `std::function<void(bool, const std::string&, const std::string&)>`.
    */
-  using Func_void_LogLevel = std::function<void(LogLevel /* result */)>;
+  using Func_void_bool_std__string_std__string = std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>;
   /**
-   * Wrapper class for a `std::function<void(LogLevel / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(bool / * success * /, const std::string& / * deviceId * /, const std::string& / * error * /)>`, this can be used from Swift.
    */
-  class Func_void_LogLevel_Wrapper final {
+  class Func_void_bool_std__string_std__string_Wrapper final {
   public:
-    explicit Func_void_LogLevel_Wrapper(std::function<void(LogLevel /* result */)>&& func): _function(std::make_unique<std::function<void(LogLevel /* result */)>>(std::move(func))) {}
-    inline void call(int result) const {
-      _function->operator()(static_cast<LogLevel>(result));
+    explicit Func_void_bool_std__string_std__string_Wrapper(std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>&& func): _function(std::make_unique<std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>>(std::move(func))) {}
+    inline void call(bool success, std::string deviceId, std::string error) const {
+      _function->operator()(success, deviceId, error);
     }
   private:
-    std::unique_ptr<std::function<void(LogLevel /* result */)>> _function;
+    std::unique_ptr<std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_LogLevel create_Func_void_LogLevel(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_LogLevel_Wrapper wrap_Func_void_LogLevel(Func_void_LogLevel value) {
-    return Func_void_LogLevel_Wrapper(std::move(value));
+  Func_void_bool_std__string_std__string create_Func_void_bool_std__string_std__string(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_bool_std__string_std__string_Wrapper wrap_Func_void_bool_std__string_std__string(Func_void_bool_std__string_std__string value) {
+    return Func_void_bool_std__string_std__string_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<State>>
+  // pragma MARK: std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>
   /**
-   * Specialized version of `std::shared_ptr<Promise<State>>`.
+   * Specialized version of `std::function<void(const std::string&, bool, const std::string&)>`.
    */
-  using std__shared_ptr_Promise_State__ = std::shared_ptr<Promise<State>>;
-  inline std::shared_ptr<Promise<State>> create_std__shared_ptr_Promise_State__() {
-    return Promise<State>::create();
-  }
-  inline PromiseHolder<State> wrap_std__shared_ptr_Promise_State__(std::shared_ptr<Promise<State>> promise) {
-    return PromiseHolder<State>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(State /* result */)>
+  using Func_void_std__string_bool_std__string = std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>;
   /**
-   * Specialized version of `std::function<void(State)>`.
+   * Wrapper class for a `std::function<void(const std::string& / * deviceId * /, bool / * interrupted * /, const std::string& / * error * /)>`, this can be used from Swift.
    */
-  using Func_void_State = std::function<void(State /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(State / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_State_Wrapper final {
+  class Func_void_std__string_bool_std__string_Wrapper final {
   public:
-    explicit Func_void_State_Wrapper(std::function<void(State /* result */)>&& func): _function(std::make_unique<std::function<void(State /* result */)>>(std::move(func))) {}
-    inline void call(int result) const {
-      _function->operator()(static_cast<State>(result));
+    explicit Func_void_std__string_bool_std__string_Wrapper(std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>(std::move(func))) {}
+    inline void call(std::string deviceId, bool interrupted, std::string error) const {
+      _function->operator()(deviceId, interrupted, error);
     }
   private:
-    std::unique_ptr<std::function<void(State /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_State create_Func_void_State(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_State_Wrapper wrap_Func_void_State(Func_void_State value) {
-    return Func_void_State_Wrapper(std::move(value));
+  Func_void_std__string_bool_std__string create_Func_void_std__string_bool_std__string(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__string_bool_std__string_Wrapper wrap_Func_void_std__string_bool_std__string(Func_void_std__string_bool_std__string value) {
+    return Func_void_std__string_bool_std__string_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<ScanMode>
+  // pragma MARK: std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>
   /**
-   * Specialized version of `std::optional<ScanMode>`.
+   * Specialized version of `std::optional<std::function<void(const std::string& / * deviceId * /, bool / * interrupted * /, const std::string& / * error * /)>>`.
    */
-  using std__optional_ScanMode_ = std::optional<ScanMode>;
-  inline std::optional<ScanMode> create_std__optional_ScanMode_(const ScanMode& value) {
-    return std::optional<ScanMode>(value);
+  using std__optional_std__function_void_const_std__string_____deviceId_____bool____interrupted_____const_std__string_____error______ = std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>;
+  inline std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>> create_std__optional_std__function_void_const_std__string_____deviceId_____bool____interrupted_____const_std__string_____error______(const std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>& value) {
+    return std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>(value);
   }
   
-  // pragma MARK: std::optional<ScanCallbackType>
+  // pragma MARK: std::function<void(bool /* success */, const std::string& /* error */)>
   /**
-   * Specialized version of `std::optional<ScanCallbackType>`.
+   * Specialized version of `std::function<void(bool, const std::string&)>`.
    */
-  using std__optional_ScanCallbackType_ = std::optional<ScanCallbackType>;
-  inline std::optional<ScanCallbackType> create_std__optional_ScanCallbackType_(const ScanCallbackType& value) {
-    return std::optional<ScanCallbackType>(value);
-  }
-  
-  // pragma MARK: std::optional<ScanOptions>
-  /**
-   * Specialized version of `std::optional<ScanOptions>`.
-   */
-  using std__optional_ScanOptions_ = std::optional<ScanOptions>;
-  inline std::optional<ScanOptions> create_std__optional_ScanOptions_(const ScanOptions& value) {
-    return std::optional<ScanOptions>(value);
-  }
-  
-  // pragma MARK: std::optional<BleATTErrorCode>
+  using Func_void_bool_std__string = std::function<void(bool /* success */, const std::string& /* error */)>;
   /**
-   * Specialized version of `std::optional<BleATTErrorCode>`.
+   * Wrapper class for a `std::function<void(bool / * success * /, const std::string& / * error * /)>`, this can be used from Swift.
    */
-  using std__optional_BleATTErrorCode_ = std::optional<BleATTErrorCode>;
-  inline std::optional<BleATTErrorCode> create_std__optional_BleATTErrorCode_(const BleATTErrorCode& value) {
-    return std::optional<BleATTErrorCode>(value);
-  }
-  
-  // pragma MARK: std::optional<BleIOSErrorCode>
-  /**
-   * Specialized version of `std::optional<BleIOSErrorCode>`.
-   */
-  using std__optional_BleIOSErrorCode_ = std::optional<BleIOSErrorCode>;
-  inline std::optional<BleIOSErrorCode> create_std__optional_BleIOSErrorCode_(const BleIOSErrorCode& value) {
-    return std::optional<BleIOSErrorCode>(value);
-  }
-  
-  // pragma MARK: std::optional<BleAndroidErrorCode>
-  /**
-   * Specialized version of `std::optional<BleAndroidErrorCode>`.
-   */
-  using std__optional_BleAndroidErrorCode_ = std::optional<BleAndroidErrorCode>;
-  inline std::optional<BleAndroidErrorCode> create_std__optional_BleAndroidErrorCode_(const BleAndroidErrorCode& value) {
-    return std::optional<BleAndroidErrorCode>(value);
-  }
-  
-  // pragma MARK: std::optional<NativeBleError>
-  /**
-   * Specialized version of `std::optional<NativeBleError>`.
-   */
-  using std__optional_NativeBleError_ = std::optional<NativeBleError>;
-  inline std::optional<NativeBleError> create_std__optional_NativeBleError_(const NativeBleError& value) {
-    return std::optional<NativeBleError>(value);
-  }
-  
-  // pragma MARK: std::optional<NativeDevice>
-  /**
-   * Specialized version of `std::optional<NativeDevice>`.
-   */
-  using std__optional_NativeDevice_ = std::optional<NativeDevice>;
-  inline std::optional<NativeDevice> create_std__optional_NativeDevice_(const NativeDevice& value) {
-    return std::optional<NativeDevice>(value);
-  }
-  
-  // pragma MARK: std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeDevice>& /* scannedDevice */)>
-  /**
-   * Specialized version of `std::function<void(const std::optional<NativeBleError>&, const std::optional<NativeDevice>&)>`.
-   */
-  using Func_void_std__optional_NativeBleError__std__optional_NativeDevice_ = std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeDevice>& /* scannedDevice */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::optional<NativeBleError>& / * error * /, const std::optional<NativeDevice>& / * scannedDevice * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__optional_NativeBleError__std__optional_NativeDevice__Wrapper final {
+  class Func_void_bool_std__string_Wrapper final {
   public:
-    explicit Func_void_std__optional_NativeBleError__std__optional_NativeDevice__Wrapper(std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeDevice>& /* scannedDevice */)>&& func): _function(std::make_unique<std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeDevice>& /* scannedDevice */)>>(std::move(func))) {}
-    inline void call(std::optional<NativeBleError> error, std::optional<NativeDevice> scannedDevice) const {
-      _function->operator()(error, scannedDevice);
+    explicit Func_void_bool_std__string_Wrapper(std::function<void(bool /* success */, const std::string& /* error */)>&& func): _function(std::make_unique<std::function<void(bool /* success */, const std::string& /* error */)>>(std::move(func))) {}
+    inline void call(bool success, std::string error) const {
+      _function->operator()(success, error);
     }
   private:
-    std::unique_ptr<std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeDevice>& /* scannedDevice */)>> _function;
+    std::unique_ptr<std::function<void(bool /* success */, const std::string& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_NativeBleError__std__optional_NativeDevice_ create_Func_void_std__optional_NativeBleError__std__optional_NativeDevice_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__optional_NativeBleError__std__optional_NativeDevice__Wrapper wrap_Func_void_std__optional_NativeBleError__std__optional_NativeDevice_(Func_void_std__optional_NativeBleError__std__optional_NativeDevice_ value) {
-    return Func_void_std__optional_NativeBleError__std__optional_NativeDevice__Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<NativeDevice>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<NativeDevice>>`.
-   */
-  using std__shared_ptr_Promise_NativeDevice__ = std::shared_ptr<Promise<NativeDevice>>;
-  inline std::shared_ptr<Promise<NativeDevice>> create_std__shared_ptr_Promise_NativeDevice__() {
-    return Promise<NativeDevice>::create();
-  }
-  inline PromiseHolder<NativeDevice> wrap_std__shared_ptr_Promise_NativeDevice__(std::shared_ptr<Promise<NativeDevice>> promise) {
-    return PromiseHolder<NativeDevice>(std::move(promise));
+  Func_void_bool_std__string create_Func_void_bool_std__string(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_bool_std__string_Wrapper wrap_Func_void_bool_std__string(Func_void_bool_std__string value) {
+    return Func_void_bool_std__string_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::function<void(const NativeDevice& /* result */)>
+  // pragma MARK: std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>
   /**
-   * Specialized version of `std::function<void(const NativeDevice&)>`.
+   * Specialized version of `std::function<void(bool, const std::vector<double>&, const std::string&)>`.
    */
-  using Func_void_NativeDevice = std::function<void(const NativeDevice& /* result */)>;
+  using Func_void_bool_std__vector_double__std__string = std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>;
   /**
-   * Wrapper class for a `std::function<void(const NativeDevice& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(bool / * success * /, const std::vector<double>& / * data * /, const std::string& / * error * /)>`, this can be used from Swift.
    */
-  class Func_void_NativeDevice_Wrapper final {
+  class Func_void_bool_std__vector_double__std__string_Wrapper final {
   public:
-    explicit Func_void_NativeDevice_Wrapper(std::function<void(const NativeDevice& /* result */)>&& func): _function(std::make_unique<std::function<void(const NativeDevice& /* result */)>>(std::move(func))) {}
-    inline void call(NativeDevice result) const {
-      _function->operator()(result);
+    explicit Func_void_bool_std__vector_double__std__string_Wrapper(std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>&& func): _function(std::make_unique<std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>>(std::move(func))) {}
+    inline void call(bool success, std::vector<double> data, std::string error) const {
+      _function->operator()(success, data, error);
     }
   private:
-    std::unique_ptr<std::function<void(const NativeDevice& /* result */)>> _function;
+    std::unique_ptr<std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_NativeDevice create_Func_void_NativeDevice(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_NativeDevice_Wrapper wrap_Func_void_NativeDevice(Func_void_NativeDevice value) {
-    return Func_void_NativeDevice_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::vector<NativeDevice>>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::vector<NativeDevice>>>`.
-   */
-  using std__shared_ptr_Promise_std__vector_NativeDevice___ = std::shared_ptr<Promise<std::vector<NativeDevice>>>;
-  inline std::shared_ptr<Promise<std::vector<NativeDevice>>> create_std__shared_ptr_Promise_std__vector_NativeDevice___() {
-    return Promise<std::vector<NativeDevice>>::create();
-  }
-  inline PromiseHolder<std::vector<NativeDevice>> wrap_std__shared_ptr_Promise_std__vector_NativeDevice___(std::shared_ptr<Promise<std::vector<NativeDevice>>> promise) {
-    return PromiseHolder<std::vector<NativeDevice>>(std::move(promise));
+  Func_void_bool_std__vector_double__std__string create_Func_void_bool_std__vector_double__std__string(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_bool_std__vector_double__std__string_Wrapper wrap_Func_void_bool_std__vector_double__std__string(Func_void_bool_std__vector_double__std__string value) {
+    return Func_void_bool_std__vector_double__std__string_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::function<void(const std::vector<NativeDevice>& /* result */)>
+  // pragma MARK: std::function<void(const std::string& /* characteristicId */, const std::vector<double>& /* data */)>
   /**
-   * Specialized version of `std::function<void(const std::vector<NativeDevice>&)>`.
+   * Specialized version of `std::function<void(const std::string&, const std::vector<double>&)>`.
    */
-  using Func_void_std__vector_NativeDevice_ = std::function<void(const std::vector<NativeDevice>& /* result */)>;
+  using Func_void_std__string_std__vector_double_ = std::function<void(const std::string& /* characteristicId */, const std::vector<double>& /* data */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::vector<NativeDevice>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::string& / * characteristicId * /, const std::vector<double>& / * data * /)>`, this can be used from Swift.
    */
-  class Func_void_std__vector_NativeDevice__Wrapper final {
+  class Func_void_std__string_std__vector_double__Wrapper final {
   public:
-    explicit Func_void_std__vector_NativeDevice__Wrapper(std::function<void(const std::vector<NativeDevice>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<NativeDevice>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<NativeDevice> result) const {
-      _function->operator()(result);
+    explicit Func_void_std__string_std__vector_double__Wrapper(std::function<void(const std::string& /* characteristicId */, const std::vector<double>& /* data */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* characteristicId */, const std::vector<double>& /* data */)>>(std::move(func))) {}
+    inline void call(std::string characteristicId, std::vector<double> data) const {
+      _function->operator()(characteristicId, data);
     }
   private:
-    std::unique_ptr<std::function<void(const std::vector<NativeDevice>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::string& /* characteristicId */, const std::vector<double>& /* data */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_NativeDevice_ create_Func_void_std__vector_NativeDevice_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_NativeDevice__Wrapper wrap_Func_void_std__vector_NativeDevice_(Func_void_std__vector_NativeDevice_ value) {
-    return Func_void_std__vector_NativeDevice__Wrapper(std::move(value));
+  Func_void_std__string_std__vector_double_ create_Func_void_std__string_std__vector_double_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__string_std__vector_double__Wrapper wrap_Func_void_std__string_std__vector_double_(Func_void_std__string_std__vector_double_ value) {
+    return Func_void_std__string_std__vector_double__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<ConnectionOptions>
-  /**
-   * Specialized version of `std::optional<ConnectionOptions>`.
-   */
-  using std__optional_ConnectionOptions_ = std::optional<ConnectionOptions>;
-  inline std::optional<ConnectionOptions> create_std__optional_ConnectionOptions_(const ConnectionOptions& value) {
-    return std::optional<ConnectionOptions>(value);
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<bool>>
+  // pragma MARK: std::optional<std::string>
   /**
-   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   * Specialized version of `std::optional<std::string>`.
    */
-  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
-  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() {
-    return Promise<bool>::create();
-  }
-  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) {
-    return PromiseHolder<bool>(std::move(promise));
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) {
+    return std::optional<std::string>(value);
   }
   
-  // pragma MARK: std::function<void(bool /* result */)>
+  // pragma MARK: std::function<void(BLEState /* state */)>
   /**
-   * Specialized version of `std::function<void(bool)>`.
+   * Specialized version of `std::function<void(BLEState)>`.
    */
-  using Func_void_bool = std::function<void(bool /* result */)>;
+  using Func_void_BLEState = std::function<void(BLEState /* state */)>;
   /**
-   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(BLEState / * state * /)>`, this can be used from Swift.
    */
-  class Func_void_bool_Wrapper final {
+  class Func_void_BLEState_Wrapper final {
   public:
-    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
-    inline void call(bool result) const {
-      _function->operator()(result);
+    explicit Func_void_BLEState_Wrapper(std::function<void(BLEState /* state */)>&& func): _function(std::make_unique<std::function<void(BLEState /* state */)>>(std::move(func))) {}
+    inline void call(int state) const {
+      _function->operator()(static_cast<BLEState>(state));
     }
   private:
-    std::unique_ptr<std::function<void(bool /* result */)>> _function;
+    std::unique_ptr<std::function<void(BLEState /* state */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_bool create_Func_void_bool(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) {
-    return Func_void_bool_Wrapper(std::move(value));
+  Func_void_BLEState create_Func_void_BLEState(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_BLEState_Wrapper wrap_Func_void_BLEState(Func_void_BLEState value) {
+    return Func_void_BLEState_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::vector<NativeService>
-  /**
-   * Specialized version of `std::vector<NativeService>`.
-   */
-  using std__vector_NativeService_ = std::vector<NativeService>;
-  inline std::vector<NativeService> create_std__vector_NativeService_(size_t size) {
-    std::vector<NativeService> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::vector<NativeService>>>
+  // pragma MARK: std::shared_ptr<Promise<void>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::vector<NativeService>>>`.
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
    */
-  using std__shared_ptr_Promise_std__vector_NativeService___ = std::shared_ptr<Promise<std::vector<NativeService>>>;
-  inline std::shared_ptr<Promise<std::vector<NativeService>>> create_std__shared_ptr_Promise_std__vector_NativeService___() {
-    return Promise<std::vector<NativeService>>::create();
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() {
+    return Promise<void>::create();
   }
-  inline PromiseHolder<std::vector<NativeService>> wrap_std__shared_ptr_Promise_std__vector_NativeService___(std::shared_ptr<Promise<std::vector<NativeService>>> promise) {
-    return PromiseHolder<std::vector<NativeService>>(std::move(promise));
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) {
+    return PromiseHolder<void>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::vector<NativeService>& /* result */)>
+  // pragma MARK: std::function<void()>
   /**
-   * Specialized version of `std::function<void(const std::vector<NativeService>&)>`.
+   * Specialized version of `std::function<void()>`.
    */
-  using Func_void_std__vector_NativeService_ = std::function<void(const std::vector<NativeService>& /* result */)>;
+  using Func_void = std::function<void()>;
   /**
-   * Wrapper class for a `std::function<void(const std::vector<NativeService>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
    */
-  class Func_void_std__vector_NativeService__Wrapper final {
+  class Func_void_Wrapper final {
   public:
-    explicit Func_void_std__vector_NativeService__Wrapper(std::function<void(const std::vector<NativeService>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<NativeService>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<NativeService> result) const {
-      _function->operator()(result);
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const {
+      _function->operator()();
     }
   private:
-    std::unique_ptr<std::function<void(const std::vector<NativeService>& /* result */)>> _function;
+    std::unique_ptr<std::function<void()>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_NativeService_ create_Func_void_std__vector_NativeService_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_NativeService__Wrapper wrap_Func_void_std__vector_NativeService_(Func_void_std__vector_NativeService_ value) {
-    return Func_void_std__vector_NativeService__Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::vector<NativeCharacteristic>
-  /**
-   * Specialized version of `std::vector<NativeCharacteristic>`.
-   */
-  using std__vector_NativeCharacteristic_ = std::vector<NativeCharacteristic>;
-  inline std::vector<NativeCharacteristic> create_std__vector_NativeCharacteristic_(size_t size) {
-    std::vector<NativeCharacteristic> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::vector<NativeCharacteristic>>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::vector<NativeCharacteristic>>>`.
-   */
-  using std__shared_ptr_Promise_std__vector_NativeCharacteristic___ = std::shared_ptr<Promise<std::vector<NativeCharacteristic>>>;
-  inline std::shared_ptr<Promise<std::vector<NativeCharacteristic>>> create_std__shared_ptr_Promise_std__vector_NativeCharacteristic___() {
-    return Promise<std::vector<NativeCharacteristic>>::create();
-  }
-  inline PromiseHolder<std::vector<NativeCharacteristic>> wrap_std__shared_ptr_Promise_std__vector_NativeCharacteristic___(std::shared_ptr<Promise<std::vector<NativeCharacteristic>>> promise) {
-    return PromiseHolder<std::vector<NativeCharacteristic>>(std::move(promise));
+  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) {
+    return Func_void_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::function<void(const std::vector<NativeCharacteristic>& /* result */)>
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
   /**
-   * Specialized version of `std::function<void(const std::vector<NativeCharacteristic>&)>`.
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
    */
-  using Func_void_std__vector_NativeCharacteristic_ = std::function<void(const std::vector<NativeCharacteristic>& /* result */)>;
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::vector<NativeCharacteristic>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
    */
-  class Func_void_std__vector_NativeCharacteristic__Wrapper final {
+  class Func_void_std__exception_ptr_Wrapper final {
   public:
-    explicit Func_void_std__vector_NativeCharacteristic__Wrapper(std::function<void(const std::vector<NativeCharacteristic>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<NativeCharacteristic>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<NativeCharacteristic> result) const {
-      _function->operator()(result);
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const {
+      _function->operator()(error);
     }
   private:
-    std::unique_ptr<std::function<void(const std::vector<NativeCharacteristic>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_NativeCharacteristic_ create_Func_void_std__vector_NativeCharacteristic_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_NativeCharacteristic__Wrapper wrap_Func_void_std__vector_NativeCharacteristic_(Func_void_std__vector_NativeCharacteristic_ value) {
-    return Func_void_std__vector_NativeCharacteristic__Wrapper(std::move(value));
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) {
+    return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<NativeCharacteristic>>
+  // pragma MARK: std::shared_ptr<HybridNativeBleNitroSpec>
   /**
-   * Specialized version of `std::shared_ptr<Promise<NativeCharacteristic>>`.
+   * Specialized version of `std::shared_ptr<HybridNativeBleNitroSpec>`.
    */
-  using std__shared_ptr_Promise_NativeCharacteristic__ = std::shared_ptr<Promise<NativeCharacteristic>>;
-  inline std::shared_ptr<Promise<NativeCharacteristic>> create_std__shared_ptr_Promise_NativeCharacteristic__() {
-    return Promise<NativeCharacteristic>::create();
-  }
-  inline PromiseHolder<NativeCharacteristic> wrap_std__shared_ptr_Promise_NativeCharacteristic__(std::shared_ptr<Promise<NativeCharacteristic>> promise) {
-    return PromiseHolder<NativeCharacteristic>(std::move(promise));
-  }
+  using std__shared_ptr_HybridNativeBleNitroSpec_ = std::shared_ptr<HybridNativeBleNitroSpec>;
+  std::shared_ptr<HybridNativeBleNitroSpec> create_std__shared_ptr_HybridNativeBleNitroSpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_HybridNativeBleNitroSpec_(std__shared_ptr_HybridNativeBleNitroSpec_ cppType);
   
-  // pragma MARK: std::function<void(const NativeCharacteristic& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const NativeCharacteristic&)>`.
-   */
-  using Func_void_NativeCharacteristic = std::function<void(const NativeCharacteristic& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const NativeCharacteristic& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_NativeCharacteristic_Wrapper final {
-  public:
-    explicit Func_void_NativeCharacteristic_Wrapper(std::function<void(const NativeCharacteristic& /* result */)>&& func): _function(std::make_unique<std::function<void(const NativeCharacteristic& /* result */)>>(std::move(func))) {}
-    inline void call(NativeCharacteristic result) const {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const NativeCharacteristic& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_NativeCharacteristic create_Func_void_NativeCharacteristic(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_NativeCharacteristic_Wrapper wrap_Func_void_NativeCharacteristic(Func_void_NativeCharacteristic value) {
-    return Func_void_NativeCharacteristic_Wrapper(std::move(value));
-  }
+  // pragma MARK: std::weak_ptr<HybridNativeBleNitroSpec>
+  using std__weak_ptr_HybridNativeBleNitroSpec_ = std::weak_ptr<HybridNativeBleNitroSpec>;
+  inline std__weak_ptr_HybridNativeBleNitroSpec_ weakify_std__shared_ptr_HybridNativeBleNitroSpec_(const std::shared_ptr<HybridNativeBleNitroSpec>& strong) { return strong; }
   
-  // pragma MARK: std::optional<NativeCharacteristic>
-  /**
-   * Specialized version of `std::optional<NativeCharacteristic>`.
-   */
-  using std__optional_NativeCharacteristic_ = std::optional<NativeCharacteristic>;
-  inline std::optional<NativeCharacteristic> create_std__optional_NativeCharacteristic_(const NativeCharacteristic& value) {
-    return std::optional<NativeCharacteristic>(value);
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() {
+    return Result<void>::withValue();
   }
-  
-  // pragma MARK: std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>
-  /**
-   * Specialized version of `std::function<void(const std::optional<NativeBleError>&, const std::optional<NativeCharacteristic>&)>`.
-   */
-  using Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_ = std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::optional<NativeBleError>& / * error * /, const std::optional<NativeCharacteristic>& / * characteristic * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__Wrapper final {
-  public:
-    explicit Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__Wrapper(std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>&& func): _function(std::make_unique<std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>>(std::move(func))) {}
-    inline void call(std::optional<NativeBleError> error, std::optional<NativeCharacteristic> characteristic) const {
-      _function->operator()(error, characteristic);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeCharacteristic>& /* characteristic */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_ create_Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__Wrapper wrap_Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_(Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic_ value) {
-    return Func_void_std__optional_NativeBleError__std__optional_NativeCharacteristic__Wrapper(std::move(value));
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) {
+    return Result<void>::withError(error);
   }
   
-  // pragma MARK: std::optional<CharacteristicSubscriptionType>
-  /**
-   * Specialized version of `std::optional<CharacteristicSubscriptionType>`.
-   */
-  using std__optional_CharacteristicSubscriptionType_ = std::optional<CharacteristicSubscriptionType>;
-  inline std::optional<CharacteristicSubscriptionType> create_std__optional_CharacteristicSubscriptionType_(const CharacteristicSubscriptionType& value) {
-    return std::optional<CharacteristicSubscriptionType>(value);
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) {
+    return Result<bool>::withValue(std::move(value));
   }
-  
-  // pragma MARK: std::vector<NativeDescriptor>
-  /**
-   * Specialized version of `std::vector<NativeDescriptor>`.
-   */
-  using std__vector_NativeDescriptor_ = std::vector<NativeDescriptor>;
-  inline std::vector<NativeDescriptor> create_std__vector_NativeDescriptor_(size_t size) {
-    std::vector<NativeDescriptor> vector;
-    vector.reserve(size);
-    return vector;
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) {
+    return Result<bool>::withError(error);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::vector<NativeDescriptor>>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::vector<NativeDescriptor>>>`.
-   */
-  using std__shared_ptr_Promise_std__vector_NativeDescriptor___ = std::shared_ptr<Promise<std::vector<NativeDescriptor>>>;
-  inline std::shared_ptr<Promise<std::vector<NativeDescriptor>>> create_std__shared_ptr_Promise_std__vector_NativeDescriptor___() {
-    return Promise<std::vector<NativeDescriptor>>::create();
+  // pragma MARK: Result<std::vector<BLEDevice>>
+  using Result_std__vector_BLEDevice__ = Result<std::vector<BLEDevice>>;
+  inline Result_std__vector_BLEDevice__ create_Result_std__vector_BLEDevice__(const std::vector<BLEDevice>& value) {
+    return Result<std::vector<BLEDevice>>::withValue(value);
   }
-  inline PromiseHolder<std::vector<NativeDescriptor>> wrap_std__shared_ptr_Promise_std__vector_NativeDescriptor___(std::shared_ptr<Promise<std::vector<NativeDescriptor>>> promise) {
-    return PromiseHolder<std::vector<NativeDescriptor>>(std::move(promise));
+  inline Result_std__vector_BLEDevice__ create_Result_std__vector_BLEDevice__(const std::exception_ptr& error) {
+    return Result<std::vector<BLEDevice>>::withError(error);
   }
   
-  // pragma MARK: std::function<void(const std::vector<NativeDescriptor>& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const std::vector<NativeDescriptor>&)>`.
-   */
-  using Func_void_std__vector_NativeDescriptor_ = std::function<void(const std::vector<NativeDescriptor>& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::vector<NativeDescriptor>& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__vector_NativeDescriptor__Wrapper final {
-  public:
-    explicit Func_void_std__vector_NativeDescriptor__Wrapper(std::function<void(const std::vector<NativeDescriptor>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<NativeDescriptor>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<NativeDescriptor> result) const {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::vector<NativeDescriptor>& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_NativeDescriptor_ create_Func_void_std__vector_NativeDescriptor_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_NativeDescriptor__Wrapper wrap_Func_void_std__vector_NativeDescriptor_(Func_void_std__vector_NativeDescriptor_ value) {
-    return Func_void_std__vector_NativeDescriptor__Wrapper(std::move(value));
+  // pragma MARK: Result<std::vector<std::string>>
+  using Result_std__vector_std__string__ = Result<std::vector<std::string>>;
+  inline Result_std__vector_std__string__ create_Result_std__vector_std__string__(const std::vector<std::string>& value) {
+    return Result<std::vector<std::string>>::withValue(value);
+  }
+  inline Result_std__vector_std__string__ create_Result_std__vector_std__string__(const std::exception_ptr& error) {
+    return Result<std::vector<std::string>>::withError(error);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<NativeDescriptor>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<NativeDescriptor>>`.
-   */
-  using std__shared_ptr_Promise_NativeDescriptor__ = std::shared_ptr<Promise<NativeDescriptor>>;
-  inline std::shared_ptr<Promise<NativeDescriptor>> create_std__shared_ptr_Promise_NativeDescriptor__() {
-    return Promise<NativeDescriptor>::create();
+  // pragma MARK: Result<BLEState>
+  using Result_BLEState_ = Result<BLEState>;
+  inline Result_BLEState_ create_Result_BLEState_(BLEState value) {
+    return Result<BLEState>::withValue(std::move(value));
   }
-  inline PromiseHolder<NativeDescriptor> wrap_std__shared_ptr_Promise_NativeDescriptor__(std::shared_ptr<Promise<NativeDescriptor>> promise) {
-    return PromiseHolder<NativeDescriptor>(std::move(promise));
+  inline Result_BLEState_ create_Result_BLEState_(const std::exception_ptr& error) {
+    return Result<BLEState>::withError(error);
   }
   
-  // pragma MARK: std::function<void(const NativeDescriptor& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const NativeDescriptor&)>`.
-   */
-  using Func_void_NativeDescriptor = std::function<void(const NativeDescriptor& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const NativeDescriptor& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_NativeDescriptor_Wrapper final {
-  public:
-    explicit Func_void_NativeDescriptor_Wrapper(std::function<void(const NativeDescriptor& /* result */)>&& func): _function(std::make_unique<std::function<void(const NativeDescriptor& /* result */)>>(std::move(func))) {}
-    inline void call(NativeDescriptor result) const {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const NativeDescriptor& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_NativeDescriptor create_Func_void_NativeDescriptor(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_NativeDescriptor_Wrapper wrap_Func_void_NativeDescriptor(Func_void_NativeDescriptor value) {
-    return Func_void_NativeDescriptor_Wrapper(std::move(value));
+  // pragma MARK: Result<OperationResult>
+  using Result_OperationResult_ = Result<OperationResult>;
+  inline Result_OperationResult_ create_Result_OperationResult_(const OperationResult& value) {
+    return Result<OperationResult>::withValue(value);
+  }
+  inline Result_OperationResult_ create_Result_OperationResult_(const std::exception_ptr& error) {
+    return Result<OperationResult>::withError(error);
   }
-  
-  // pragma MARK: std::shared_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpec>
-  /**
-   * Specialized version of `std::shared_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpec>`.
-   */
-  using std__shared_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_ = std::shared_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpec>;
-  std::shared_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpec> create_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_(std__shared_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpec>
-  using std__weak_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_ = std::weak_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpec>;
-  inline std__weak_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_ weakify_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridBleManagerSpec_(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridBleManagerSpec>& strong) { return strong; }
   
   // pragma MARK: Result<std::shared_ptr<Promise<void>>>
   using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
@@ -823,247 +394,5 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<BleRestoredState>>>>
-  using Result_std__shared_ptr_Promise_std__optional_BleRestoredState____ = Result<std::shared_ptr<Promise<std::optional<BleRestoredState>>>>;
-  inline Result_std__shared_ptr_Promise_std__optional_BleRestoredState____ create_Result_std__shared_ptr_Promise_std__optional_BleRestoredState____(const std::shared_ptr<Promise<std::optional<BleRestoredState>>>& value) {
-    return Result<std::shared_ptr<Promise<std::optional<BleRestoredState>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__optional_BleRestoredState____ create_Result_std__shared_ptr_Promise_std__optional_BleRestoredState____(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::optional<BleRestoredState>>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<LogLevel>>>
-  using Result_std__shared_ptr_Promise_LogLevel___ = Result<std::shared_ptr<Promise<LogLevel>>>;
-  inline Result_std__shared_ptr_Promise_LogLevel___ create_Result_std__shared_ptr_Promise_LogLevel___(const std::shared_ptr<Promise<LogLevel>>& value) {
-    return Result<std::shared_ptr<Promise<LogLevel>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_LogLevel___ create_Result_std__shared_ptr_Promise_LogLevel___(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<LogLevel>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<State>>>
-  using Result_std__shared_ptr_Promise_State___ = Result<std::shared_ptr<Promise<State>>>;
-  inline Result_std__shared_ptr_Promise_State___ create_Result_std__shared_ptr_Promise_State___(const std::shared_ptr<Promise<State>>& value) {
-    return Result<std::shared_ptr<Promise<State>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_State___ create_Result_std__shared_ptr_Promise_State___(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<State>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<Subscription>
-  using Result_Subscription_ = Result<Subscription>;
-  inline Result_Subscription_ create_Result_Subscription_(const Subscription& value) {
-    return Result<Subscription>::withValue(value);
-  }
-  inline Result_Subscription_ create_Result_Subscription_(const std::exception_ptr& error) {
-    return Result<Subscription>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<NativeDevice>>>
-  using Result_std__shared_ptr_Promise_NativeDevice___ = Result<std::shared_ptr<Promise<NativeDevice>>>;
-  inline Result_std__shared_ptr_Promise_NativeDevice___ create_Result_std__shared_ptr_Promise_NativeDevice___(const std::shared_ptr<Promise<NativeDevice>>& value) {
-    return Result<std::shared_ptr<Promise<NativeDevice>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_NativeDevice___ create_Result_std__shared_ptr_Promise_NativeDevice___(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<NativeDevice>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NativeDevice>>>>
-  using Result_std__shared_ptr_Promise_std__vector_NativeDevice____ = Result<std::shared_ptr<Promise<std::vector<NativeDevice>>>>;
-  inline Result_std__shared_ptr_Promise_std__vector_NativeDevice____ create_Result_std__shared_ptr_Promise_std__vector_NativeDevice____(const std::shared_ptr<Promise<std::vector<NativeDevice>>>& value) {
-    return Result<std::shared_ptr<Promise<std::vector<NativeDevice>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__vector_NativeDevice____ create_Result_std__shared_ptr_Promise_std__vector_NativeDevice____(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::vector<NativeDevice>>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
-  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
-  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) {
-    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NativeService>>>>
-  using Result_std__shared_ptr_Promise_std__vector_NativeService____ = Result<std::shared_ptr<Promise<std::vector<NativeService>>>>;
-  inline Result_std__shared_ptr_Promise_std__vector_NativeService____ create_Result_std__shared_ptr_Promise_std__vector_NativeService____(const std::shared_ptr<Promise<std::vector<NativeService>>>& value) {
-    return Result<std::shared_ptr<Promise<std::vector<NativeService>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__vector_NativeService____ create_Result_std__shared_ptr_Promise_std__vector_NativeService____(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::vector<NativeService>>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NativeCharacteristic>>>>
-  using Result_std__shared_ptr_Promise_std__vector_NativeCharacteristic____ = Result<std::shared_ptr<Promise<std::vector<NativeCharacteristic>>>>;
-  inline Result_std__shared_ptr_Promise_std__vector_NativeCharacteristic____ create_Result_std__shared_ptr_Promise_std__vector_NativeCharacteristic____(const std::shared_ptr<Promise<std::vector<NativeCharacteristic>>>& value) {
-    return Result<std::shared_ptr<Promise<std::vector<NativeCharacteristic>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__vector_NativeCharacteristic____ create_Result_std__shared_ptr_Promise_std__vector_NativeCharacteristic____(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::vector<NativeCharacteristic>>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<NativeCharacteristic>>>
-  using Result_std__shared_ptr_Promise_NativeCharacteristic___ = Result<std::shared_ptr<Promise<NativeCharacteristic>>>;
-  inline Result_std__shared_ptr_Promise_NativeCharacteristic___ create_Result_std__shared_ptr_Promise_NativeCharacteristic___(const std::shared_ptr<Promise<NativeCharacteristic>>& value) {
-    return Result<std::shared_ptr<Promise<NativeCharacteristic>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_NativeCharacteristic___ create_Result_std__shared_ptr_Promise_NativeCharacteristic___(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<NativeCharacteristic>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<NativeDescriptor>>>>
-  using Result_std__shared_ptr_Promise_std__vector_NativeDescriptor____ = Result<std::shared_ptr<Promise<std::vector<NativeDescriptor>>>>;
-  inline Result_std__shared_ptr_Promise_std__vector_NativeDescriptor____ create_Result_std__shared_ptr_Promise_std__vector_NativeDescriptor____(const std::shared_ptr<Promise<std::vector<NativeDescriptor>>>& value) {
-    return Result<std::shared_ptr<Promise<std::vector<NativeDescriptor>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__vector_NativeDescriptor____ create_Result_std__shared_ptr_Promise_std__vector_NativeDescriptor____(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::vector<NativeDescriptor>>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<NativeDescriptor>>>
-  using Result_std__shared_ptr_Promise_NativeDescriptor___ = Result<std::shared_ptr<Promise<NativeDescriptor>>>;
-  inline Result_std__shared_ptr_Promise_NativeDescriptor___ create_Result_std__shared_ptr_Promise_NativeDescriptor___(const std::shared_ptr<Promise<NativeDescriptor>>& value) {
-    return Result<std::shared_ptr<Promise<NativeDescriptor>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_NativeDescriptor___ create_Result_std__shared_ptr_Promise_NativeDescriptor___(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<NativeDescriptor>>>::withError(error);
-  }
-  
-  // pragma MARK: std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>
-  /**
-   * Specialized version of `std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>`.
-   */
-  using std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_ = std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>;
-  std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec> create_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_(std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>
-  using std__weak_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_ = std::weak_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>;
-  inline std__weak_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_ weakify_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>& strong) { return strong; }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>>`.
-   */
-  using std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec___ = std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>>;
-  inline std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>> create_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec___() {
-    return Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>::create();
-  }
-  inline PromiseHolder<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>> wrap_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec___(std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>> promise) {
-    return PromiseHolder<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>&)>`.
-   */
-  using Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_ = std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec__Wrapper final {
-  public:
-    explicit Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec__Wrapper(std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>& /* result */)>>(std::move(func))) {}
-    inline void call(std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec> result) const {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_ create_Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec__Wrapper wrap_Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_(Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec_ value) {
-    return Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec__Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>>>
-  using Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec____ = Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>>>;
-  inline Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec____(const std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>>& value) {
-    return Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridCharacteristicSpec____(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridCharacteristicSpec>>>>::withError(error);
-  }
-  
-  // pragma MARK: std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>
-  /**
-   * Specialized version of `std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>`.
-   */
-  using std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_ = std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>;
-  std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec> create_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_(std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>
-  using std__weak_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_ = std::weak_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>;
-  inline std__weak_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_ weakify_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>& strong) { return strong; }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>>`.
-   */
-  using std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec___ = std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>>;
-  inline std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>> create_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec___() {
-    return Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>::create();
-  }
-  inline PromiseHolder<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>> wrap_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec___(std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>> promise) {
-    return PromiseHolder<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>&)>`.
-   */
-  using Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_ = std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec__Wrapper final {
-  public:
-    explicit Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec__Wrapper(std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>& /* result */)>>(std::move(func))) {}
-    inline void call(std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec> result) const {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_ create_Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec__Wrapper wrap_Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_(Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec_ value) {
-    return Func_void_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec__Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>>>
-  using Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec____ = Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>>>;
-  inline Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec____(const std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>>& value) {
-    return Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDescriptorSpec____(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDescriptorSpec>>>>::withError(error);
-  }
-  
-  // pragma MARK: std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDeviceSpec>
-  /**
-   * Specialized version of `std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDeviceSpec>`.
-   */
-  using std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDeviceSpec_ = std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDeviceSpec>;
-  std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDeviceSpec> create_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDeviceSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDeviceSpec_(std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDeviceSpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<margelo::nitro::co::zyke::ble::HybridDeviceSpec>
-  using std__weak_ptr_margelo__nitro__co__zyke__ble__HybridDeviceSpec_ = std::weak_ptr<margelo::nitro::co::zyke::ble::HybridDeviceSpec>;
-  inline std__weak_ptr_margelo__nitro__co__zyke__ble__HybridDeviceSpec_ weakify_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridDeviceSpec_(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridDeviceSpec>& strong) { return strong; }
-  
-  // pragma MARK: std::shared_ptr<margelo::nitro::co::zyke::ble::HybridServiceSpec>
-  /**
-   * Specialized version of `std::shared_ptr<margelo::nitro::co::zyke::ble::HybridServiceSpec>`.
-   */
-  using std__shared_ptr_margelo__nitro__co__zyke__ble__HybridServiceSpec_ = std::shared_ptr<margelo::nitro::co::zyke::ble::HybridServiceSpec>;
-  std::shared_ptr<margelo::nitro::co::zyke::ble::HybridServiceSpec> create_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridServiceSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridServiceSpec_(std__shared_ptr_margelo__nitro__co__zyke__ble__HybridServiceSpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<margelo::nitro::co::zyke::ble::HybridServiceSpec>
-  using std__weak_ptr_margelo__nitro__co__zyke__ble__HybridServiceSpec_ = std::weak_ptr<margelo::nitro::co::zyke::ble::HybridServiceSpec>;
-  inline std__weak_ptr_margelo__nitro__co__zyke__ble__HybridServiceSpec_ weakify_std__shared_ptr_margelo__nitro__co__zyke__ble__HybridServiceSpec_(const std::shared_ptr<margelo::nitro::co::zyke::ble::HybridServiceSpec>& strong) { return strong; }
 
 } // namespace margelo::nitro::co::zyke::ble::bridge::swift