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

package/nitrogen/generated/apple/ReactNitroRendererAppleCxx/include/ReactNitroRendererAppleCxx/ReactNitroRendererAppleCxx.h

@@ -0,0 +1,245 @@
+///
+/// ReactNitroRendererAppleCxx.h
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declaration of `HybridAnimatorSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridAnimatorSpec_cxx; }
+#ifndef SWIFT_SWIFT_H
+namespace swift { template <class T> class Optional; }
+#endif
+#include <NitroModules/Result.hpp>
+// Forward declaration of `HybridApplicationSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridApplicationSpec_cxx; }
+// Forward declaration of `HybridViewSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridViewSpec_cxx; }
+// Forward declaration of `HybridWindowSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridWindowSpec_cxx; }
+// Forward declaration of `HybridWindowSceneSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridWindowSceneSpec_cxx; }
+#include <NitroModules/Callback.hpp>
+// Forward declaration of `HybridGestureRecognizerSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridGestureRecognizerSpec_cxx; }
+// Forward declaration of `GestureRecognizerState` to properly resolve imports.
+namespace ReactNitroRenderer { class GestureRecognizerState; }
+// Forward declaration of `HybridLongPressGestureRecognizerSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridLongPressGestureRecognizerSpec_cxx; }
+// Forward declaration of `HybridPanGestureRecognizerSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridPanGestureRecognizerSpec_cxx; }
+// Forward declaration of `Point` to properly resolve imports.
+namespace ReactNitroRenderer { class Point; }
+// Forward declaration of `HybridTapGestureRecognizerSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridTapGestureRecognizerSpec_cxx; }
+// Forward declaration of `EdgeInsets` to properly resolve imports.
+namespace ReactNitroRenderer { class EdgeInsets; }
+// Forward declaration of `Corner` to properly resolve imports.
+namespace ReactNitroRenderer { class Corner; }
+#ifndef SWIFT_SWIFT_H
+namespace swift { template <class T> class Array; }
+#endif
+// Forward declaration of `CornerCurve` to properly resolve imports.
+namespace ReactNitroRenderer { class CornerCurve; }
+// Forward declaration of `Point3D` to properly resolve imports.
+namespace ReactNitroRenderer { class Point3D; }
+// Forward declaration of `Frame` to properly resolve imports.
+namespace ReactNitroRenderer { class Frame; }
+// Forward declaration of `AnimationCurve` to properly resolve imports.
+namespace ReactNitroRenderer { class AnimationCurve; }
+// Forward declaration of `HybridLabelSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridLabelSpec_cxx; }
+namespace swift { class String; }
+// Forward declaration of `HybridScreenSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridScreenSpec_cxx; }
+// Forward declaration of `Size` to properly resolve imports.
+namespace ReactNitroRenderer { class Size; }
+// Forward declaration of `HybridScrollViewSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridScrollViewSpec_cxx; }
+// Forward declaration of `HybridScrollViewContentSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridScrollViewContentSpec_cxx; }
+// Forward declaration of `HybridViewControllerSpec_cxx` to properly resolve imports.
+namespace ReactNitroRenderer { class HybridViewControllerSpec_cxx; }
+// Forward declaration of `ListenerSubscription` to properly resolve imports.
+namespace ReactNitroRenderer { class ListenerSubscription; }
+// Forward declaration of `ModifierKey` to properly resolve imports.
+namespace ReactNitroRenderer { class ModifierKey; }
+#include <NitroModules/HybridObject.hpp>
+// Forward declaration of `HybridAnimatorSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridAnimatorSpecSwift; }
+#include <NitroModules/NitroDefines.hpp>
+// Forward declaration of `HybridApplicationSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridApplicationSpecSwift; }
+// Forward declaration of `HybridViewSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridViewSpecSwift; }
+// Forward declaration of `HybridWindowSceneSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridWindowSceneSpecSwift; }
+// Forward declaration of `HybridWindowSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridWindowSpecSwift; }
+#include <NitroModules/Promise.hpp>
+// Forward declaration of `HybridGestureRecognizerSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridGestureRecognizerSpecSwift; }
+// Forward declaration of `HybridLongPressGestureRecognizerSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridLongPressGestureRecognizerSpecSwift; }
+// Forward declaration of `HybridPanGestureRecognizerSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridPanGestureRecognizerSpecSwift; }
+// Forward declaration of `HybridTapGestureRecognizerSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridTapGestureRecognizerSpecSwift; }
+// Forward declaration of `HybridLabelSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridLabelSpecSwift; }
+// Forward declaration of `HybridScreenSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridScreenSpecSwift; }
+// Forward declaration of `HybridScrollViewSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridScrollViewSpecSwift; }
+// Forward declaration of `HybridScrollViewContentSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridScrollViewContentSpecSwift; }
+// Forward declaration of `HybridViewControllerSpecSwift` to properly resolve imports.
+namespace margelo::nitro::renderer { class HybridViewControllerSpecSwift; }
+
+namespace margelo::nitro::renderer::swift_bridge {
+  using std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridAnimatorSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridAnimatorSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridAnimatorSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridAnimatorSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridAnimatorSpec_(const std::shared_ptr<HybridObject>& value);
+  // Distinct specializations prevent duplicate Swift metadata across module headers.
+  struct ResultTag {};
+  using Result_void = Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>;
+  using std__shared_ptr_margelo__nitro__renderer__HybridApplicationSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridApplicationSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridApplicationSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridApplicationSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridApplicationSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridApplicationSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridApplicationSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridApplicationSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridApplicationSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridApplicationSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridViewSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridViewSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridViewSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridViewSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridWindowSceneSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridWindowSceneSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridWindowSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridWindowSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridWindowSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridWindowSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_(const std::shared_ptr<HybridObject>& value);
+  using Promise___ReactNitroRenderer__HybridWindowSpec_cxx = Promise<::ReactNitroRenderer::HybridWindowSpec_cxx>;
+  Promise___ReactNitroRenderer__HybridWindowSpec_cxx create_Promise___ReactNitroRenderer__HybridWindowSpec_cxx();
+  void reject_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(const Promise___ReactNitroRenderer__HybridWindowSpec_cxx& promise, std::exception_ptr error);
+  void listenRejected_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(const Promise___ReactNitroRenderer__HybridWindowSpec_cxx& promise, std::function<void(const std::exception_ptr&)> listener);
+  void resolve_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(const Promise___ReactNitroRenderer__HybridWindowSpec_cxx& promise, const void* NON_NULL value);
+  void listen_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(const Promise___ReactNitroRenderer__HybridWindowSpec_cxx& promise, std::function<void(const void* NON_NULL)> listener);
+  using Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx = Callback<::ReactNitroRenderer::HybridWindowSpec_cxx(const ::ReactNitroRenderer::HybridWindowSceneSpec_cxx&)>;
+  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;
+  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);
+  void callAndForget_Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx(const Callback___ReactNitroRenderer__HybridWindowSpec_cxx___ReactNitroRenderer__HybridWindowSceneSpec_cxx& callback, const void* NON_NULL 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);
+  using Result_void_ = Result<void*, margelo::nitro::renderer::swift_bridge::ResultTag>;
+  using std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridGestureRecognizerSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridLongPressGestureRecognizerSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridLongPressGestureRecognizerSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_(const std::shared_ptr<HybridObject>& value);
+  std::shared_ptr<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift> upcast_LongPressGestureRecognizer_to_GestureRecognizer(const std__shared_ptr_margelo__nitro__renderer__HybridLongPressGestureRecognizerSpec_& value);
+  using Promise_void = Promise<void>;
+  using Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx = Callback<void(const ::ReactNitroRenderer::HybridLongPressGestureRecognizerSpec_cxx&)>;
+  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;
+  Promise<void> callAsync_Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0);
+  void callAndForget_Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridLongPressGestureRecognizerSpec_cxx& callback, const void* NON_NULL 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);
+  using std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridPanGestureRecognizerSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridPanGestureRecognizerSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_(const std::shared_ptr<HybridObject>& value);
+  std::shared_ptr<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift> upcast_PanGestureRecognizer_to_GestureRecognizer(const std__shared_ptr_margelo__nitro__renderer__HybridPanGestureRecognizerSpec_& value);
+  using Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx = Callback<void(const ::ReactNitroRenderer::HybridPanGestureRecognizerSpec_cxx&)>;
+  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;
+  Promise<void> callAsync_Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0);
+  void callAndForget_Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridPanGestureRecognizerSpec_cxx& callback, const void* NON_NULL 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);
+  using std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridTapGestureRecognizerSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridTapGestureRecognizerSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_(const std::shared_ptr<HybridObject>& value);
+  std::shared_ptr<margelo::nitro::renderer::HybridGestureRecognizerSpecSwift> upcast_TapGestureRecognizer_to_GestureRecognizer(const std__shared_ptr_margelo__nitro__renderer__HybridTapGestureRecognizerSpec_& value);
+  using Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx = Callback<void(const ::ReactNitroRenderer::HybridTapGestureRecognizerSpec_cxx&)>;
+  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;
+  Promise<void> callAsync_Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx& callback, const void* NON_NULL param0);
+  void callAndForget_Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx(const Callback_void___ReactNitroRenderer__HybridTapGestureRecognizerSpec_cxx& callback, const void* NON_NULL 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);
+  using Callback_void = Callback<void()>;
+  Result<void, margelo::nitro::renderer::swift_bridge::ResultTag> callSync_Callback_void(const Callback_void& callback) noexcept;
+  Callback_void create_Callback_void(std::function<Result<void, margelo::nitro::renderer::swift_bridge::ResultTag>()> closure);
+  using std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridLabelSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridLabelSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridLabelSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridLabelSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_(const std::shared_ptr<HybridObject>& value);
+  std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift> upcast_Label_to_View(const std__shared_ptr_margelo__nitro__renderer__HybridLabelSpec_& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridScreenSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridScreenSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridScreenSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridScreenSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridScreenSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridScreenSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridScreenSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridScreenSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridScreenSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridScreenSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridScrollViewSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridScrollViewSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridScrollViewSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridScrollViewSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_(const std::shared_ptr<HybridObject>& value);
+  std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift> upcast_ScrollView_to_View(const std__shared_ptr_margelo__nitro__renderer__HybridScrollViewSpec_& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridScrollViewContentSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridScrollViewContentSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_(const std::shared_ptr<HybridObject>& value);
+  std::shared_ptr<margelo::nitro::renderer::HybridViewSpecSwift> upcast_ScrollViewContent_to_View(const std__shared_ptr_margelo__nitro__renderer__HybridScrollViewContentSpec_& value);
+  using std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_ = std::shared_ptr<margelo::nitro::renderer::HybridViewControllerSpecSwift>;
+  using std__weak_ptr_margelo__nitro__renderer__HybridViewControllerSpec_ = std::weak_ptr<margelo::nitro::renderer::HybridViewControllerSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__renderer__HybridViewControllerSpec_ weakify_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(const std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_ create_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__renderer__HybridViewControllerSpec_(const std::shared_ptr<HybridObject>& value);
+  using Callback_void___ReactNitroRenderer__EdgeInsets = Callback<void(const ::ReactNitroRenderer::EdgeInsets&)>;
+  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;
+  Promise<void> callAsync_Callback_void___ReactNitroRenderer__EdgeInsets(const Callback_void___ReactNitroRenderer__EdgeInsets& callback, const void* NON_NULL param0);
+  void callAndForget_Callback_void___ReactNitroRenderer__EdgeInsets(const Callback_void___ReactNitroRenderer__EdgeInsets& callback, const void* NON_NULL 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);
+} // namespace margelo::nitro::renderer::swift_bridge

package/nitrogen/generated/apple/ReactNitroRendererAutolinking.cpp

@@ -0,0 +1,46 @@
+///
+/// ReactNitroRendererAutolinking.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroRenderer/ReactNitroRendererAutolinking.hpp>
+#include <NitroModules/HybridClassRegistry.hpp>
+
+#include <ReactNitroRenderer/private/HybridAnimatorSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridApplicationSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridGestureRecognizerSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridLongPressGestureRecognizerSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridPanGestureRecognizerSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridTapGestureRecognizerSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridLabelSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridScreenSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridScrollViewSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridScrollViewContentSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridViewSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridViewControllerSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridWindowSpecSwift.hpp>
+#include <ReactNitroRenderer/private/HybridWindowSceneSpecSwift.hpp>
+
+namespace margelo::nitro::renderer {
+  void registerHybridClasses() {
+    using namespace margelo::nitro;
+    using namespace margelo::nitro::renderer;
+
+    HybridClassRegistry::registerHybridClass("renderer.Animator", HybridAnimatorSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.Application", HybridApplicationSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.GestureRecognizer", HybridGestureRecognizerSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.LongPressGestureRecognizer", HybridLongPressGestureRecognizerSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.PanGestureRecognizer", HybridPanGestureRecognizerSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.TapGestureRecognizer", HybridTapGestureRecognizerSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.Label", HybridLabelSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.Screen", HybridScreenSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.ScrollView", HybridScrollViewSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.ScrollViewContent", HybridScrollViewContentSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.View", HybridViewSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.ViewController", HybridViewControllerSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.Window", HybridWindowSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("renderer.WindowScene", HybridWindowSceneSpecSwift::Class::get());
+  }
+} // namespace margelo::nitro::renderer

package/nitrogen/generated/apple/ReactNitroRendererAutolinking.mm

@@ -0,0 +1,24 @@
+///
+/// ReactNitroRendererAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#include <ReactNitroRenderer/ReactNitroRendererAutolinking.hpp>
+
+/**
+ * Registers all HybridObject classes of ReactNitroRenderer
+ * when the app loads, so JS can look them up by name.
+ */
+@interface ReactNitroRendererAutolinking : NSObject
+@end
+
+@implementation ReactNitroRendererAutolinking
+
++ (void)load {
+  margelo::nitro::renderer::registerHybridClasses();
+}
+
+@end

package/nitrogen/generated/apple/c++/AnimationCurve-Swift.cpp

@@ -0,0 +1,42 @@
+///
+/// AnimationCurve-Swift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroRenderer/private/AnimationCurve-Swift.hpp>
+#include <ReactNitroRenderer/private/ReactNitroRenderer-Swift-Cxx-Umbrella.hpp>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/NumberUtils.hpp>
+#include <NitroModules/JSIString.hpp>
+
+namespace margelo::nitro {
+
+  ::ReactNitroRenderer::AnimationCurve JSIConverter<::ReactNitroRenderer::AnimationCurve>::fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    const int integer = doubleToInt(value.asNumber());
+    switch (integer) {
+      case 0: return ::ReactNitroRenderer::AnimationCurve::fromRawValue(0);
+      case 1: return ::ReactNitroRenderer::AnimationCurve::fromRawValue(1);
+      case 2: return ::ReactNitroRenderer::AnimationCurve::fromRawValue(2);
+      case 3: return ::ReactNitroRenderer::AnimationCurve::fromRawValue(3);
+      default: [[unlikely]]
+        throw std::invalid_argument("Cannot convert " + value.toString(runtime).utf8(runtime) + " to enum AnimationCurve - invalid value!");
+    }
+  }
+
+  jsi::Value JSIConverter<::ReactNitroRenderer::AnimationCurve>::toJSI(jsi::Runtime& runtime, const ::ReactNitroRenderer::AnimationCurve& value) {
+    return jsi::Value(value.getRawValue());
+  }
+
+  bool JSIConverter<::ReactNitroRenderer::AnimationCurve>::canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isNumber()) { return false; }
+    const double number = value.getNumber();
+    if (!(number >= 0 && number <= 3)) { return false; }
+    const auto integer = static_cast<int32_t>(number);
+    if (number != integer) { return false; }
+    return true;
+  }
+
+} // namespace margelo::nitro

