@rive-app/react-native 0.1.1-beta.0

package/nitrogen/generated/ios/RNRive-Swift-Cxx-Umbrella.hpp

@@ -0,0 +1,161 @@
+///
+/// RNRive-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `Alignment` to properly resolve imports.
+namespace margelo::nitro::rive { enum class Alignment; }
+// Forward declaration of `ArtboardByTypes` to properly resolve imports.
+namespace margelo::nitro::rive { enum class ArtboardByTypes; }
+// Forward declaration of `ArtboardBy` to properly resolve imports.
+namespace margelo::nitro::rive { struct ArtboardBy; }
+// Forward declaration of `DataBindByName` to properly resolve imports.
+namespace margelo::nitro::rive { struct DataBindByName; }
+// Forward declaration of `DataBindMode` to properly resolve imports.
+namespace margelo::nitro::rive { enum class DataBindMode; }
+// Forward declaration of `Fit` to properly resolve imports.
+namespace margelo::nitro::rive { enum class Fit; }
+// Forward declaration of `HybridRiveFileFactorySpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveFileFactorySpec; }
+// Forward declaration of `HybridRiveFileSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveFileSpec; }
+// Forward declaration of `HybridRiveImageFactorySpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveImageFactorySpec; }
+// Forward declaration of `HybridRiveImageSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveImageSpec; }
+// Forward declaration of `HybridRiveSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveSpec; }
+// Forward declaration of `HybridRiveViewSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveViewSpec; }
+// Forward declaration of `HybridViewModelBooleanPropertySpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelBooleanPropertySpec; }
+// Forward declaration of `HybridViewModelColorPropertySpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelColorPropertySpec; }
+// Forward declaration of `HybridViewModelEnumPropertySpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelEnumPropertySpec; }
+// Forward declaration of `HybridViewModelImagePropertySpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelImagePropertySpec; }
+// Forward declaration of `HybridViewModelInstanceSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelInstanceSpec; }
+// Forward declaration of `HybridViewModelNumberPropertySpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelNumberPropertySpec; }
+// Forward declaration of `HybridViewModelPropertySpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelPropertySpec; }
+// Forward declaration of `HybridViewModelSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelSpec; }
+// Forward declaration of `HybridViewModelStringPropertySpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelStringPropertySpec; }
+// Forward declaration of `HybridViewModelTriggerPropertySpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelTriggerPropertySpec; }
+// Forward declaration of `ReferencedAssetsType` to properly resolve imports.
+namespace margelo::nitro::rive { struct ReferencedAssetsType; }
+// Forward declaration of `ResolvedReferencedAsset` to properly resolve imports.
+namespace margelo::nitro::rive { struct ResolvedReferencedAsset; }
+// Forward declaration of `RiveErrorType` to properly resolve imports.
+namespace margelo::nitro::rive { enum class RiveErrorType; }
+// Forward declaration of `RiveError` to properly resolve imports.
+namespace margelo::nitro::rive { struct RiveError; }
+// Forward declaration of `RiveEventType` to properly resolve imports.
+namespace margelo::nitro::rive { enum class RiveEventType; }
+// Forward declaration of `UnifiedRiveEvent` to properly resolve imports.
+namespace margelo::nitro::rive { struct UnifiedRiveEvent; }
+
+// Include C++ defined types
+#include "Alignment.hpp"
+#include "ArtboardBy.hpp"
+#include "ArtboardByTypes.hpp"
+#include "DataBindByName.hpp"
+#include "DataBindMode.hpp"
+#include "Fit.hpp"
+#include "HybridRiveFileFactorySpec.hpp"
+#include "HybridRiveFileSpec.hpp"
+#include "HybridRiveImageFactorySpec.hpp"
+#include "HybridRiveImageSpec.hpp"
+#include "HybridRiveSpec.hpp"
+#include "HybridRiveViewSpec.hpp"
+#include "HybridViewModelBooleanPropertySpec.hpp"
+#include "HybridViewModelColorPropertySpec.hpp"
+#include "HybridViewModelEnumPropertySpec.hpp"
+#include "HybridViewModelImagePropertySpec.hpp"
+#include "HybridViewModelInstanceSpec.hpp"
+#include "HybridViewModelNumberPropertySpec.hpp"
+#include "HybridViewModelPropertySpec.hpp"
+#include "HybridViewModelSpec.hpp"
+#include "HybridViewModelStringPropertySpec.hpp"
+#include "HybridViewModelTriggerPropertySpec.hpp"
+#include "ReferencedAssetsType.hpp"
+#include "ResolvedReferencedAsset.hpp"
+#include "RiveError.hpp"
+#include "RiveErrorType.hpp"
+#include "RiveEventType.hpp"
+#include "UnifiedRiveEvent.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+
+// C++ helpers for Swift
+#include "RNRive-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridRiveFileFactorySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveFileFactorySpec_cxx; }
+// Forward declaration of `HybridRiveFileSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveFileSpec_cxx; }
+// Forward declaration of `HybridRiveImageFactorySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveImageFactorySpec_cxx; }
+// Forward declaration of `HybridRiveImageSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveImageSpec_cxx; }
+// Forward declaration of `HybridRiveSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveSpec_cxx; }
+// Forward declaration of `HybridRiveViewSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveViewSpec_cxx; }
+// Forward declaration of `HybridViewModelBooleanPropertySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridViewModelBooleanPropertySpec_cxx; }
+// Forward declaration of `HybridViewModelColorPropertySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridViewModelColorPropertySpec_cxx; }
+// Forward declaration of `HybridViewModelEnumPropertySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridViewModelEnumPropertySpec_cxx; }
+// Forward declaration of `HybridViewModelImagePropertySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridViewModelImagePropertySpec_cxx; }
+// Forward declaration of `HybridViewModelInstanceSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridViewModelInstanceSpec_cxx; }
+// Forward declaration of `HybridViewModelNumberPropertySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridViewModelNumberPropertySpec_cxx; }
+// Forward declaration of `HybridViewModelPropertySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridViewModelPropertySpec_cxx; }
+// Forward declaration of `HybridViewModelSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridViewModelSpec_cxx; }
+// Forward declaration of `HybridViewModelStringPropertySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridViewModelStringPropertySpec_cxx; }
+// Forward declaration of `HybridViewModelTriggerPropertySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridViewModelTriggerPropertySpec_cxx; }
+
+// Include Swift defined types
+#if __has_include("RNRive-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "RNRive".
+#include "RNRive-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<RNRive/RNRive-Swift.h>)
+#include <RNRive/RNRive-Swift.h>
+#else
+#error RNRive's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "RNRive", and try building the app first.
+#endif

