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

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

@@ -0,0 +1,1069 @@
+///
+/// BleNitro-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#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 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; }
+
+// 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 <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+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>`.
+   */
+  using std__vector_std__string_ = std::vector<std::string>;
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) {
+    std::vector<std::string> vector;
+    vector.reserve(size);
+    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>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  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;
+    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>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<BleRestoredState>>>`.
+   */
+  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));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<BleRestoredState>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<BleRestoredState>&)>`.
+   */
+  using Func_void_std__optional_BleRestoredState_ = std::function<void(const std::optional<BleRestoredState>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<BleRestoredState>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_BleRestoredState__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);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<BleRestoredState>& /* result */)>> _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));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<LogLevel>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<LogLevel>>`.
+   */
+  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));
+  }
+  
+  // pragma MARK: std::function<void(LogLevel /* result */)>
+  /**
+   * Specialized version of `std::function<void(LogLevel)>`.
+   */
+  using Func_void_LogLevel = std::function<void(LogLevel /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(LogLevel / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_LogLevel_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));
+    }
+  private:
+    std::unique_ptr<std::function<void(LogLevel /* result */)>> _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));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<State>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<State>>`.
+   */
+  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 */)>
+  /**
+   * Specialized version of `std::function<void(State)>`.
+   */
+  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 {
+  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));
+    }
+  private:
+    std::unique_ptr<std::function<void(State /* result */)>> _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));
+  }
+  
+  // pragma MARK: std::optional<ScanMode>
+  /**
+   * Specialized version of `std::optional<ScanMode>`.
+   */
+  using std__optional_ScanMode_ = std::optional<ScanMode>;
+  inline std::optional<ScanMode> create_std__optional_ScanMode_(const ScanMode& value) {
+    return std::optional<ScanMode>(value);
+  }
+  
+  // pragma MARK: std::optional<ScanCallbackType>
+  /**
+   * Specialized version of `std::optional<ScanCallbackType>`.
+   */
+  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>
+  /**
+   * Specialized version of `std::optional<BleATTErrorCode>`.
+   */
+  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 {
+  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);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<NativeBleError>& /* error */, const std::optional<NativeDevice>& /* scannedDevice */)>> _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));
+  }
+  
+  // pragma MARK: std::function<void(const NativeDevice& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const NativeDevice&)>`.
+   */
+  using Func_void_NativeDevice = std::function<void(const NativeDevice& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const NativeDevice& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_NativeDevice_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);
+    }
+  private:
+    std::unique_ptr<std::function<void(const NativeDevice& /* result */)>> _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));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<NativeDevice>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<NativeDevice>&)>`.
+   */
+  using Func_void_std__vector_NativeDevice_ = std::function<void(const std::vector<NativeDevice>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<NativeDevice>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_NativeDevice__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);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<NativeDevice>& /* result */)>> _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));
+  }
+  
+  // 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>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  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));
+  }
+  
+  // pragma MARK: std::function<void(bool /* result */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_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);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* result */)>> _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));
+  }
+  
+  // 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>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<NativeService>>>`.
+   */
+  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();
+  }
+  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));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<NativeService>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<NativeService>&)>`.
+   */
+  using Func_void_std__vector_NativeService_ = std::function<void(const std::vector<NativeService>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<NativeService>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_NativeService__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);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<NativeService>& /* result */)>> _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));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<NativeCharacteristic>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<NativeCharacteristic>&)>`.
+   */
+  using Func_void_std__vector_NativeCharacteristic_ = std::function<void(const std::vector<NativeCharacteristic>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<NativeCharacteristic>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_NativeCharacteristic__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);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<NativeCharacteristic>& /* result */)>> _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));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<NativeCharacteristic>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<NativeCharacteristic>>`.
+   */
+  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));
+  }
+  
+  // 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::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: 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));
+  }
+  
+  // 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: 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;
+  }
+  
+  // 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();
+  }
+  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));
+  }
+  
+  // 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: 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();
+  }
+  inline PromiseHolder<NativeDescriptor> wrap_std__shared_ptr_Promise_NativeDescriptor__(std::shared_ptr<Promise<NativeDescriptor>> promise) {
+    return PromiseHolder<NativeDescriptor>(std::move(promise));
+  }
+  
+  // 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: 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>>>;
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) {
+    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
+  }
+  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