package/nitrogen/generated/apple/c++/Corner-Swift.cpp

@@ -0,0 +1,52 @@
+///
+/// Corner-Swift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroRenderer/private/Corner-Swift.hpp>
+#include <ReactNitroRenderer/private/ReactNitroRenderer-Swift-Cxx-Umbrella.hpp>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/NumberUtils.hpp>
+#include <NitroModules/JSIString.hpp>
+
+namespace margelo::nitro {
+
+  ::ReactNitroRenderer::Corner JSIConverter<::ReactNitroRenderer::Corner>::fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    const auto string = value.asString(runtime).utf8(runtime);
+    switch (hashString(string)) {
+      case hashString("topLeft"): return ::ReactNitroRenderer::Corner::fromRawValue(0);
+      case hashString("topRight"): return ::ReactNitroRenderer::Corner::fromRawValue(1);
+      case hashString("bottomLeft"): return ::ReactNitroRenderer::Corner::fromRawValue(2);
+      case hashString("bottomRight"): return ::ReactNitroRenderer::Corner::fromRawValue(3);
+      default: [[unlikely]]
+        throw std::invalid_argument("Cannot convert \"" + string + "\" to enum Corner - invalid value!");
+    }
+  }
+
+  jsi::Value JSIConverter<::ReactNitroRenderer::Corner>::toJSI(jsi::Runtime& runtime, const ::ReactNitroRenderer::Corner& value) {
+    switch (value.getRawValue()) {
+      case 0: return createJSIString<"topLeft">(runtime);
+      case 1: return createJSIString<"topRight">(runtime);
+      case 2: return createJSIString<"bottomLeft">(runtime);
+      case 3: return createJSIString<"bottomRight">(runtime);
+      default: [[unlikely]]
+        throw std::invalid_argument("Cannot convert Corner to JS - invalid value: " + std::to_string(value.getRawValue()) + "!");
+    }
+  }
+
+  bool JSIConverter<::ReactNitroRenderer::Corner>::canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isString()) return false;
+    const auto string = value.getString(runtime).utf8(runtime);
+    switch (hashString(string)) {
+      case hashString("topLeft"): return true;
+      case hashString("topRight"): return true;
+      case hashString("bottomLeft"): return true;
+      case hashString("bottomRight"): return true;
+      default: return false;
+    }
+  }
+
+} // namespace margelo::nitro