package/nitrogen/generated/ios/RNRiveAutolinking.mm

@@ -0,0 +1,137 @@
+///
+/// RNRiveAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "RNRive-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridRiveSpecSwift.hpp"
+#include "HybridRiveFileFactorySpecSwift.hpp"
+#include "HybridRiveFileSpecSwift.hpp"
+#include "HybridViewModelSpecSwift.hpp"
+#include "HybridViewModelInstanceSpecSwift.hpp"
+#include "HybridViewModelNumberPropertySpecSwift.hpp"
+#include "HybridViewModelStringPropertySpecSwift.hpp"
+#include "HybridViewModelBooleanPropertySpecSwift.hpp"
+#include "HybridViewModelColorPropertySpecSwift.hpp"
+#include "HybridViewModelEnumPropertySpecSwift.hpp"
+#include "HybridViewModelTriggerPropertySpecSwift.hpp"
+#include "HybridViewModelImagePropertySpecSwift.hpp"
+#include "HybridRiveViewSpecSwift.hpp"
+#include "HybridRiveImageFactorySpecSwift.hpp"
+
+@interface RNRiveAutolinking : NSObject
+@end
+
+@implementation RNRiveAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::rive;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Rive",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridRiveSpec> hybridObject = RNRive::RNRiveAutolinking::createRive();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RiveFileFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridRiveFileFactorySpec> hybridObject = RNRive::RNRiveAutolinking::createRiveFileFactory();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RiveFile",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridRiveFileSpec> hybridObject = RNRive::RNRiveAutolinking::createRiveFile();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ViewModel",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridViewModelSpec> hybridObject = RNRive::RNRiveAutolinking::createViewModel();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ViewModelInstance",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridViewModelInstanceSpec> hybridObject = RNRive::RNRiveAutolinking::createViewModelInstance();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ViewModelNumberProperty",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridViewModelNumberPropertySpec> hybridObject = RNRive::RNRiveAutolinking::createViewModelNumberProperty();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ViewModelStringProperty",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridViewModelStringPropertySpec> hybridObject = RNRive::RNRiveAutolinking::createViewModelStringProperty();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ViewModelBooleanProperty",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridViewModelBooleanPropertySpec> hybridObject = RNRive::RNRiveAutolinking::createViewModelBooleanProperty();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ViewModelColorProperty",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridViewModelColorPropertySpec> hybridObject = RNRive::RNRiveAutolinking::createViewModelColorProperty();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ViewModelEnumProperty",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridViewModelEnumPropertySpec> hybridObject = RNRive::RNRiveAutolinking::createViewModelEnumProperty();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ViewModelTriggerProperty",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridViewModelTriggerPropertySpec> hybridObject = RNRive::RNRiveAutolinking::createViewModelTriggerProperty();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ViewModelImageProperty",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridViewModelImagePropertySpec> hybridObject = RNRive::RNRiveAutolinking::createViewModelImageProperty();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RiveView",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridRiveViewSpec> hybridObject = RNRive::RNRiveAutolinking::createRiveView();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RiveImageFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridRiveImageFactorySpec> hybridObject = RNRive::RNRiveAutolinking::createRiveImageFactory();
+      return hybridObject;
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/RNRiveAutolinking.swift

