react-native-ble-nitro 1.7.0 → 1.8.0

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

@@ -15,7 +15,7 @@
 namespace margelo::nitro::co::zyke::ble::bridge::swift {
 
   // pragma MARK: std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>
-  Func_void_std__vector_BLEDevice_ create_Func_void_std__vector_BLEDevice_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__vector_BLEDevice_ create_Func_void_std__vector_BLEDevice_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_std__vector_BLEDevice_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::vector<BLEDevice>& restoredPeripherals) mutable -> void {
       swiftClosure.call(restoredPeripherals);
@@ -23,7 +23,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>
-  Func_void_std__optional_BLEDevice__std__optional_std__string_ create_Func_void_std__optional_BLEDevice__std__optional_std__string_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__optional_BLEDevice__std__optional_std__string_ create_Func_void_std__optional_BLEDevice__std__optional_std__string_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_std__optional_BLEDevice__std__optional_std__string_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::optional<BLEDevice>& device, const std::optional<std::string>& error) mutable -> void {
       swiftClosure.call(device, error);
@@ -31,7 +31,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>
-  Func_void_bool_std__string_std__string create_Func_void_bool_std__string_std__string(void* _Nonnull swiftClosureWrapper) {
+  Func_void_bool_std__string_std__string create_Func_void_bool_std__string_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_bool_std__string_std__string::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](bool success, const std::string& deviceId, const std::string& error) mutable -> void {
       swiftClosure.call(success, deviceId, error);
@@ -39,7 +39,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>
-  Func_void_std__string_bool_std__string create_Func_void_std__string_bool_std__string(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__string_bool_std__string create_Func_void_std__string_bool_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_std__string_bool_std__string::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::string& deviceId, bool interrupted, const std::string& error) mutable -> void {
       swiftClosure.call(deviceId, interrupted, error);
@@ -47,7 +47,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(bool /* success */, const std::string& /* error */)>
-  Func_void_bool_std__string create_Func_void_bool_std__string(void* _Nonnull swiftClosureWrapper) {
+  Func_void_bool_std__string create_Func_void_bool_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_bool_std__string::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](bool success, const std::string& error) mutable -> void {
       swiftClosure.call(success, error);
@@ -55,7 +55,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>
-  Func_void_bool_double_std__string create_Func_void_bool_double_std__string(void* _Nonnull swiftClosureWrapper) {
+  Func_void_bool_double_std__string create_Func_void_bool_double_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_bool_double_std__string::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](bool success, double rssi, const std::string& error) mutable -> void {
       swiftClosure.call(success, rssi, error);
@@ -63,7 +63,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>
-  Func_void_bool_std__shared_ptr_ArrayBuffer__std__string create_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(void* _Nonnull swiftClosureWrapper) {
+  Func_void_bool_std__shared_ptr_ArrayBuffer__std__string create_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_bool_std__shared_ptr_ArrayBuffer__std__string::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](bool success, const std::shared_ptr<ArrayBuffer>& data, const std::string& error) mutable -> void {
       swiftClosure.call(success, ArrayBufferHolder(data), error);
@@ -71,7 +71,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)>
-  Func_void_std__string_std__shared_ptr_ArrayBuffer_ create_Func_void_std__string_std__shared_ptr_ArrayBuffer_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__string_std__shared_ptr_ArrayBuffer_ create_Func_void_std__string_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_std__string_std__shared_ptr_ArrayBuffer_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::string& characteristicId, const std::shared_ptr<ArrayBuffer>& data) mutable -> void {
       swiftClosure.call(characteristicId, ArrayBufferHolder(data));
@@ -79,7 +79,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(BLEState /* state */)>
-  Func_void_BLEState create_Func_void_BLEState(void* _Nonnull swiftClosureWrapper) {
+  Func_void_BLEState create_Func_void_BLEState(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_BLEState::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](BLEState state) mutable -> void {
       swiftClosure.call(static_cast<int>(state));
@@ -87,7 +87,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void()>
-  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper) {
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
       swiftClosure.call();
@@ -95,7 +95,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
-  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void {
       swiftClosure.call(error);
@@ -103,11 +103,11 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridNativeBleNitroSpec>
-  std::shared_ptr<HybridNativeBleNitroSpec> create_std__shared_ptr_HybridNativeBleNitroSpec_(void* _Nonnull swiftUnsafePointer) {
+  std::shared_ptr<HybridNativeBleNitroSpec> create_std__shared_ptr_HybridNativeBleNitroSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     BleNitro::HybridNativeBleNitroSpec_cxx swiftPart = BleNitro::HybridNativeBleNitroSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::co::zyke::ble::HybridNativeBleNitroSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridNativeBleNitroSpec_(std__shared_ptr_HybridNativeBleNitroSpec_ cppType) {
+  void* NON_NULL get_std__shared_ptr_HybridNativeBleNitroSpec_(std__shared_ptr_HybridNativeBleNitroSpec_ cppType) {
     std::shared_ptr<margelo::nitro::co::zyke::ble::HybridNativeBleNitroSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::co::zyke::ble::HybridNativeBleNitroSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -119,11 +119,11 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridNativeBleNitroFactorySpec>
-  std::shared_ptr<HybridNativeBleNitroFactorySpec> create_std__shared_ptr_HybridNativeBleNitroFactorySpec_(void* _Nonnull swiftUnsafePointer) {
+  std::shared_ptr<HybridNativeBleNitroFactorySpec> create_std__shared_ptr_HybridNativeBleNitroFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     BleNitro::HybridNativeBleNitroFactorySpec_cxx swiftPart = BleNitro::HybridNativeBleNitroFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::co::zyke::ble::HybridNativeBleNitroFactorySpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridNativeBleNitroFactorySpec_(std__shared_ptr_HybridNativeBleNitroFactorySpec_ cppType) {
+  void* NON_NULL get_std__shared_ptr_HybridNativeBleNitroFactorySpec_(std__shared_ptr_HybridNativeBleNitroFactorySpec_ cppType) {
     std::shared_ptr<margelo::nitro::co::zyke::ble::HybridNativeBleNitroFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::co::zyke::ble::HybridNativeBleNitroFactorySpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {

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

@@ -43,6 +43,7 @@ namespace BleNitro { class HybridNativeBleNitroSpec_cxx; }
 #include "OperationResult.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/FastVectorCopy.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -64,16 +65,22 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
    * 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) {
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
     return std::optional<std::string>(value);
   }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::vector<ManufacturerDataEntry>
   /**
    * Specialized version of `std::vector<ManufacturerDataEntry>`.
    */
   using std__vector_ManufacturerDataEntry_ = std::vector<ManufacturerDataEntry>;
-  inline std::vector<ManufacturerDataEntry> create_std__vector_ManufacturerDataEntry_(size_t size) {
+  inline std::vector<ManufacturerDataEntry> create_std__vector_ManufacturerDataEntry_(size_t size) noexcept {
     std::vector<ManufacturerDataEntry> vector;
     vector.reserve(size);
     return vector;
@@ -84,7 +91,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
    * 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) {
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
     std::vector<std::string> vector;
     vector.reserve(size);
     return vector;
@@ -95,7 +102,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
    * Specialized version of `std::vector<BLEDevice>`.
    */
   using std__vector_BLEDevice_ = std::vector<BLEDevice>;
-  inline std::vector<BLEDevice> create_std__vector_BLEDevice_(size_t size) {
+  inline std::vector<BLEDevice> create_std__vector_BLEDevice_(size_t size) noexcept {
     std::vector<BLEDevice> vector;
     vector.reserve(size);
     return vector;
@@ -112,14 +119,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   class Func_void_std__vector_BLEDevice__Wrapper final {
   public:
     explicit Func_void_std__vector_BLEDevice__Wrapper(std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>&& func): _function(std::make_unique<std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>>(std::move(func))) {}
-    inline void call(std::vector<BLEDevice> restoredPeripherals) const {
+    inline void call(std::vector<BLEDevice> restoredPeripherals) const noexcept {
       _function->operator()(restoredPeripherals);
     }
   private:
     std::unique_ptr<std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__vector_BLEDevice_ create_Func_void_std__vector_BLEDevice_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_BLEDevice__Wrapper wrap_Func_void_std__vector_BLEDevice_(Func_void_std__vector_BLEDevice_ value) {
+  Func_void_std__vector_BLEDevice_ create_Func_void_std__vector_BLEDevice_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_BLEDevice__Wrapper wrap_Func_void_std__vector_BLEDevice_(Func_void_std__vector_BLEDevice_ value) noexcept {
     return Func_void_std__vector_BLEDevice__Wrapper(std::move(value));
   }
   
@@ -128,9 +135,15 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
    * Specialized version of `std::optional<BLEDevice>`.
    */
   using std__optional_BLEDevice_ = std::optional<BLEDevice>;
-  inline std::optional<BLEDevice> create_std__optional_BLEDevice_(const BLEDevice& value) {
+  inline std::optional<BLEDevice> create_std__optional_BLEDevice_(const BLEDevice& value) noexcept {
     return std::optional<BLEDevice>(value);
   }
+  inline bool has_value_std__optional_BLEDevice_(const std::optional<BLEDevice>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline BLEDevice get_std__optional_BLEDevice_(const std::optional<BLEDevice>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>
   /**
@@ -143,14 +156,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   class Func_void_std__optional_BLEDevice__std__optional_std__string__Wrapper final {
   public:
     explicit Func_void_std__optional_BLEDevice__std__optional_std__string__Wrapper(std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>>(std::move(func))) {}
-    inline void call(std::optional<BLEDevice> device, std::optional<std::string> error) const {
+    inline void call(std::optional<BLEDevice> device, std::optional<std::string> error) const noexcept {
       _function->operator()(device, error);
     }
   private:
     std::unique_ptr<std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_BLEDevice__std__optional_std__string_ create_Func_void_std__optional_BLEDevice__std__optional_std__string_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__optional_BLEDevice__std__optional_std__string__Wrapper wrap_Func_void_std__optional_BLEDevice__std__optional_std__string_(Func_void_std__optional_BLEDevice__std__optional_std__string_ value) {
+  Func_void_std__optional_BLEDevice__std__optional_std__string_ create_Func_void_std__optional_BLEDevice__std__optional_std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_BLEDevice__std__optional_std__string__Wrapper wrap_Func_void_std__optional_BLEDevice__std__optional_std__string_(Func_void_std__optional_BLEDevice__std__optional_std__string_ value) noexcept {
     return Func_void_std__optional_BLEDevice__std__optional_std__string__Wrapper(std::move(value));
   }
   
@@ -165,14 +178,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   class Func_void_bool_std__string_std__string_Wrapper final {
   public:
     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 {
+    inline void call(bool success, std::string deviceId, std::string error) const noexcept {
       _function->operator()(success, deviceId, error);
     }
   private:
     std::unique_ptr<std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  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) {
+  Func_void_bool_std__string_std__string create_Func_void_bool_std__string_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  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) noexcept {
     return Func_void_bool_std__string_std__string_Wrapper(std::move(value));
   }
   
@@ -187,14 +200,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   class Func_void_std__string_bool_std__string_Wrapper final {
   public:
     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 {
+    inline void call(std::string deviceId, bool interrupted, std::string error) const noexcept {
       _function->operator()(deviceId, interrupted, error);
     }
   private:
     std::unique_ptr<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  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) {
+  Func_void_std__string_bool_std__string create_Func_void_std__string_bool_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  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) noexcept {
     return Func_void_std__string_bool_std__string_Wrapper(std::move(value));
   }
   
@@ -203,18 +216,30 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
    * Specialized version of `std::optional<std::function<void(const std::string& / * deviceId * /, bool / * interrupted * /, const std::string& / * error * /)>>`.
    */
   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) {
+  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) noexcept {
     return std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>(value);
   }
+  inline bool has_value_std__optional_std__function_void_const_std__string_____deviceId_____bool____interrupted_____const_std__string_____error______(const std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)> get_std__optional_std__function_void_const_std__string_____deviceId_____bool____interrupted_____const_std__string_____error______(const std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
     return std::optional<bool>(value);
   }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::function<void(bool /* success */, const std::string& /* error */)>
   /**
@@ -227,14 +252,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   class Func_void_bool_std__string_Wrapper final {
   public:
     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 {
+    inline void call(bool success, std::string error) const noexcept {
       _function->operator()(success, error);
     }
   private:
     std::unique_ptr<std::function<void(bool /* success */, const std::string& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  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) {
+  Func_void_bool_std__string create_Func_void_bool_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_std__string_Wrapper wrap_Func_void_bool_std__string(Func_void_bool_std__string value) noexcept {
     return Func_void_bool_std__string_Wrapper(std::move(value));
   }
   
@@ -249,14 +274,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   class Func_void_bool_double_std__string_Wrapper final {
   public:
     explicit Func_void_bool_double_std__string_Wrapper(std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>&& func): _function(std::make_unique<std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>>(std::move(func))) {}
-    inline void call(bool success, double rssi, std::string error) const {
+    inline void call(bool success, double rssi, std::string error) const noexcept {
       _function->operator()(success, rssi, error);
     }
   private:
     std::unique_ptr<std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_bool_double_std__string create_Func_void_bool_double_std__string(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_bool_double_std__string_Wrapper wrap_Func_void_bool_double_std__string(Func_void_bool_double_std__string value) {
+  Func_void_bool_double_std__string create_Func_void_bool_double_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_double_std__string_Wrapper wrap_Func_void_bool_double_std__string(Func_void_bool_double_std__string value) noexcept {
     return Func_void_bool_double_std__string_Wrapper(std::move(value));
   }
   
@@ -271,14 +296,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   class Func_void_bool_std__shared_ptr_ArrayBuffer__std__string_Wrapper final {
   public:
     explicit Func_void_bool_std__shared_ptr_ArrayBuffer__std__string_Wrapper(std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>&& func): _function(std::make_unique<std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>>(std::move(func))) {}
-    inline void call(bool success, ArrayBufferHolder data, std::string error) const {
+    inline void call(bool success, ArrayBufferHolder data, std::string error) const noexcept {
       _function->operator()(success, data.getArrayBuffer(), error);
     }
   private:
     std::unique_ptr<std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_bool_std__shared_ptr_ArrayBuffer__std__string create_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_bool_std__shared_ptr_ArrayBuffer__std__string_Wrapper wrap_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(Func_void_bool_std__shared_ptr_ArrayBuffer__std__string value) {
+  Func_void_bool_std__shared_ptr_ArrayBuffer__std__string create_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_std__shared_ptr_ArrayBuffer__std__string_Wrapper wrap_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(Func_void_bool_std__shared_ptr_ArrayBuffer__std__string value) noexcept {
     return Func_void_bool_std__shared_ptr_ArrayBuffer__std__string_Wrapper(std::move(value));
   }
   
@@ -293,14 +318,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   class Func_void_std__string_std__shared_ptr_ArrayBuffer__Wrapper final {
   public:
     explicit Func_void_std__string_std__shared_ptr_ArrayBuffer__Wrapper(std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)>>(std::move(func))) {}
-    inline void call(std::string characteristicId, ArrayBufferHolder data) const {
+    inline void call(std::string characteristicId, ArrayBufferHolder data) const noexcept {
       _function->operator()(characteristicId, data.getArrayBuffer());
     }
   private:
     std::unique_ptr<std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__string_std__shared_ptr_ArrayBuffer_ create_Func_void_std__string_std__shared_ptr_ArrayBuffer_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__string_std__shared_ptr_ArrayBuffer__Wrapper wrap_Func_void_std__string_std__shared_ptr_ArrayBuffer_(Func_void_std__string_std__shared_ptr_ArrayBuffer_ value) {
+  Func_void_std__string_std__shared_ptr_ArrayBuffer_ create_Func_void_std__string_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_std__shared_ptr_ArrayBuffer__Wrapper wrap_Func_void_std__string_std__shared_ptr_ArrayBuffer_(Func_void_std__string_std__shared_ptr_ArrayBuffer_ value) noexcept {
     return Func_void_std__string_std__shared_ptr_ArrayBuffer__Wrapper(std::move(value));
   }
   
@@ -315,14 +340,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   class Func_void_BLEState_Wrapper final {
   public:
     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 {
+    inline void call(int state) const noexcept {
       _function->operator()(static_cast<BLEState>(state));
     }
   private:
     std::unique_ptr<std::function<void(BLEState /* state */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_BLEState create_Func_void_BLEState(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_BLEState_Wrapper wrap_Func_void_BLEState(Func_void_BLEState value) {
+  Func_void_BLEState create_Func_void_BLEState(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_BLEState_Wrapper wrap_Func_void_BLEState(Func_void_BLEState value) noexcept {
     return Func_void_BLEState_Wrapper(std::move(value));
   }
   
@@ -331,10 +356,10 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
    * 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__() {
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
     return Promise<void>::create();
   }
-  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) {
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
     return PromiseHolder<void>(std::move(promise));
   }
   
@@ -349,14 +374,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::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 {
+    inline void call() const noexcept {
       _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) {
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
     return Func_void_Wrapper(std::move(value));
   }
   
@@ -371,14 +396,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::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 {
+    inline void call(std::exception_ptr error) const noexcept {
       _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) {
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
@@ -387,82 +412,82 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridNativeBleNitroSpec>`.
    */
   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);
+  std::shared_ptr<HybridNativeBleNitroSpec> create_std__shared_ptr_HybridNativeBleNitroSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridNativeBleNitroSpec_(std__shared_ptr_HybridNativeBleNitroSpec_ cppType);
   
   // 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; }
+  inline std__weak_ptr_HybridNativeBleNitroSpec_ weakify_std__shared_ptr_HybridNativeBleNitroSpec_(const std::shared_ptr<HybridNativeBleNitroSpec>& strong) noexcept { return strong; }
   
   // pragma MARK: Result<void>
   using Result_void_ = Result<void>;
-  inline Result_void_ create_Result_void_() {
+  inline Result_void_ create_Result_void_() noexcept {
     return Result<void>::withValue();
   }
-  inline Result_void_ create_Result_void_(const std::exception_ptr& error) {
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
     return Result<void>::withError(error);
   }
   
   // pragma MARK: Result<bool>
   using Result_bool_ = Result<bool>;
-  inline Result_bool_ create_Result_bool_(bool value) {
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
     return Result<bool>::withValue(std::move(value));
   }
-  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) {
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
     return Result<bool>::withError(error);
   }
   
   // 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) {
+  inline Result_std__vector_BLEDevice__ create_Result_std__vector_BLEDevice__(const std::vector<BLEDevice>& value) noexcept {
     return Result<std::vector<BLEDevice>>::withValue(value);
   }
-  inline Result_std__vector_BLEDevice__ create_Result_std__vector_BLEDevice__(const std::exception_ptr& error) {
+  inline Result_std__vector_BLEDevice__ create_Result_std__vector_BLEDevice__(const std::exception_ptr& error) noexcept {
     return Result<std::vector<BLEDevice>>::withError(error);
   }
   
   // pragma MARK: Result<double>
   using Result_double_ = Result<double>;
-  inline Result_double_ create_Result_double_(double value) {
+  inline Result_double_ create_Result_double_(double value) noexcept {
     return Result<double>::withValue(std::move(value));
   }
-  inline Result_double_ create_Result_double_(const std::exception_ptr& error) {
+  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
     return Result<double>::withError(error);
   }
   
   // 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) {
+  inline Result_std__vector_std__string__ create_Result_std__vector_std__string__(const std::vector<std::string>& value) noexcept {
     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) {
+  inline Result_std__vector_std__string__ create_Result_std__vector_std__string__(const std::exception_ptr& error) noexcept {
     return Result<std::vector<std::string>>::withError(error);
   }
   
-  // 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 Result_BLEState_ create_Result_BLEState_(const std::exception_ptr& error) {
-    return Result<BLEState>::withError(error);
-  }
-  
   // pragma MARK: Result<OperationResult>
   using Result_OperationResult_ = Result<OperationResult>;
-  inline Result_OperationResult_ create_Result_OperationResult_(const OperationResult& value) {
+  inline Result_OperationResult_ create_Result_OperationResult_(const OperationResult& value) noexcept {
     return Result<OperationResult>::withValue(value);
   }
-  inline Result_OperationResult_ create_Result_OperationResult_(const std::exception_ptr& error) {
+  inline Result_OperationResult_ create_Result_OperationResult_(const std::exception_ptr& error) noexcept {
     return Result<OperationResult>::withError(error);
   }
   
+  // pragma MARK: Result<BLEState>
+  using Result_BLEState_ = Result<BLEState>;
+  inline Result_BLEState_ create_Result_BLEState_(BLEState value) noexcept {
+    return Result<BLEState>::withValue(std::move(value));
+  }
+  inline Result_BLEState_ create_Result_BLEState_(const std::exception_ptr& error) noexcept {
+    return Result<BLEState>::withError(error);
+  }
+  
   // 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) {
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
     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) {
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
   
@@ -471,28 +496,34 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
    * Specialized version of `std::optional<std::function<void(const std::vector<BLEDevice>& / * peripherals * /)>>`.
    */
   using std__optional_std__function_void_const_std__vector_BLEDevice______peripherals______ = std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>;
-  inline std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>> create_std__optional_std__function_void_const_std__vector_BLEDevice______peripherals______(const std::function<void(const std::vector<BLEDevice>& /* peripherals */)>& value) {
+  inline std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>> create_std__optional_std__function_void_const_std__vector_BLEDevice______peripherals______(const std::function<void(const std::vector<BLEDevice>& /* peripherals */)>& value) noexcept {
     return std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>(value);
   }
+  inline bool has_value_std__optional_std__function_void_const_std__vector_BLEDevice______peripherals______(const std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const std::vector<BLEDevice>& /* peripherals */)> get_std__optional_std__function_void_const_std__vector_BLEDevice______peripherals______(const std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::shared_ptr<HybridNativeBleNitroFactorySpec>
   /**
    * Specialized version of `std::shared_ptr<HybridNativeBleNitroFactorySpec>`.
    */
   using std__shared_ptr_HybridNativeBleNitroFactorySpec_ = std::shared_ptr<HybridNativeBleNitroFactorySpec>;
-  std::shared_ptr<HybridNativeBleNitroFactorySpec> create_std__shared_ptr_HybridNativeBleNitroFactorySpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_HybridNativeBleNitroFactorySpec_(std__shared_ptr_HybridNativeBleNitroFactorySpec_ cppType);
+  std::shared_ptr<HybridNativeBleNitroFactorySpec> create_std__shared_ptr_HybridNativeBleNitroFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridNativeBleNitroFactorySpec_(std__shared_ptr_HybridNativeBleNitroFactorySpec_ cppType);
   
   // pragma MARK: std::weak_ptr<HybridNativeBleNitroFactorySpec>
   using std__weak_ptr_HybridNativeBleNitroFactorySpec_ = std::weak_ptr<HybridNativeBleNitroFactorySpec>;
-  inline std__weak_ptr_HybridNativeBleNitroFactorySpec_ weakify_std__shared_ptr_HybridNativeBleNitroFactorySpec_(const std::shared_ptr<HybridNativeBleNitroFactorySpec>& strong) { return strong; }
+  inline std__weak_ptr_HybridNativeBleNitroFactorySpec_ weakify_std__shared_ptr_HybridNativeBleNitroFactorySpec_(const std::shared_ptr<HybridNativeBleNitroFactorySpec>& strong) noexcept { return strong; }
   
   // pragma MARK: Result<std::shared_ptr<HybridNativeBleNitroSpec>>
   using Result_std__shared_ptr_HybridNativeBleNitroSpec__ = Result<std::shared_ptr<HybridNativeBleNitroSpec>>;
-  inline Result_std__shared_ptr_HybridNativeBleNitroSpec__ create_Result_std__shared_ptr_HybridNativeBleNitroSpec__(const std::shared_ptr<HybridNativeBleNitroSpec>& value) {
+  inline Result_std__shared_ptr_HybridNativeBleNitroSpec__ create_Result_std__shared_ptr_HybridNativeBleNitroSpec__(const std::shared_ptr<HybridNativeBleNitroSpec>& value) noexcept {
     return Result<std::shared_ptr<HybridNativeBleNitroSpec>>::withValue(value);
   }
-  inline Result_std__shared_ptr_HybridNativeBleNitroSpec__ create_Result_std__shared_ptr_HybridNativeBleNitroSpec__(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_HybridNativeBleNitroSpec__ create_Result_std__shared_ptr_HybridNativeBleNitroSpec__(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<HybridNativeBleNitroSpec>>::withError(error);
   }