package/nitrogen/generated/apple/c++/CornerCurve-Swift.cpp

@@ -0,0 +1,46 @@
+///
+/// CornerCurve-Swift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroRenderer/private/CornerCurve-Swift.hpp>
+#include <ReactNitroRenderer/private/ReactNitroRenderer-Swift-Cxx-Umbrella.hpp>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/NumberUtils.hpp>
+#include <NitroModules/JSIString.hpp>
+
+namespace margelo::nitro {
+
+  ::ReactNitroRenderer::CornerCurve JSIConverter<::ReactNitroRenderer::CornerCurve>::fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    const auto string = value.asString(runtime).utf8(runtime);
+    switch (hashString(string)) {
+      case hashString("circular"): return ::ReactNitroRenderer::CornerCurve::fromRawValue(0);
+      case hashString("continuous"): return ::ReactNitroRenderer::CornerCurve::fromRawValue(1);
+      default: [[unlikely]]
+        throw std::invalid_argument("Cannot convert \"" + string + "\" to enum CornerCurve - invalid value!");
+    }
+  }
+
+  jsi::Value JSIConverter<::ReactNitroRenderer::CornerCurve>::toJSI(jsi::Runtime& runtime, const ::ReactNitroRenderer::CornerCurve& value) {
+    switch (value.getRawValue()) {
+      case 0: return createJSIString<"circular">(runtime);
+      case 1: return createJSIString<"continuous">(runtime);
+      default: [[unlikely]]
+        throw std::invalid_argument("Cannot convert CornerCurve to JS - invalid value: " + std::to_string(value.getRawValue()) + "!");
+    }
+  }
+
+  bool JSIConverter<::ReactNitroRenderer::CornerCurve>::canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isString()) return false;
+    const auto string = value.getString(runtime).utf8(runtime);
+    switch (hashString(string)) {
+      case hashString("circular"): return true;
+      case hashString("continuous"): return true;
+      default: return false;
+    }
+  }
+
+} // namespace margelo::nitro

