react-native-list 1.0.1 → 2.0.0-alpha.1

package/nitrogen/generated/ios/c++/HybridIOSWorkletsModuleProxyHolderSpecSwift.hpp

@@ -0,0 +1,75 @@
+///
+/// HybridIOSWorkletsModuleProxyHolderSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridIOSWorkletsModuleProxyHolderSpec.hpp"
+
+// Forward declaration of `HybridIOSWorkletsModuleProxyHolderSpec_cxx` to properly resolve imports.
+namespace ReactNativeList { class HybridIOSWorkletsModuleProxyHolderSpec_cxx; }
+
+
+
+
+
+#include "ReactNativeList-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::reactnativelist {
+
+  /**
+   * The C++ part of HybridIOSWorkletsModuleProxyHolderSpec_cxx.swift.
+   *
+   * HybridIOSWorkletsModuleProxyHolderSpecSwift (C++) accesses HybridIOSWorkletsModuleProxyHolderSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridIOSWorkletsModuleProxyHolderSpec_cxx can directly inherit from the C++ class HybridIOSWorkletsModuleProxyHolderSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridIOSWorkletsModuleProxyHolderSpecSwift: public virtual HybridIOSWorkletsModuleProxyHolderSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridIOSWorkletsModuleProxyHolderSpecSwift(const ReactNativeList::HybridIOSWorkletsModuleProxyHolderSpec_cxx& swiftPart):
+      HybridObject(HybridIOSWorkletsModuleProxyHolderSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeList::HybridIOSWorkletsModuleProxyHolderSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridIOSWorkletsModuleProxyHolderSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    
+
+  private:
+    ReactNativeList::HybridIOSWorkletsModuleProxyHolderSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridNativeLinearListLayoutSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridNativeLinearListLayoutSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNativeLinearListLayoutSpecSwift.hpp"
+
+namespace margelo::nitro::reactnativelist {
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridNativeLinearListLayoutSpecSwift.hpp

@@ -0,0 +1,92 @@
+///
+/// HybridNativeLinearListLayoutSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNativeLinearListLayoutSpec.hpp"
+
+// Forward declaration of `HybridNativeLinearListLayoutSpec_cxx` to properly resolve imports.
+namespace ReactNativeList { class HybridNativeLinearListLayoutSpec_cxx; }
+
+// Forward declaration of `NativeLinearListLayoutConfig` to properly resolve imports.
+namespace margelo::nitro::reactnativelist { struct NativeLinearListLayoutConfig; }
+// Forward declaration of `NativeLinearListLayoutIOSConfig` to properly resolve imports.
+namespace margelo::nitro::reactnativelist { struct NativeLinearListLayoutIOSConfig; }
+// Forward declaration of `NativeItemSizeEstimate` to properly resolve imports.
+namespace margelo::nitro::reactnativelist { struct NativeItemSizeEstimate; }
+// Forward declaration of `HybridNativeListLayoutSpecSwift` to properly resolve imports.
+namespace margelo::nitro::reactnativelist { class HybridNativeListLayoutSpecSwift; }
+
+#include "NativeLinearListLayoutConfig.hpp"
+#include "NativeLinearListLayoutIOSConfig.hpp"
+#include <optional>
+#include "NativeItemSizeEstimate.hpp"
+#include "HybridNativeListLayoutSpecSwift.hpp"
+
+#include "ReactNativeList-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::reactnativelist {
+
+  /**
+   * The C++ part of HybridNativeLinearListLayoutSpec_cxx.swift.
+   *
+   * HybridNativeLinearListLayoutSpecSwift (C++) accesses HybridNativeLinearListLayoutSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridNativeLinearListLayoutSpec_cxx can directly inherit from the C++ class HybridNativeLinearListLayoutSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNativeLinearListLayoutSpecSwift: public virtual HybridNativeLinearListLayoutSpec, public virtual HybridNativeListLayoutSpecSwift {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNativeLinearListLayoutSpecSwift(const ReactNativeList::HybridNativeLinearListLayoutSpec_cxx& swiftPart):
+      HybridObject(HybridNativeLinearListLayoutSpec::TAG),
+      HybridNativeListLayoutSpecSwift(swiftPart),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeList::HybridNativeLinearListLayoutSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridNativeLinearListLayoutSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline void setConfig(const NativeLinearListLayoutConfig& config) override {
+      auto __result = _swiftPart.setConfig(std::forward<decltype(config)>(config));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    ReactNativeList::HybridNativeLinearListLayoutSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridNativeListDataSourceSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridNativeListDataSourceSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNativeListDataSourceSpecSwift.hpp"
+
+namespace margelo::nitro::reactnativelist {
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridNativeListDataSourceSpecSwift.hpp

@@ -0,0 +1,132 @@
+///
+/// HybridNativeListDataSourceSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNativeListDataSourceSpec.hpp"
+
+// Forward declaration of `HybridNativeListDataSourceSpec_cxx` to properly resolve imports.
+namespace ReactNativeList { class HybridNativeListDataSourceSpec_cxx; }
+
+// Forward declaration of `NativeListItem` to properly resolve imports.
+namespace margelo::nitro::reactnativelist { struct NativeListItem; }
+
+#include "NativeListItem.hpp"
+#include <functional>
+#include <string>
+#include <optional>
+#include <NitroModules/AnyMap.hpp>
+#include <vector>
+
+#include "ReactNativeList-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::reactnativelist {
+
+  /**
+   * The C++ part of HybridNativeListDataSourceSpec_cxx.swift.
+   *
+   * HybridNativeListDataSourceSpecSwift (C++) accesses HybridNativeListDataSourceSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridNativeListDataSourceSpec_cxx can directly inherit from the C++ class HybridNativeListDataSourceSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNativeListDataSourceSpecSwift: public virtual HybridNativeListDataSourceSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNativeListDataSourceSpecSwift(const ReactNativeList::HybridNativeListDataSourceSpec_cxx& swiftPart):
+      HybridObject(HybridNativeListDataSourceSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeList::HybridNativeListDataSourceSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridNativeListDataSourceSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline void setContentEqualCallback(const std::function<bool(const NativeListItem& /* oldItem */, const NativeListItem& /* newItem */)>& isContentEqual) override {
+      auto __result = _swiftPart.setContentEqualCallback(isContentEqual);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void replaceData(const std::vector<NativeListItem>& items, bool animated) override {
+      auto __result = _swiftPart.replaceData(items, std::forward<decltype(animated)>(animated));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void insertItem(double index, const NativeListItem& item) override {
+      auto __result = _swiftPart.insertItem(std::forward<decltype(index)>(index), std::forward<decltype(item)>(item));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void updateItem(double index, const NativeListItem& item) override {
+      auto __result = _swiftPart.updateItem(std::forward<decltype(index)>(index), std::forward<decltype(item)>(item));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void removeItem(double index) override {
+      auto __result = _swiftPart.removeItem(std::forward<decltype(index)>(index));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void moveItem(double fromIndex, double toIndex) override {
+      auto __result = _swiftPart.moveItem(std::forward<decltype(fromIndex)>(fromIndex), std::forward<decltype(toIndex)>(toIndex));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline double getCount() override {
+      auto __result = _swiftPart.getCount();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline NativeListItem getItem(double index) override {
+      auto __result = _swiftPart.getItem(std::forward<decltype(index)>(index));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    ReactNativeList::HybridNativeListDataSourceSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridNativeListLayoutSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridNativeListLayoutSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNativeListLayoutSpecSwift.hpp"
+
+namespace margelo::nitro::reactnativelist {
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridNativeListLayoutSpecSwift.hpp

@@ -0,0 +1,75 @@
+///
+/// HybridNativeListLayoutSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNativeListLayoutSpec.hpp"
+
+// Forward declaration of `HybridNativeListLayoutSpec_cxx` to properly resolve imports.
+namespace ReactNativeList { class HybridNativeListLayoutSpec_cxx; }
+
+
+
+
+
+#include "ReactNativeList-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::reactnativelist {
+
+  /**
+   * The C++ part of HybridNativeListLayoutSpec_cxx.swift.
+   *
+   * HybridNativeListLayoutSpecSwift (C++) accesses HybridNativeListLayoutSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridNativeListLayoutSpec_cxx can directly inherit from the C++ class HybridNativeListLayoutSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNativeListLayoutSpecSwift: public virtual HybridNativeListLayoutSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNativeListLayoutSpecSwift(const ReactNativeList::HybridNativeListLayoutSpec_cxx& swiftPart):
+      HybridObject(HybridNativeListLayoutSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeList::HybridNativeListLayoutSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridNativeListLayoutSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    
+
+  private:
+    ReactNativeList::HybridNativeListLayoutSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridUiListModuleSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridUiListModuleSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridUiListModuleSpecSwift.hpp"
+
+namespace margelo::nitro::reactnativelist {
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridUiListModuleSpecSwift.hpp

@@ -0,0 +1,93 @@
+///
+/// HybridUiListModuleSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridUiListModuleSpec.hpp"
+
+// Forward declaration of `HybridUiListModuleSpec_cxx` to properly resolve imports.
+namespace ReactNativeList { class HybridUiListModuleSpec_cxx; }
+
+// Forward declaration of `HybridIOSWorkletsModuleProxyHolderSpec` to properly resolve imports.
+namespace margelo::nitro::reactnativelist { class HybridIOSWorkletsModuleProxyHolderSpec; }
+
+#include <memory>
+#include "HybridIOSWorkletsModuleProxyHolderSpec.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <optional>
+
+#include "ReactNativeList-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::reactnativelist {
+
+  /**
+   * The C++ part of HybridUiListModuleSpec_cxx.swift.
+   *
+   * HybridUiListModuleSpecSwift (C++) accesses HybridUiListModuleSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridUiListModuleSpec_cxx can directly inherit from the C++ class HybridUiListModuleSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridUiListModuleSpecSwift: public virtual HybridUiListModuleSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridUiListModuleSpecSwift(const ReactNativeList::HybridUiListModuleSpec_cxx& swiftPart):
+      HybridObject(HybridUiListModuleSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeList::HybridUiListModuleSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridUiListModuleSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<HybridIOSWorkletsModuleProxyHolderSpec> iosGetWorkletsModule() override {
+      auto __result = _swiftPart.iosGetWorkletsModule();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void setupRuntime(const std::optional<std::variant<nitro::NullType, std::shared_ptr<HybridIOSWorkletsModuleProxyHolderSpec>>>& workletsModuleHolder) override {
+      auto __result = _swiftPart.setupRuntime(workletsModuleHolder);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    ReactNativeList::HybridUiListModuleSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridUiListViewSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridUiListViewSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridUiListViewSpecSwift.hpp"
+
+namespace margelo::nitro::reactnativelist {
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridUiListViewSpecSwift.hpp

@@ -0,0 +1,121 @@
+///
+/// HybridUiListViewSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridUiListViewSpec.hpp"
+
+// Forward declaration of `HybridUiListViewSpec_cxx` to properly resolve imports.
+namespace ReactNativeList { class HybridUiListViewSpec_cxx; }
+
+// Forward declaration of `HybridUiListModuleSpec` to properly resolve imports.
+namespace margelo::nitro::reactnativelist { class HybridUiListModuleSpec; }
+// Forward declaration of `NativeListItem` to properly resolve imports.
+namespace margelo::nitro::reactnativelist { struct NativeListItem; }
+// Forward declaration of `HybridNativeListDataSourceSpec` to properly resolve imports.
+namespace margelo::nitro::reactnativelist { class HybridNativeListDataSourceSpec; }
+// Forward declaration of `HybridNativeListLayoutSpec` to properly resolve imports.
+namespace margelo::nitro::reactnativelist { class HybridNativeListLayoutSpec; }
+
+#include <memory>
+#include "HybridUiListModuleSpec.hpp"
+#include <string>
+#include <functional>
+#include "NativeListItem.hpp"
+#include <optional>
+#include <NitroModules/AnyMap.hpp>
+#include "HybridNativeListDataSourceSpec.hpp"
+#include "HybridNativeListLayoutSpec.hpp"
+
+#include "ReactNativeList-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::reactnativelist {
+
+  /**
+   * The C++ part of HybridUiListViewSpec_cxx.swift.
+   *
+   * HybridUiListViewSpecSwift (C++) accesses HybridUiListViewSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridUiListViewSpec_cxx can directly inherit from the C++ class HybridUiListViewSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridUiListViewSpecSwift: public virtual HybridUiListViewSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridUiListViewSpecSwift(const ReactNativeList::HybridUiListViewSpec_cxx& swiftPart):
+      HybridObject(HybridUiListViewSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeList::HybridUiListViewSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridUiListViewSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline void setListCallbacks(const std::shared_ptr<HybridUiListModuleSpec>& uiListModule, const std::function<double(const std::string& /* type */)>& createView, const std::function<bool(double /* reactTag */, const NativeListItem& /* item */, double /* index */)>& updateView) override {
+      auto __result = _swiftPart.setListCallbacks(uiListModule, createView, updateView);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setDataSource(const std::shared_ptr<HybridNativeListDataSourceSpec>& dataSource) override {
+      auto __result = _swiftPart.setDataSource(dataSource);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setLayout(const std::shared_ptr<HybridNativeListLayoutSpec>& layout) override {
+      auto __result = _swiftPart.setLayout(layout);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline double getSurfaceId() override {
+      auto __result = _swiftPart.getSurfaceId();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void disposeRendererSurface() override {
+      auto __result = _swiftPart.disposeRendererSurface();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    ReactNativeList::HybridUiListViewSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::reactnativelist

package/nitrogen/generated/ios/c++/HybridViewHolderSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridViewHolderSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridViewHolderSpecSwift.hpp"
+
+namespace margelo::nitro::reactnativelist {
+} // namespace margelo::nitro::reactnativelist