@rive-app/react-native 0.2.6 → 0.2.7

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

@@ -22,18 +22,20 @@ namespace margelo::nitro::rive { enum class DataBindMode; }
 namespace margelo::nitro::rive { enum class Fit; }
 // Forward declaration of `HybridBindableArtboardSpec` to properly resolve imports.
 namespace margelo::nitro::rive { class HybridBindableArtboardSpec; }
+// Forward declaration of `HybridFallbackFontSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridFallbackFontSpec; }
 // 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 `HybridRiveFontConfigSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveFontConfigSpec; }
 // 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 `HybridRiveRuntimeSpec` to properly resolve imports.
 namespace margelo::nitro::rive { class HybridRiveRuntimeSpec; }
-// 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 `HybridViewModelArtboardPropertySpec` to properly resolve imports.
@@ -76,18 +78,20 @@ namespace margelo::nitro::rive { struct UnifiedRiveEvent; }
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridBindableArtboardSpec_cxx` to properly resolve imports.
 namespace RNRive { class HybridBindableArtboardSpec_cxx; }
+// Forward declaration of `HybridFallbackFontSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridFallbackFontSpec_cxx; }
 // 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 `HybridRiveFontConfigSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveFontConfigSpec_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 `HybridRiveRuntimeSpec_cxx` to properly resolve imports.
 namespace RNRive { class HybridRiveRuntimeSpec_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 `HybridViewModelArtboardPropertySpec_cxx` to properly resolve imports.
@@ -123,12 +127,13 @@ namespace RNRive { class HybridViewModelTriggerPropertySpec_cxx; }
 #include "DataBindMode.hpp"
 #include "Fit.hpp"
 #include "HybridBindableArtboardSpec.hpp"
+#include "HybridFallbackFontSpec.hpp"
 #include "HybridRiveFileFactorySpec.hpp"
 #include "HybridRiveFileSpec.hpp"
+#include "HybridRiveFontConfigSpec.hpp"
 #include "HybridRiveImageFactorySpec.hpp"
 #include "HybridRiveImageSpec.hpp"
 #include "HybridRiveRuntimeSpec.hpp"
-#include "HybridRiveSpec.hpp"
 #include "HybridRiveViewSpec.hpp"
 #include "HybridViewModelArtboardPropertySpec.hpp"
 #include "HybridViewModelBooleanPropertySpec.hpp"
@@ -178,27 +183,6 @@ namespace margelo::nitro::rive::bridge::swift {
   using std__weak_ptr_HybridBindableArtboardSpec_ = std::weak_ptr<HybridBindableArtboardSpec>;
   inline std__weak_ptr_HybridBindableArtboardSpec_ weakify_std__shared_ptr_HybridBindableArtboardSpec_(const std::shared_ptr<HybridBindableArtboardSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: std::shared_ptr<HybridRiveSpec>
-  /**
-   * Specialized version of `std::shared_ptr<HybridRiveSpec>`.
-   */
-  using std__shared_ptr_HybridRiveSpec_ = std::shared_ptr<HybridRiveSpec>;
-  std::shared_ptr<HybridRiveSpec> create_std__shared_ptr_HybridRiveSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
-  void* NON_NULL get_std__shared_ptr_HybridRiveSpec_(std__shared_ptr_HybridRiveSpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<HybridRiveSpec>
-  using std__weak_ptr_HybridRiveSpec_ = std::weak_ptr<HybridRiveSpec>;
-  inline std__weak_ptr_HybridRiveSpec_ weakify_std__shared_ptr_HybridRiveSpec_(const std::shared_ptr<HybridRiveSpec>& strong) noexcept { return strong; }
-  
-  // pragma MARK: Result<double>
-  using Result_double_ = Result<double>;
-  inline Result_double_ create_Result_double_(double value) noexcept {
-    return Result<double>::withValue(std::move(value));
-  }
-  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
-    return Result<double>::withError(error);
-  }
-  
   // pragma MARK: std::optional<double>
   /**
    * Specialized version of `std::optional<double>`.
@@ -480,59 +464,61 @@ namespace margelo::nitro::rive::bridge::swift {
     return Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>>>::withError(error);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>
+  // pragma MARK: std::shared_ptr<HybridFallbackFontSpec>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>`.
+   * Specialized version of `std::shared_ptr<HybridFallbackFontSpec>`.
    */
-  using std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec___ = std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>;
-  inline std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>> create_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec___() noexcept {
-    return Promise<std::shared_ptr<HybridRiveImageSpec>>::create();
+  using std__shared_ptr_HybridFallbackFontSpec_ = std::shared_ptr<HybridFallbackFontSpec>;
+  std::shared_ptr<HybridFallbackFontSpec> create_std__shared_ptr_HybridFallbackFontSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridFallbackFontSpec_(std__shared_ptr_HybridFallbackFontSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridFallbackFontSpec>
+  using std__weak_ptr_HybridFallbackFontSpec_ = std::weak_ptr<HybridFallbackFontSpec>;
+  inline std__weak_ptr_HybridFallbackFontSpec_ weakify_std__shared_ptr_HybridFallbackFontSpec_(const std::shared_ptr<HybridFallbackFontSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_HybridFallbackFontSpec___ = std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>> create_std__shared_ptr_Promise_std__shared_ptr_HybridFallbackFontSpec___() noexcept {
+    return Promise<std::shared_ptr<HybridFallbackFontSpec>>::create();
   }
-  inline PromiseHolder<std::shared_ptr<HybridRiveImageSpec>> wrap_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec___(std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>> promise) noexcept {
-    return PromiseHolder<std::shared_ptr<HybridRiveImageSpec>>(std::move(promise));
+  inline PromiseHolder<std::shared_ptr<HybridFallbackFontSpec>> wrap_std__shared_ptr_Promise_std__shared_ptr_HybridFallbackFontSpec___(std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<HybridFallbackFontSpec>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>
+  // pragma MARK: std::function<void(const std::shared_ptr<HybridFallbackFontSpec>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::shared_ptr<HybridRiveImageSpec>&)>`.
+   * Specialized version of `std::function<void(const std::shared_ptr<HybridFallbackFontSpec>&)>`.
    */
-  using Func_void_std__shared_ptr_HybridRiveImageSpec_ = std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>;
+  using Func_void_std__shared_ptr_HybridFallbackFontSpec_ = std::function<void(const std::shared_ptr<HybridFallbackFontSpec>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::shared_ptr<HybridRiveImageSpec>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::shared_ptr<HybridFallbackFontSpec>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__shared_ptr_HybridRiveImageSpec__Wrapper final {
+  class Func_void_std__shared_ptr_HybridFallbackFontSpec__Wrapper final {
   public:
-    explicit Func_void_std__shared_ptr_HybridRiveImageSpec__Wrapper(std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>>(std::move(func))) {}
-    inline void call(std::shared_ptr<HybridRiveImageSpec> result) const noexcept {
+    explicit Func_void_std__shared_ptr_HybridFallbackFontSpec__Wrapper(std::function<void(const std::shared_ptr<HybridFallbackFontSpec>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<HybridFallbackFontSpec>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<HybridFallbackFontSpec> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::shared_ptr<HybridFallbackFontSpec>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__shared_ptr_HybridRiveImageSpec_ create_Func_void_std__shared_ptr_HybridRiveImageSpec_(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__shared_ptr_HybridRiveImageSpec__Wrapper wrap_Func_void_std__shared_ptr_HybridRiveImageSpec_(Func_void_std__shared_ptr_HybridRiveImageSpec_ value) noexcept {
-    return Func_void_std__shared_ptr_HybridRiveImageSpec__Wrapper(std::move(value));
+  Func_void_std__shared_ptr_HybridFallbackFontSpec_ create_Func_void_std__shared_ptr_HybridFallbackFontSpec_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_HybridFallbackFontSpec__Wrapper wrap_Func_void_std__shared_ptr_HybridFallbackFontSpec_(Func_void_std__shared_ptr_HybridFallbackFontSpec_ value) noexcept {
+    return Func_void_std__shared_ptr_HybridFallbackFontSpec__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<HybridRiveImageFactorySpec>
+  // pragma MARK: std::vector<std::shared_ptr<HybridFallbackFontSpec>>
   /**
-   * Specialized version of `std::shared_ptr<HybridRiveImageFactorySpec>`.
+   * Specialized version of `std::vector<std::shared_ptr<HybridFallbackFontSpec>>`.
    */
-  using std__shared_ptr_HybridRiveImageFactorySpec_ = std::shared_ptr<HybridRiveImageFactorySpec>;
-  std::shared_ptr<HybridRiveImageFactorySpec> create_std__shared_ptr_HybridRiveImageFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
-  void* NON_NULL get_std__shared_ptr_HybridRiveImageFactorySpec_(std__shared_ptr_HybridRiveImageFactorySpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<HybridRiveImageFactorySpec>
-  using std__weak_ptr_HybridRiveImageFactorySpec_ = std::weak_ptr<HybridRiveImageFactorySpec>;
-  inline std__weak_ptr_HybridRiveImageFactorySpec_ weakify_std__shared_ptr_HybridRiveImageFactorySpec_(const std::shared_ptr<HybridRiveImageFactorySpec>& strong) noexcept { return strong; }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>>
-  using Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec____ = Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>>;
-  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec____(const std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec____(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>>::withError(error);
+  using std__vector_std__shared_ptr_HybridFallbackFontSpec__ = std::vector<std::shared_ptr<HybridFallbackFontSpec>>;
+  inline std::vector<std::shared_ptr<HybridFallbackFontSpec>> create_std__vector_std__shared_ptr_HybridFallbackFontSpec__(size_t size) noexcept {
+    std::vector<std::shared_ptr<HybridFallbackFontSpec>> vector;
+    vector.reserve(size);
+    return vector;
   }
   
   // pragma MARK: std::shared_ptr<Promise<void>>
@@ -569,17 +555,35 @@ namespace margelo::nitro::rive::bridge::swift {
     return Func_void_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<HybridRiveRuntimeSpec>
+  // pragma MARK: std::shared_ptr<HybridRiveFontConfigSpec>
   /**
-   * Specialized version of `std::shared_ptr<HybridRiveRuntimeSpec>`.
+   * Specialized version of `std::shared_ptr<HybridRiveFontConfigSpec>`.
    */
-  using std__shared_ptr_HybridRiveRuntimeSpec_ = std::shared_ptr<HybridRiveRuntimeSpec>;
-  std::shared_ptr<HybridRiveRuntimeSpec> create_std__shared_ptr_HybridRiveRuntimeSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
-  void* NON_NULL get_std__shared_ptr_HybridRiveRuntimeSpec_(std__shared_ptr_HybridRiveRuntimeSpec_ cppType);
+  using std__shared_ptr_HybridRiveFontConfigSpec_ = std::shared_ptr<HybridRiveFontConfigSpec>;
+  std::shared_ptr<HybridRiveFontConfigSpec> create_std__shared_ptr_HybridRiveFontConfigSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridRiveFontConfigSpec_(std__shared_ptr_HybridRiveFontConfigSpec_ cppType);
   
-  // pragma MARK: std::weak_ptr<HybridRiveRuntimeSpec>
-  using std__weak_ptr_HybridRiveRuntimeSpec_ = std::weak_ptr<HybridRiveRuntimeSpec>;
-  inline std__weak_ptr_HybridRiveRuntimeSpec_ weakify_std__shared_ptr_HybridRiveRuntimeSpec_(const std::shared_ptr<HybridRiveRuntimeSpec>& strong) noexcept { return strong; }
+  // pragma MARK: std::weak_ptr<HybridRiveFontConfigSpec>
+  using std__weak_ptr_HybridRiveFontConfigSpec_ = std::weak_ptr<HybridRiveFontConfigSpec>;
+  inline std__weak_ptr_HybridRiveFontConfigSpec_ weakify_std__shared_ptr_HybridRiveFontConfigSpec_(const std::shared_ptr<HybridRiveFontConfigSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>>>
+  using Result_std__shared_ptr_Promise_std__shared_ptr_HybridFallbackFontSpec____ = Result<std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>>>;
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridFallbackFontSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridFallbackFontSpec____(const std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridFallbackFontSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridFallbackFontSpec____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridFallbackFontSpec>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<HybridFallbackFontSpec>>
+  using Result_std__shared_ptr_HybridFallbackFontSpec__ = Result<std::shared_ptr<HybridFallbackFontSpec>>;
+  inline Result_std__shared_ptr_HybridFallbackFontSpec__ create_Result_std__shared_ptr_HybridFallbackFontSpec__(const std::shared_ptr<HybridFallbackFontSpec>& value) noexcept {
+    return Result<std::shared_ptr<HybridFallbackFontSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_HybridFallbackFontSpec__ create_Result_std__shared_ptr_HybridFallbackFontSpec__(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<HybridFallbackFontSpec>>::withError(error);
+  }
   
   // pragma MARK: Result<std::shared_ptr<Promise<void>>>
   using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
@@ -590,6 +594,73 @@ namespace margelo::nitro::rive::bridge::swift {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
   
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec___ = std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>> create_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec___() noexcept {
+    return Promise<std::shared_ptr<HybridRiveImageSpec>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<HybridRiveImageSpec>> wrap_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec___(std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<HybridRiveImageSpec>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<HybridRiveImageSpec>&)>`.
+   */
+  using Func_void_std__shared_ptr_HybridRiveImageSpec_ = std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<HybridRiveImageSpec>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_HybridRiveImageSpec__Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_HybridRiveImageSpec__Wrapper(std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<HybridRiveImageSpec> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<HybridRiveImageSpec>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_HybridRiveImageSpec_ create_Func_void_std__shared_ptr_HybridRiveImageSpec_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_HybridRiveImageSpec__Wrapper wrap_Func_void_std__shared_ptr_HybridRiveImageSpec_(Func_void_std__shared_ptr_HybridRiveImageSpec_ value) noexcept {
+    return Func_void_std__shared_ptr_HybridRiveImageSpec__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridRiveImageFactorySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridRiveImageFactorySpec>`.
+   */
+  using std__shared_ptr_HybridRiveImageFactorySpec_ = std::shared_ptr<HybridRiveImageFactorySpec>;
+  std::shared_ptr<HybridRiveImageFactorySpec> create_std__shared_ptr_HybridRiveImageFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridRiveImageFactorySpec_(std__shared_ptr_HybridRiveImageFactorySpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridRiveImageFactorySpec>
+  using std__weak_ptr_HybridRiveImageFactorySpec_ = std::weak_ptr<HybridRiveImageFactorySpec>;
+  inline std__weak_ptr_HybridRiveImageFactorySpec_ weakify_std__shared_ptr_HybridRiveImageFactorySpec_(const std::shared_ptr<HybridRiveImageFactorySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>>
+  using Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec____ = Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>>;
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec____(const std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveImageSpec____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>>>::withError(error);
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridRiveRuntimeSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridRiveRuntimeSpec>`.
+   */
+  using std__shared_ptr_HybridRiveRuntimeSpec_ = std::shared_ptr<HybridRiveRuntimeSpec>;
+  std::shared_ptr<HybridRiveRuntimeSpec> create_std__shared_ptr_HybridRiveRuntimeSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridRiveRuntimeSpec_(std__shared_ptr_HybridRiveRuntimeSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridRiveRuntimeSpec>
+  using std__weak_ptr_HybridRiveRuntimeSpec_ = std::weak_ptr<HybridRiveRuntimeSpec>;
+  inline std__weak_ptr_HybridRiveRuntimeSpec_ weakify_std__shared_ptr_HybridRiveRuntimeSpec_(const std::shared_ptr<HybridRiveRuntimeSpec>& strong) noexcept { return strong; }
+  
   // pragma MARK: std::optional<bool>
   /**
    * Specialized version of `std::optional<bool>`.
@@ -895,6 +966,15 @@ namespace margelo::nitro::rive::bridge::swift {
     return Result<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>::withError(error);
   }
   
+  // pragma MARK: Result<double>
+  using Result_double_ = Result<double>;
+  inline Result_double_ create_Result_double_(double value) noexcept {
+    return Result<double>::withValue(std::move(value));
+  }
+  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
+    return Result<double>::withError(error);
+  }
+  
   // pragma MARK: Result<bool>
   using Result_bool_ = Result<bool>;
   inline Result_bool_ create_Result_bool_(bool value) noexcept {

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

@@ -22,18 +22,20 @@ namespace margelo::nitro::rive { enum class DataBindMode; }
 namespace margelo::nitro::rive { enum class Fit; }
 // Forward declaration of `HybridBindableArtboardSpec` to properly resolve imports.
 namespace margelo::nitro::rive { class HybridBindableArtboardSpec; }
+// Forward declaration of `HybridFallbackFontSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridFallbackFontSpec; }
 // 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 `HybridRiveFontConfigSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveFontConfigSpec; }
 // 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 `HybridRiveRuntimeSpec` to properly resolve imports.
 namespace margelo::nitro::rive { class HybridRiveRuntimeSpec; }
-// 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 `HybridViewModelArtboardPropertySpec` to properly resolve imports.
@@ -81,12 +83,13 @@ namespace margelo::nitro::rive { struct UnifiedRiveEvent; }
 #include "DataBindMode.hpp"
 #include "Fit.hpp"
 #include "HybridBindableArtboardSpec.hpp"
+#include "HybridFallbackFontSpec.hpp"
 #include "HybridRiveFileFactorySpec.hpp"
 #include "HybridRiveFileSpec.hpp"
+#include "HybridRiveFontConfigSpec.hpp"
 #include "HybridRiveImageFactorySpec.hpp"
 #include "HybridRiveImageSpec.hpp"
 #include "HybridRiveRuntimeSpec.hpp"
-#include "HybridRiveSpec.hpp"
 #include "HybridRiveViewSpec.hpp"
 #include "HybridViewModelArtboardPropertySpec.hpp"
 #include "HybridViewModelBooleanPropertySpec.hpp"
@@ -130,18 +133,20 @@ namespace margelo::nitro::rive { struct UnifiedRiveEvent; }
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridBindableArtboardSpec_cxx` to properly resolve imports.
 namespace RNRive { class HybridBindableArtboardSpec_cxx; }
+// Forward declaration of `HybridFallbackFontSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridFallbackFontSpec_cxx; }
 // 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 `HybridRiveFontConfigSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveFontConfigSpec_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 `HybridRiveRuntimeSpec_cxx` to properly resolve imports.
 namespace RNRive { class HybridRiveRuntimeSpec_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 `HybridViewModelArtboardPropertySpec_cxx` to properly resolve imports.

package/nitrogen/generated/ios/RNRiveAutolinking.mm

@@ -10,7 +10,7 @@
 #import "RNRive-Swift-Cxx-Umbrella.hpp"
 #import <type_traits>
 
-#include "HybridRiveSpecSwift.hpp"
+#include "HybridRiveFontConfigSpecSwift.hpp"
 #include "HybridRiveFileFactorySpecSwift.hpp"
 #include "HybridRiveFileSpecSwift.hpp"
 #include "HybridRiveViewSpecSwift.hpp"
@@ -27,9 +27,9 @@
   using namespace margelo::nitro::rive;
 
   HybridObjectRegistry::registerHybridObjectConstructor(
-    "Rive",
+    "RiveFontConfig",
     []() -> std::shared_ptr<HybridObject> {
-      std::shared_ptr<HybridRiveSpec> hybridObject = RNRive::RNRiveAutolinking::createRive();
+      std::shared_ptr<HybridRiveFontConfigSpec> hybridObject = RNRive::RNRiveAutolinking::createRiveFontConfig();
       return hybridObject;
     }
   );

package/nitrogen/generated/ios/RNRiveAutolinking.swift

@@ -12,16 +12,16 @@ import NitroModules
 public final class RNRiveAutolinking {
   public typealias bridge = margelo.nitro.rive.bridge.swift
 
-  public static func createRive() -> bridge.std__shared_ptr_HybridRiveSpec_ {
-    let hybridObject = Rive()
-    return { () -> bridge.std__shared_ptr_HybridRiveSpec_ in
+  public static func createRiveFontConfig() -> bridge.std__shared_ptr_HybridRiveFontConfigSpec_ {
+    let hybridObject = HybridRiveFontConfig()
+    return { () -> bridge.std__shared_ptr_HybridRiveFontConfigSpec_ in
       let __cxxWrapped = hybridObject.getCxxWrapper()
       return __cxxWrapped.getCxxPart()
     }()
   }
   
-  public static func isRiveRecyclable() -> Bool {
-    return Rive.self is any RecyclableView.Type
+  public static func isRiveFontConfigRecyclable() -> Bool {
+    return HybridRiveFontConfig.self is any RecyclableView.Type
   }
   
   public static func createRiveFileFactory() -> bridge.std__shared_ptr_HybridRiveFileFactorySpec_ {

package/nitrogen/generated/ios/c++/{HybridRiveSpecSwift.cpp → HybridFallbackFontSpecSwift.cpp}

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

package/nitrogen/generated/ios/c++/{HybridRiveSpecSwift.hpp → HybridFallbackFontSpecSwift.hpp}

@@ -1,5 +1,5 @@
 ///
-/// HybridRiveSpecSwift.hpp
+/// HybridFallbackFontSpecSwift.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -7,10 +7,10 @@
 
 #pragma once
 
-#include "HybridRiveSpec.hpp"
+#include "HybridFallbackFontSpec.hpp"
 
-// Forward declaration of `HybridRiveSpec_cxx` to properly resolve imports.
-namespace RNRive { class HybridRiveSpec_cxx; }
+// Forward declaration of `HybridFallbackFontSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridFallbackFontSpec_cxx; }
 
 
 
@@ -21,25 +21,25 @@ namespace RNRive { class HybridRiveSpec_cxx; }
 namespace margelo::nitro::rive {
 
   /**
-   * The C++ part of HybridRiveSpec_cxx.swift.
+   * The C++ part of HybridFallbackFontSpec_cxx.swift.
    *
-   * HybridRiveSpecSwift (C++) accesses HybridRiveSpec_cxx (Swift), and might
+   * HybridFallbackFontSpecSwift (C++) accesses HybridFallbackFontSpec_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, HybridRiveSpec_cxx can directly inherit from the C++ class HybridRiveSpec
+   * the future, HybridFallbackFontSpec_cxx can directly inherit from the C++ class HybridFallbackFontSpec
    * to simplify the whole structure and memory management.
    */
-  class HybridRiveSpecSwift: public virtual HybridRiveSpec {
+  class HybridFallbackFontSpecSwift: public virtual HybridFallbackFontSpec {
   public:
     // Constructor from a Swift instance
-    explicit HybridRiveSpecSwift(const RNRive::HybridRiveSpec_cxx& swiftPart):
-      HybridObject(HybridRiveSpec::TAG),
+    explicit HybridFallbackFontSpecSwift(const RNRive::HybridFallbackFontSpec_cxx& swiftPart):
+      HybridObject(HybridFallbackFontSpec::TAG),
       _swiftPart(swiftPart) { }
 
   public:
     // Get the Swift part
-    inline RNRive::HybridRiveSpec_cxx& getSwiftPart() noexcept {
+    inline RNRive::HybridFallbackFontSpec_cxx& getSwiftPart() noexcept {
       return _swiftPart;
     }
 
@@ -48,7 +48,7 @@ namespace margelo::nitro::rive {
       return _swiftPart.getMemorySize();
     }
     bool equals(const std::shared_ptr<HybridObject>& other) override {
-      if (auto otherCast = std::dynamic_pointer_cast<HybridRiveSpecSwift>(other)) {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridFallbackFontSpecSwift>(other)) {
         return _swiftPart.equals(otherCast->_swiftPart);
       }
       return false;
@@ -66,17 +66,10 @@ namespace margelo::nitro::rive {
 
   public:
     // Methods
-    inline double multiply(double a, double b) override {
-      auto __result = _swiftPart.multiply(std::forward<decltype(a)>(a), std::forward<decltype(b)>(b));
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-      auto __value = std::move(__result.value());
-      return __value;
-    }
+    
 
   private:
-    RNRive::HybridRiveSpec_cxx _swiftPart;
+    RNRive::HybridFallbackFontSpec_cxx _swiftPart;
   };
 
 } // namespace margelo::nitro::rive

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

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