package/nitrogen/generated/apple/c++/EdgeInsets-Swift.cpp

@@ -0,0 +1,35 @@
+///
+/// EdgeInsets-Swift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroRenderer/private/EdgeInsets-Swift.hpp>
+#include <ReactNitroRenderer/private/ReactNitroRenderer-Swift-Cxx-Umbrella.hpp>
+#include <NitroModules/PropNameIDCache.hpp>
+
+namespace margelo::nitro {
+
+  ::ReactNitroRenderer::EdgeInsets JSIConverter<::ReactNitroRenderer::EdgeInsets>::fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    auto object = value.asObject(runtime);
+    return ::ReactNitroRenderer::EdgeInsets::init_cxx(JSIConverter<double>::fromJSI(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "top"))), JSIConverter<double>::fromJSI(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "right"))), JSIConverter<double>::fromJSI(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "bottom"))), JSIConverter<double>::fromJSI(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "left"))));
+  }
+
+  jsi::Value JSIConverter<::ReactNitroRenderer::EdgeInsets>::toJSI(jsi::Runtime& runtime, const ::ReactNitroRenderer::EdgeInsets& value) {
+    jsi::Object object(runtime);
+    object.setProperty(runtime, PropNameIDCache::get(runtime, "top"), JSIConverter<double>::toJSI(runtime, value.getTop_cxx()));
+    object.setProperty(runtime, PropNameIDCache::get(runtime, "right"), JSIConverter<double>::toJSI(runtime, value.getRight_cxx()));
+    object.setProperty(runtime, PropNameIDCache::get(runtime, "bottom"), JSIConverter<double>::toJSI(runtime, value.getBottom_cxx()));
+    object.setProperty(runtime, PropNameIDCache::get(runtime, "left"), JSIConverter<double>::toJSI(runtime, value.getLeft_cxx()));
+    return object;
+  }
+
+  bool JSIConverter<::ReactNitroRenderer::EdgeInsets>::canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isObject()) return false;
+    auto object = value.getObject(runtime);
+    if (!isPlainObject(runtime, object)) return false;
+    return JSIConverter<double>::canConvert(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "top"))) && JSIConverter<double>::canConvert(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "right"))) && JSIConverter<double>::canConvert(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "bottom"))) && JSIConverter<double>::canConvert(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "left")));
+  }
+
+} // namespace margelo::nitro