@@ -0,0 +1,220 @@
+///
+/// RNRiveAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+public final class RNRiveAutolinking {
+  public typealias bridge = margelo.nitro.rive.bridge.swift
+
+  /**
+   * Creates an instance of a Swift class that implements `HybridRiveSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridRiveSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `Rive`).
+   */
+  public static func createRive() -> bridge.std__shared_ptr_HybridRiveSpec_ {
+    let hybridObject = Rive()
+    return { () -> bridge.std__shared_ptr_HybridRiveSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridRiveFileFactorySpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridRiveFileFactorySpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridRiveFileFactory`).
+   */
+  public static func createRiveFileFactory() -> bridge.std__shared_ptr_HybridRiveFileFactorySpec_ {
+    let hybridObject = HybridRiveFileFactory()
+    return { () -> bridge.std__shared_ptr_HybridRiveFileFactorySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridRiveFileSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridRiveFileSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridRiveFile`).
+   */
+  public static func createRiveFile() -> bridge.std__shared_ptr_HybridRiveFileSpec_ {
+    let hybridObject = HybridRiveFile()
+    return { () -> bridge.std__shared_ptr_HybridRiveFileSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridViewModelSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridViewModelSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridViewModel`).
+   */
+  public static func createViewModel() -> bridge.std__shared_ptr_HybridViewModelSpec_ {
+    let hybridObject = HybridViewModel()
+    return { () -> bridge.std__shared_ptr_HybridViewModelSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridViewModelInstanceSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridViewModelInstanceSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridViewModelInstance`).
+   */
+  public static func createViewModelInstance() -> bridge.std__shared_ptr_HybridViewModelInstanceSpec_ {
+    let hybridObject = HybridViewModelInstance()
+    return { () -> bridge.std__shared_ptr_HybridViewModelInstanceSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridViewModelNumberPropertySpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridViewModelNumberPropertySpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridViewModelNumberProperty`).
+   */
+  public static func createViewModelNumberProperty() -> bridge.std__shared_ptr_HybridViewModelNumberPropertySpec_ {
+    let hybridObject = HybridViewModelNumberProperty()
+    return { () -> bridge.std__shared_ptr_HybridViewModelNumberPropertySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridViewModelStringPropertySpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridViewModelStringPropertySpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridViewModelStringProperty`).
+   */
+  public static func createViewModelStringProperty() -> bridge.std__shared_ptr_HybridViewModelStringPropertySpec_ {
+    let hybridObject = HybridViewModelStringProperty()
+    return { () -> bridge.std__shared_ptr_HybridViewModelStringPropertySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridViewModelBooleanPropertySpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridViewModelBooleanPropertySpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridViewModelBooleanProperty`).
+   */
+  public static func createViewModelBooleanProperty() -> bridge.std__shared_ptr_HybridViewModelBooleanPropertySpec_ {
+    let hybridObject = HybridViewModelBooleanProperty()
+    return { () -> bridge.std__shared_ptr_HybridViewModelBooleanPropertySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridViewModelColorPropertySpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridViewModelColorPropertySpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridViewModelColorProperty`).
+   */
+  public static func createViewModelColorProperty() -> bridge.std__shared_ptr_HybridViewModelColorPropertySpec_ {
+    let hybridObject = HybridViewModelColorProperty()
+    return { () -> bridge.std__shared_ptr_HybridViewModelColorPropertySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridViewModelEnumPropertySpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridViewModelEnumPropertySpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridViewModelEnumProperty`).
+   */
+  public static func createViewModelEnumProperty() -> bridge.std__shared_ptr_HybridViewModelEnumPropertySpec_ {
+    let hybridObject = HybridViewModelEnumProperty()
+    return { () -> bridge.std__shared_ptr_HybridViewModelEnumPropertySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridViewModelTriggerPropertySpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridViewModelTriggerPropertySpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridViewModelTriggerProperty`).
+   */
+  public static func createViewModelTriggerProperty() -> bridge.std__shared_ptr_HybridViewModelTriggerPropertySpec_ {
+    let hybridObject = HybridViewModelTriggerProperty()
+    return { () -> bridge.std__shared_ptr_HybridViewModelTriggerPropertySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridViewModelImagePropertySpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridViewModelImagePropertySpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridViewModelImageProperty`).
+   */
+  public static func createViewModelImageProperty() -> bridge.std__shared_ptr_HybridViewModelImagePropertySpec_ {
+    let hybridObject = HybridViewModelImageProperty()
+    return { () -> bridge.std__shared_ptr_HybridViewModelImagePropertySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridRiveViewSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridRiveViewSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridRiveView`).
+   */
+  public static func createRiveView() -> bridge.std__shared_ptr_HybridRiveViewSpec_ {
+    let hybridObject = HybridRiveView()
+    return { () -> bridge.std__shared_ptr_HybridRiveViewSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridRiveImageFactorySpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridRiveImageFactorySpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridRiveImageFactory`).
+   */
+  public static func createRiveImageFactory() -> bridge.std__shared_ptr_HybridRiveImageFactorySpec_ {
+    let hybridObject = HybridRiveImageFactory()
+    return { () -> bridge.std__shared_ptr_HybridRiveImageFactorySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+}

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

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

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

@@ -0,0 +1,119 @@
+///
+/// HybridRiveFileFactorySpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridRiveFileFactorySpec.hpp"
+
+// Forward declaration of `HybridRiveFileFactorySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveFileFactorySpec_cxx; }
+
+// Forward declaration of `HybridRiveFileSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveFileSpec; }
+// Forward declaration of `ReferencedAssetsType` to properly resolve imports.
+namespace margelo::nitro::rive { struct ReferencedAssetsType; }
+// Forward declaration of `ResolvedReferencedAsset` to properly resolve imports.
+namespace margelo::nitro::rive { struct ResolvedReferencedAsset; }
+// Forward declaration of `HybridRiveImageSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveImageSpec; }
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+
+#include <memory>
+#include "HybridRiveFileSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include <string>
+#include "ReferencedAssetsType.hpp"
+#include <optional>
+#include "ResolvedReferencedAsset.hpp"
+#include <unordered_map>
+#include "HybridRiveImageSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
+
+#include "RNRive-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::rive {
+
+  /**
+   * The C++ part of HybridRiveFileFactorySpec_cxx.swift.
+   *
+   * HybridRiveFileFactorySpecSwift (C++) accesses HybridRiveFileFactorySpec_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, HybridRiveFileFactorySpec_cxx can directly inherit from the C++ class HybridRiveFileFactorySpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridRiveFileFactorySpecSwift: public virtual HybridRiveFileFactorySpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridRiveFileFactorySpecSwift(const RNRive::HybridRiveFileFactorySpec_cxx& swiftPart):
+      HybridObject(HybridRiveFileFactorySpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline RNRive::HybridRiveFileFactorySpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> fromURL(const std::string& url, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) override {
+      auto __result = _swiftPart.fromURL(url, std::forward<decltype(loadCdn)>(loadCdn), referencedAssets);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> fromFileURL(const std::string& fileURL, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) override {
+      auto __result = _swiftPart.fromFileURL(fileURL, std::forward<decltype(loadCdn)>(loadCdn), referencedAssets);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> fromResource(const std::string& resource, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) override {
+      auto __result = _swiftPart.fromResource(resource, std::forward<decltype(loadCdn)>(loadCdn), referencedAssets);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> fromBytes(const std::shared_ptr<ArrayBuffer>& bytes, bool loadCdn, const std::optional<ReferencedAssetsType>& referencedAssets) override {
+      auto __result = _swiftPart.fromBytes(ArrayBufferHolder(bytes), std::forward<decltype(loadCdn)>(loadCdn), referencedAssets);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    RNRive::HybridRiveFileFactorySpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::rive

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

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