react-nitro-renderer 0.0.0-stage → 0.0.1-alpha.7

package/nitrogen/generated/apple/ReactNitroRenderer-Swift-Cxx-Bridge.cpp

@@ -0,0 +1,376 @@
+///
+/// ReactNitroRenderer-Swift-Cxx-Bridge.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+#include <ReactNitroRenderer/private/ReactNitroRenderer-Swift-Cxx-Umbrella.hpp>
+#include <ReactNitroRenderer/private/HybridAnimatorSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridApplicationSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridViewSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridWindowSceneSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridWindowSpecSwift.hpp>
+
+#include <ReactNitroRenderer/private/HybridWindowSpec_cxx-Swift.hpp>
+#include <NitroModules/Promise.hpp>
+#include <ReactNitroRenderer/private/HybridWindowSceneSpec_cxx-Swift.hpp>
+#include <NitroModules/Callback.hpp>
+#include <NitroModules/SwiftResult.hpp>
+#include <ReactNitroRenderer/private/HybridGestureRecognizerSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridLongPressGestureRecognizerSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridLongPressGestureRecognizerSpec_cxx-Swift.hpp>
+#include <ReactNitroRenderer/private/HybridPanGestureRecognizerSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridPanGestureRecognizerSpec_cxx-Swift.hpp>
+#include <ReactNitroRenderer/private/HybridTapGestureRecognizerSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridTapGestureRecognizerSpec_cxx-Swift.hpp>
+#include <ReactNitroRenderer/private/HybridLabelSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridScreenSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridScrollViewSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridScrollViewContentSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridViewControllerSpecSwift.hpp>
+#include <ReactNitroRenderer/private/EdgeInsets-Swift.hpp>
+
+namespace margelo::nitro::renderer::swift_bridge {
+  std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridAnimatorSpecSwift>(::ReactNitroRenderer::HybridAnimatorSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridAnimatorSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridAnimatorSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridApplicationSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridApplicationSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridApplicationSpecSwift>(::ReactNitroRenderer::HybridApplicationSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridApplicationSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridApplicationSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridApplicationSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridViewSpecSwift>(::ReactNitroRenderer::HybridViewSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridViewSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridViewSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridWindowSceneSpecSwift>(::ReactNitroRenderer::HybridWindowSceneSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridWindowSceneSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridWindowSceneSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridWindowSpecSwift>(::ReactNitroRenderer::HybridWindowSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridWindowSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridWindowSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  Promise___ReactNitroRenderer__HybridWindowSpec_cxx create_Promise___ReactNitroRenderer__HybridWindowSpec_cxx() { return Promise___ReactNitroRenderer__HybridWindowSpec_cxx::pending(); }
+
+  void reject_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(const Promise___ReactNitroRenderer__HybridWindowSpec_cxx& promise, std::exception_ptr error) { promise.reject(std::move(error)); }
+
+  void listenRejected_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(const Promise___ReactNitroRenderer__HybridWindowSpec_cxx& promise, std::function<void(const std::exception_ptr&)> listener) { promise.addOnRejectedListener(std::move(listener)); }
+
+  void resolve_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(const Promise___ReactNitroRenderer__HybridWindowSpec_cxx& promise, const void* NON_NULL value) {
+    promise.resolve(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridWindowSpec_cxx>(value));
+  }
+
+  void listen_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(const Promise___ReactNitroRenderer__HybridWindowSpec_cxx& promise, std::function<void(const void* NON_NULL)> listener) {
+    promise.addOnResolvedListener([listener = std::move(listener)](const ::ReactNitroRenderer::HybridWindowSpec_cxx& value) {
+      NitroModules::withSwiftValue(value, [&](const void* pointer) {
+        listener(pointer);
+      });
+    });
+  }
+
+  Result<void, margelo::nitro::renderer::swift_bridge::ResultTag> callSync_Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx(const Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx& callback, const void* NON_NULL param0, void* NON_NULL __outResult) noexcept {
+    try {
+      NitroModules::initializeSwiftValue(__outResult, callback.callSync(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridWindowSceneSpec_cxx>(param0)));
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Promise<::ReactNitroRenderer::HybridWindowSpec_cxx> callAsync_Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx(const Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx& callback, const void* NON_NULL param0) {
+    return callback.callAsync(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridWindowSceneSpec_cxx>(param0));
+  }
+
+  void callAndForget_Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx(const Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx& callback, const void* NON_NULL param0) {
+    callback.callAndForget(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridWindowSceneSpec_cxx>(param0));
+  }
+
+  Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx create_Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx(std::function<Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>(const void* NON_NULL param0, void* NON_NULL __outResult)> closure) {
+    return Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx::make([closure = std::move(closure)](const ::ReactNitroRenderer::HybridWindowSceneSpec_cxx& param0) -> ::ReactNitroRenderer::HybridWindowSpec_cxx {
+      auto __result = borrowSwiftValue(param0, [&](const void* param0) {
+        return withSwiftResult<::ReactNitroRenderer::HybridWindowSpec_cxx>([&](void* __outResult) {
+          return closure(param0, __outResult);
+        });
+      });
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      return std::move(__result.value());
+    });
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift>(::ReactNitroRenderer::HybridGestureRecognizerSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridGestureRecognizerSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridLongPressGestureRecognizerSpecSwift>(::ReactNitroRenderer::HybridLongPressGestureRecognizerSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridLongPressGestureRecognizerSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridLongPressGestureRecognizerSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std::shared_ptr<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift> upcast_LongPressGestureRecognizer_to_GestureRecognizer(const std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_& value) {
+    return value;
+  }
+
+  Result<void, margelo::nitro::renderer::swift_bridge::ResultTag> callSync_Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0) noexcept {
+    try {
+      callback.callSync(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridLongPressGestureRecognizerSpec_cxx>(param0));
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Promise<void> callAsync_Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0) {
+    return callback.callAsync(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridLongPressGestureRecognizerSpec_cxx>(param0));
+  }
+
+  void callAndForget_Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0) {
+    callback.callAndForget(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridLongPressGestureRecognizerSpec_cxx>(param0));
+  }
+
+  Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx create_Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx(std::function<Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>(const void* NON_NULL param0)> closure) {
+    return Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx::make([closure = std::move(closure)](const ::ReactNitroRenderer::HybridLongPressGestureRecognizerSpec_cxx& param0) -> void {
+      auto __result = borrowSwiftValue(param0, [&](const void* param0) {
+        return closure(param0);
+      });
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    });
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridPanGestureRecognizerSpecSwift>(::ReactNitroRenderer::HybridPanGestureRecognizerSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridPanGestureRecognizerSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridPanGestureRecognizerSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std::shared_ptr<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift> upcast_PanGestureRecognizer_to_GestureRecognizer(const std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_& value) {
+    return value;
+  }
+
+  Result<void, margelo::nitro::renderer::swift_bridge::ResultTag> callSync_Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0) noexcept {
+    try {
+      callback.callSync(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridPanGestureRecognizerSpec_cxx>(param0));
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Promise<void> callAsync_Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0) {
+    return callback.callAsync(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridPanGestureRecognizerSpec_cxx>(param0));
+  }
+
+  void callAndForget_Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0) {
+    callback.callAndForget(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridPanGestureRecognizerSpec_cxx>(param0));
+  }
+
+  Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx create_Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx(std::function<Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>(const void* NON_NULL param0)> closure) {
+    return Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx::make([closure = std::move(closure)](const ::ReactNitroRenderer::HybridPanGestureRecognizerSpec_cxx& param0) -> void {
+      auto __result = borrowSwiftValue(param0, [&](const void* param0) {
+        return closure(param0);
+      });
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    });
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridTapGestureRecognizerSpecSwift>(::ReactNitroRenderer::HybridTapGestureRecognizerSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridTapGestureRecognizerSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridTapGestureRecognizerSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std::shared_ptr<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift> upcast_TapGestureRecognizer_to_GestureRecognizer(const std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_& value) {
+    return value;
+  }
+
+  Result<void, margelo::nitro::renderer::swift_bridge::ResultTag> callSync_Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0) noexcept {
+    try {
+      callback.callSync(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridTapGestureRecognizerSpec_cxx>(param0));
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Promise<void> callAsync_Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0) {
+    return callback.callAsync(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridTapGestureRecognizerSpec_cxx>(param0));
+  }
+
+  void callAndForget_Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0) {
+    callback.callAndForget(NitroModules::copySwiftValue<::ReactNitroRenderer::HybridTapGestureRecognizerSpec_cxx>(param0));
+  }
+
+  Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx create_Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx(std::function<Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>(const void* NON_NULL param0)> closure) {
+    return Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx::make([closure = std::move(closure)](const ::ReactNitroRenderer::HybridTapGestureRecognizerSpec_cxx& param0) -> void {
+      auto __result = borrowSwiftValue(param0, [&](const void* param0) {
+        return closure(param0);
+      });
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    });
+  }
+
+  Result<void, margelo::nitro::renderer::swift_bridge::ResultTag> callSync_Callback_void(const Callback_void& callback) noexcept {
+    try {
+      callback.callSync();
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Callback_void create_Callback_void(std::function<Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>()> closure) {
+    return Callback_void::make([closure = std::move(closure)]() -> void {
+      auto __result = closure();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    });
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridLabelSpecSwift>(::ReactNitroRenderer::HybridLabelSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridLabelSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridLabelSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift> upcast_Label_to_View(const std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_& value) {
+    return value;
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridScreenSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridScreenSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridScreenSpecSwift>(::ReactNitroRenderer::HybridScreenSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridScreenSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridScreenSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridScreenSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridScrollViewSpecSwift>(::ReactNitroRenderer::HybridScrollViewSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridScrollViewSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridScrollViewSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift> upcast_ScrollView_to_View(const std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_& value) {
+    return value;
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridScrollViewContentSpecSwift>(::ReactNitroRenderer::HybridScrollViewContentSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridScrollViewContentSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridScrollViewContentSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift> upcast_ScrollViewContent_to_View(const std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_& value) {
+    return value;
+  }
+
+  std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::renderer::HybridViewControllerSpecSwift>(::ReactNitroRenderer::HybridViewControllerSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::renderer::HybridViewControllerSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridViewControllerSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  Result<void, margelo::nitro::renderer::swift_bridge::ResultTag> callSync_Callback_void___ReactNitroRenderer__EdgeInsets(const Callback_void___ReactNitroRenderer__EdgeInsets& callback, const void* NON_NULL param0) noexcept {
+    try {
+      callback.callSync(NitroModules::copySwiftValue<::ReactNitroRenderer::EdgeInsets>(param0));
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Promise<void> callAsync_Callback_void___ReactNitroRenderer__EdgeInsets(const Callback_void___ReactNitroRenderer__EdgeInsets& callback, const void* NON_NULL param0) {
+    return callback.callAsync(NitroModules::copySwiftValue<::ReactNitroRenderer::EdgeInsets>(param0));
+  }
+
+  void callAndForget_Callback_void___ReactNitroRenderer__EdgeInsets(const Callback_void___ReactNitroRenderer__EdgeInsets& callback, const void* NON_NULL param0) {
+    callback.callAndForget(NitroModules::copySwiftValue<::ReactNitroRenderer::EdgeInsets>(param0));
+  }
+
+  Callback_void___ReactNitroRenderer__EdgeInsets create_Callback_void___ReactNitroRenderer__EdgeInsets(std::function<Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>(const void* NON_NULL param0)> closure) {
+    return Callback_void___ReactNitroRenderer__EdgeInsets::make([closure = std::move(closure)](const ::ReactNitroRenderer::EdgeInsets& param0) -> void {
+      auto __result = borrowSwiftValue(param0, [&](const void* param0) {
+        return closure(param0);
+      });
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    });
+  }
+} // namespace margelo::nitro::renderer::swift_bridge

package/nitrogen/generated/apple/ReactNitroRendererAppleCxx/ReactNitroRendererAppleCxx.cpp

@@ -0,0 +1,9 @@
+///
+/// ReactNitroRendererAppleCxx.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+// Swift packages require at least one source file per C++ target.
+#include <ReactNitroRendererAppleCxx/ReactNitroRendererAppleCxx.h>