package/nitrogen/generated/apple/c++/Frame-Swift.cpp

@@ -0,0 +1,35 @@
+///
+/// Frame-Swift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroRenderer/private/Frame-Swift.hpp>
+#include <ReactNitroRenderer/private/ReactNitroRenderer-Swift-Cxx-Umbrella.hpp>
+#include <NitroModules/PropNameIDCache.hpp>
+
+namespace margelo::nitro {
+
+  ::ReactNitroRenderer::Frame JSIConverter<::ReactNitroRenderer::Frame>::fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    auto object = value.asObject(runtime);
+    return ::ReactNitroRenderer::Frame::init_cxx(JSIConverter<double>::fromJSI(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "x"))), JSIConverter<double>::fromJSI(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "y"))), JSIConverter<double>::fromJSI(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "width"))), JSIConverter<double>::fromJSI(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "height"))));
+  }
+
+  jsi::Value JSIConverter<::ReactNitroRenderer::Frame>::toJSI(jsi::Runtime& runtime, const ::ReactNitroRenderer::Frame& value) {
+    jsi::Object object(runtime);
+    object.setProperty(runtime, PropNameIDCache::get(runtime, "x"), JSIConverter<double>::toJSI(runtime, value.getX_cxx()));
+    object.setProperty(runtime, PropNameIDCache::get(runtime, "y"), JSIConverter<double>::toJSI(runtime, value.getY_cxx()));
+    object.setProperty(runtime, PropNameIDCache::get(runtime, "width"), JSIConverter<double>::toJSI(runtime, value.getWidth_cxx()));
+    object.setProperty(runtime, PropNameIDCache::get(runtime, "height"), JSIConverter<double>::toJSI(runtime, value.getHeight_cxx()));
+    return object;
+  }
+
+  bool JSIConverter<::ReactNitroRenderer::Frame>::canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isObject()) return false;
+    auto object = value.getObject(runtime);
+    if (!isPlainObject(runtime, object)) return false;
+    return JSIConverter<double>::canConvert(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "x"))) && JSIConverter<double>::canConvert(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "y"))) && JSIConverter<double>::canConvert(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "width"))) && JSIConverter<double>::canConvert(runtime, object.getProperty(runtime, PropNameIDCache::get(runtime, "height")));
+  }
+
+} // namespace margelo::nitro

package/nitrogen/generated/apple/c++/GestureRecognizerState-Swift.cpp

@@ -0,0 +1,44 @@
+///
+/// GestureRecognizerState-Swift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroRenderer/private/GestureRecognizerState-Swift.hpp>
+#include <ReactNitroRenderer/private/ReactNitroRenderer-Swift-Cxx-Umbrella.hpp>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/NumberUtils.hpp>
+#include <NitroModules/JSIString.hpp>
+
+namespace margelo::nitro {
+
+  ::ReactNitroRenderer::GestureRecognizerState JSIConverter<::ReactNitroRenderer::GestureRecognizerState>::fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    const int integer = doubleToInt(value.asNumber());
+    switch (integer) {
+      case 0: return ::ReactNitroRenderer::GestureRecognizerState::fromRawValue(0);
+      case 1: return ::ReactNitroRenderer::GestureRecognizerState::fromRawValue(1);
+      case 2: return ::ReactNitroRenderer::GestureRecognizerState::fromRawValue(2);
+      case 3: return ::ReactNitroRenderer::GestureRecognizerState::fromRawValue(3);
+      case 4: return ::ReactNitroRenderer::GestureRecognizerState::fromRawValue(4);
+      case 5: return ::ReactNitroRenderer::GestureRecognizerState::fromRawValue(5);
+      default: [[unlikely]]
+        throw std::invalid_argument("Cannot convert " + value.toString(runtime).utf8(runtime) + " to enum GestureRecognizerState - invalid value!");
+    }
+  }
+
+  jsi::Value JSIConverter<::ReactNitroRenderer::GestureRecognizerState>::toJSI(jsi::Runtime& runtime, const ::ReactNitroRenderer::GestureRecognizerState& value) {
+    return jsi::Value(value.getRawValue());
+  }
+
+  bool JSIConverter<::ReactNitroRenderer::GestureRecognizerState>::canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isNumber()) { return false; }
+    const double number = value.getNumber();
+    if (!(number >= 0 && number <= 5)) { return false; }
+    const auto integer = static_cast<int32_t>(number);
+    if (number != integer) { return false; }
+    return true;
+  }
+
+} // namespace margelo::nitro