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

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

@@ -0,0 +1,1180 @@
+///
+/// RNRive-Swift-Cxx-Bridge.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; }
+
+// 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 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/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::rive::bridge::swift {
+
+  // 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>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridViewModelSpec>`.
+   */
+  using std__shared_ptr_HybridViewModelSpec_ = std::shared_ptr<HybridViewModelSpec>;
+  std::shared_ptr<HybridViewModelSpec> create_std__shared_ptr_HybridViewModelSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridViewModelSpec_(std__shared_ptr_HybridViewModelSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridViewModelSpec>
+  using std__weak_ptr_HybridViewModelSpec_ = std::weak_ptr<HybridViewModelSpec>;
+  inline std__weak_ptr_HybridViewModelSpec_ weakify_std__shared_ptr_HybridViewModelSpec_(const std::shared_ptr<HybridViewModelSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelSpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelSpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridViewModelSpec__ = std::optional<std::shared_ptr<HybridViewModelSpec>>;
+  inline std::optional<std::shared_ptr<HybridViewModelSpec>> create_std__optional_std__shared_ptr_HybridViewModelSpec__(const std::shared_ptr<HybridViewModelSpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridViewModelSpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelSpec__(const std::optional<std::shared_ptr<HybridViewModelSpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridViewModelSpec> get_std__optional_std__shared_ptr_HybridViewModelSpec__(const std::optional<std::shared_ptr<HybridViewModelSpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<ArtboardBy>
+  /**
+   * Specialized version of `std::optional<ArtboardBy>`.
+   */
+  using std__optional_ArtboardBy_ = std::optional<ArtboardBy>;
+  inline std::optional<ArtboardBy> create_std__optional_ArtboardBy_(const ArtboardBy& value) noexcept {
+    return std::optional<ArtboardBy>(value);
+  }
+  inline bool has_value_std__optional_ArtboardBy_(const std::optional<ArtboardBy>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ArtboardBy get_std__optional_ArtboardBy_(const std::optional<ArtboardBy>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridRiveImageSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridRiveImageSpec>`.
+   */
+  using std__shared_ptr_HybridRiveImageSpec_ = std::shared_ptr<HybridRiveImageSpec>;
+  std::shared_ptr<HybridRiveImageSpec> create_std__shared_ptr_HybridRiveImageSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridRiveImageSpec_(std__shared_ptr_HybridRiveImageSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridRiveImageSpec>
+  using std__weak_ptr_HybridRiveImageSpec_ = std::weak_ptr<HybridRiveImageSpec>;
+  inline std__weak_ptr_HybridRiveImageSpec_ weakify_std__shared_ptr_HybridRiveImageSpec_(const std::shared_ptr<HybridRiveImageSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<std::shared_ptr<HybridRiveImageSpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridRiveImageSpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridRiveImageSpec__ = std::optional<std::shared_ptr<HybridRiveImageSpec>>;
+  inline std::optional<std::shared_ptr<HybridRiveImageSpec>> create_std__optional_std__shared_ptr_HybridRiveImageSpec__(const std::shared_ptr<HybridRiveImageSpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridRiveImageSpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridRiveImageSpec__(const std::optional<std::shared_ptr<HybridRiveImageSpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridRiveImageSpec> get_std__optional_std__shared_ptr_HybridRiveImageSpec__(const std::optional<std::shared_ptr<HybridRiveImageSpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::unordered_map<std::string, ResolvedReferencedAsset>
+  /**
+   * Specialized version of `std::unordered_map<std::string, ResolvedReferencedAsset>`.
+   */
+  using std__unordered_map_std__string__ResolvedReferencedAsset_ = std::unordered_map<std::string, ResolvedReferencedAsset>;
+  inline std::unordered_map<std::string, ResolvedReferencedAsset> create_std__unordered_map_std__string__ResolvedReferencedAsset_(size_t size) noexcept {
+    std::unordered_map<std::string, ResolvedReferencedAsset> map;
+    map.reserve(size);
+    return map;
+  }
+  inline std::vector<std::string> get_std__unordered_map_std__string__ResolvedReferencedAsset__keys(const std__unordered_map_std__string__ResolvedReferencedAsset_& map) noexcept {
+    std::vector<std::string> keys;
+    keys.reserve(map.size());
+    for (const auto& entry : map) {
+      keys.push_back(entry.first);
+    }
+    return keys;
+  }
+  inline ResolvedReferencedAsset get_std__unordered_map_std__string__ResolvedReferencedAsset__value(const std__unordered_map_std__string__ResolvedReferencedAsset_& map, const std::string& key) noexcept {
+    return map.find(key)->second;
+  }
+  inline void emplace_std__unordered_map_std__string__ResolvedReferencedAsset_(std__unordered_map_std__string__ResolvedReferencedAsset_& map, const std::string& key, const ResolvedReferencedAsset& value) noexcept {
+    map.emplace(key, value);
+  }
+  
+  // pragma MARK: std::optional<std::unordered_map<std::string, ResolvedReferencedAsset>>
+  /**
+   * Specialized version of `std::optional<std::unordered_map<std::string, ResolvedReferencedAsset>>`.
+   */
+  using std__optional_std__unordered_map_std__string__ResolvedReferencedAsset__ = std::optional<std::unordered_map<std::string, ResolvedReferencedAsset>>;
+  inline std::optional<std::unordered_map<std::string, ResolvedReferencedAsset>> create_std__optional_std__unordered_map_std__string__ResolvedReferencedAsset__(const std::unordered_map<std::string, ResolvedReferencedAsset>& value) noexcept {
+    return std::optional<std::unordered_map<std::string, ResolvedReferencedAsset>>(value);
+  }
+  inline bool has_value_std__optional_std__unordered_map_std__string__ResolvedReferencedAsset__(const std::optional<std::unordered_map<std::string, ResolvedReferencedAsset>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::unordered_map<std::string, ResolvedReferencedAsset> get_std__optional_std__unordered_map_std__string__ResolvedReferencedAsset__(const std::optional<std::unordered_map<std::string, ResolvedReferencedAsset>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridRiveFileSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridRiveFileSpec>`.
+   */
+  using std__shared_ptr_HybridRiveFileSpec_ = std::shared_ptr<HybridRiveFileSpec>;
+  std::shared_ptr<HybridRiveFileSpec> create_std__shared_ptr_HybridRiveFileSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridRiveFileSpec_(std__shared_ptr_HybridRiveFileSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridRiveFileSpec>
+  using std__weak_ptr_HybridRiveFileSpec_ = std::weak_ptr<HybridRiveFileSpec>;
+  inline std__weak_ptr_HybridRiveFileSpec_ weakify_std__shared_ptr_HybridRiveFileSpec_(const std::shared_ptr<HybridRiveFileSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::optional<std::shared_ptr<HybridViewModelSpec>>>
+  using Result_std__optional_std__shared_ptr_HybridViewModelSpec___ = Result<std::optional<std::shared_ptr<HybridViewModelSpec>>>;
+  inline Result_std__optional_std__shared_ptr_HybridViewModelSpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelSpec___(const std::optional<std::shared_ptr<HybridViewModelSpec>>& value) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelSpec>>>::withValue(value);
+  }
+  inline Result_std__optional_std__shared_ptr_HybridViewModelSpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelSpec___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelSpec>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_HybridRiveFileSpec___ = std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> create_std__shared_ptr_Promise_std__shared_ptr_HybridRiveFileSpec___() noexcept {
+    return Promise<std::shared_ptr<HybridRiveFileSpec>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<HybridRiveFileSpec>> wrap_std__shared_ptr_Promise_std__shared_ptr_HybridRiveFileSpec___(std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<HybridRiveFileSpec>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<HybridRiveFileSpec>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<HybridRiveFileSpec>&)>`.
+   */
+  using Func_void_std__shared_ptr_HybridRiveFileSpec_ = std::function<void(const std::shared_ptr<HybridRiveFileSpec>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<HybridRiveFileSpec>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_HybridRiveFileSpec__Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_HybridRiveFileSpec__Wrapper(std::function<void(const std::shared_ptr<HybridRiveFileSpec>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<HybridRiveFileSpec>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<HybridRiveFileSpec> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<HybridRiveFileSpec>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_HybridRiveFileSpec_ create_Func_void_std__shared_ptr_HybridRiveFileSpec_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_HybridRiveFileSpec__Wrapper wrap_Func_void_std__shared_ptr_HybridRiveFileSpec_(Func_void_std__shared_ptr_HybridRiveFileSpec_ value) noexcept {
+    return Func_void_std__shared_ptr_HybridRiveFileSpec__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
+   */
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__exception_ptr_Wrapper final {
+  public:
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
+    return Func_void_std__exception_ptr_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<ReferencedAssetsType>
+  /**
+   * Specialized version of `std::optional<ReferencedAssetsType>`.
+   */
+  using std__optional_ReferencedAssetsType_ = std::optional<ReferencedAssetsType>;
+  inline std::optional<ReferencedAssetsType> create_std__optional_ReferencedAssetsType_(const ReferencedAssetsType& value) noexcept {
+    return std::optional<ReferencedAssetsType>(value);
+  }
+  inline bool has_value_std__optional_ReferencedAssetsType_(const std::optional<ReferencedAssetsType>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ReferencedAssetsType get_std__optional_ReferencedAssetsType_(const std::optional<ReferencedAssetsType>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridRiveFileFactorySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridRiveFileFactorySpec>`.
+   */
+  using std__shared_ptr_HybridRiveFileFactorySpec_ = std::shared_ptr<HybridRiveFileFactorySpec>;
+  std::shared_ptr<HybridRiveFileFactorySpec> create_std__shared_ptr_HybridRiveFileFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridRiveFileFactorySpec_(std__shared_ptr_HybridRiveFileFactorySpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridRiveFileFactorySpec>
+  using std__weak_ptr_HybridRiveFileFactorySpec_ = std::weak_ptr<HybridRiveFileFactorySpec>;
+  inline std__weak_ptr_HybridRiveFileFactorySpec_ weakify_std__shared_ptr_HybridRiveFileFactorySpec_(const std::shared_ptr<HybridRiveFileFactorySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>>>
+  using Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveFileSpec____ = Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>>>;
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveFileSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveFileSpec____(const std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveFileSpec____ create_Result_std__shared_ptr_Promise_std__shared_ptr_HybridRiveFileSpec____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<HybridRiveFileSpec>>>>::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::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<Alignment>
+  /**
+   * Specialized version of `std::optional<Alignment>`.
+   */
+  using std__optional_Alignment_ = std::optional<Alignment>;
+  inline std::optional<Alignment> create_std__optional_Alignment_(const Alignment& value) noexcept {
+    return std::optional<Alignment>(value);
+  }
+  inline bool has_value_std__optional_Alignment_(const std::optional<Alignment>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Alignment get_std__optional_Alignment_(const std::optional<Alignment>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<Fit>
+  /**
+   * Specialized version of `std::optional<Fit>`.
+   */
+  using std__optional_Fit_ = std::optional<Fit>;
+  inline std::optional<Fit> create_std__optional_Fit_(const Fit& value) noexcept {
+    return std::optional<Fit>(value);
+  }
+  inline bool has_value_std__optional_Fit_(const std::optional<Fit>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Fit get_std__optional_Fit_(const std::optional<Fit>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelInstanceSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridViewModelInstanceSpec>`.
+   */
+  using std__shared_ptr_HybridViewModelInstanceSpec_ = std::shared_ptr<HybridViewModelInstanceSpec>;
+  std::shared_ptr<HybridViewModelInstanceSpec> create_std__shared_ptr_HybridViewModelInstanceSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridViewModelInstanceSpec_(std__shared_ptr_HybridViewModelInstanceSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridViewModelInstanceSpec>
+  using std__weak_ptr_HybridViewModelInstanceSpec_ = std::weak_ptr<HybridViewModelInstanceSpec>;
+  inline std__weak_ptr_HybridViewModelInstanceSpec_ weakify_std__shared_ptr_HybridViewModelInstanceSpec_(const std::shared_ptr<HybridViewModelInstanceSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>
+  /**
+   * Wrapper struct for `std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_ {
+    std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName> variant;
+    std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_(std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName> variant): variant(variant) { }
+    operator std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline std::shared_ptr<HybridViewModelInstanceSpec> get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline DataBindMode get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+    inline DataBindByName get_2() const noexcept {
+      return std::get<2>(variant);
+    }
+  };
+  inline std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_ create_std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_(const std::shared_ptr<HybridViewModelInstanceSpec>& value) noexcept {
+    return std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_(value);
+  }
+  inline std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_ create_std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_(DataBindMode value) noexcept {
+    return std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_(value);
+  }
+  inline std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_ create_std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_(const DataBindByName& value) noexcept {
+    return std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>>
+  /**
+   * Specialized version of `std::optional<std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>>`.
+   */
+  using std__optional_std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName__ = std::optional<std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>>;
+  inline std::optional<std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>> create_std__optional_std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName__(const std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>& value) noexcept {
+    return std::optional<std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName__(const std::optional<std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName> get_std__optional_std__variant_std__shared_ptr_HybridViewModelInstanceSpec___DataBindMode__DataBindByName__(const std::optional<std::variant<std::shared_ptr<HybridViewModelInstanceSpec>, DataBindMode, DataBindByName>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const RiveError& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const RiveError&)>`.
+   */
+  using Func_void_RiveError = std::function<void(const RiveError& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RiveError& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_RiveError_Wrapper final {
+  public:
+    explicit Func_void_RiveError_Wrapper(std::function<void(const RiveError& /* error */)>&& func): _function(std::make_unique<std::function<void(const RiveError& /* error */)>>(std::move(func))) {}
+    inline void call(RiveError error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RiveError& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RiveError create_Func_void_RiveError(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RiveError_Wrapper wrap_Func_void_RiveError(Func_void_RiveError value) noexcept {
+    return Func_void_RiveError_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(bool /* result */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
+    inline void call(bool result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridViewModelInstanceSpec__ = std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>;
+  inline std::optional<std::shared_ptr<HybridViewModelInstanceSpec>> create_std__optional_std__shared_ptr_HybridViewModelInstanceSpec__(const std::shared_ptr<HybridViewModelInstanceSpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelInstanceSpec__(const std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridViewModelInstanceSpec> get_std__optional_std__shared_ptr_HybridViewModelInstanceSpec__(const std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<void>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   */
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
+    return Promise<void>::create();
+  }
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
+    }
+  private:
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::variant<bool, std::string, double>
+  /**
+   * Wrapper struct for `std::variant<bool, std::string, double>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_bool__std__string__double_ {
+    std::variant<bool, std::string, double> variant;
+    std__variant_bool__std__string__double_(std::variant<bool, std::string, double> variant): variant(variant) { }
+    operator std::variant<bool, std::string, double>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline bool get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline std::string get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+    inline double get_2() const noexcept {
+      return std::get<2>(variant);
+    }
+  };
+  inline std__variant_bool__std__string__double_ create_std__variant_bool__std__string__double_(bool value) noexcept {
+    return std__variant_bool__std__string__double_(value);
+  }
+  inline std__variant_bool__std__string__double_ create_std__variant_bool__std__string__double_(const std::string& value) noexcept {
+    return std__variant_bool__std__string__double_(value);
+  }
+  inline std__variant_bool__std__string__double_ create_std__variant_bool__std__string__double_(double value) noexcept {
+    return std__variant_bool__std__string__double_(value);
+  }
+  
+  // pragma MARK: std::unordered_map<std::string, std::variant<bool, std::string, double>>
+  /**
+   * Specialized version of `std::unordered_map<std::string, std::variant<bool, std::string, double>>`.
+   */
+  using std__unordered_map_std__string__std__variant_bool__std__string__double__ = std::unordered_map<std::string, std::variant<bool, std::string, double>>;
+  inline std::unordered_map<std::string, std::variant<bool, std::string, double>> create_std__unordered_map_std__string__std__variant_bool__std__string__double__(size_t size) noexcept {
+    std::unordered_map<std::string, std::variant<bool, std::string, double>> map;
+    map.reserve(size);
+    return map;
+  }
+  inline std::vector<std::string> get_std__unordered_map_std__string__std__variant_bool__std__string__double___keys(const std__unordered_map_std__string__std__variant_bool__std__string__double__& map) noexcept {
+    std::vector<std::string> keys;
+    keys.reserve(map.size());
+    for (const auto& entry : map) {
+      keys.push_back(entry.first);
+    }
+    return keys;
+  }
+  inline std::variant<bool, std::string, double> get_std__unordered_map_std__string__std__variant_bool__std__string__double___value(const std__unordered_map_std__string__std__variant_bool__std__string__double__& map, const std::string& key) noexcept {
+    return map.find(key)->second;
+  }
+  inline void emplace_std__unordered_map_std__string__std__variant_bool__std__string__double__(std__unordered_map_std__string__std__variant_bool__std__string__double__& map, const std::string& key, const std::variant<bool, std::string, double>& value) noexcept {
+    map.emplace(key, value);
+  }
+  
+  // pragma MARK: std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>>
+  /**
+   * Specialized version of `std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>>`.
+   */
+  using std__optional_std__unordered_map_std__string__std__variant_bool__std__string__double___ = std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>>;
+  inline std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>> create_std__optional_std__unordered_map_std__string__std__variant_bool__std__string__double___(const std::unordered_map<std::string, std::variant<bool, std::string, double>>& value) noexcept {
+    return std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>>(value);
+  }
+  inline bool has_value_std__optional_std__unordered_map_std__string__std__variant_bool__std__string__double___(const std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::unordered_map<std::string, std::variant<bool, std::string, double>> get_std__optional_std__unordered_map_std__string__std__variant_bool__std__string__double___(const std::optional<std::unordered_map<std::string, std::variant<bool, std::string, double>>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const UnifiedRiveEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const UnifiedRiveEvent&)>`.
+   */
+  using Func_void_UnifiedRiveEvent = std::function<void(const UnifiedRiveEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const UnifiedRiveEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_UnifiedRiveEvent_Wrapper final {
+  public:
+    explicit Func_void_UnifiedRiveEvent_Wrapper(std::function<void(const UnifiedRiveEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const UnifiedRiveEvent& /* event */)>>(std::move(func))) {}
+    inline void call(UnifiedRiveEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const UnifiedRiveEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_UnifiedRiveEvent create_Func_void_UnifiedRiveEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_UnifiedRiveEvent_Wrapper wrap_Func_void_UnifiedRiveEvent(Func_void_UnifiedRiveEvent value) noexcept {
+    return Func_void_UnifiedRiveEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridRiveViewSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridRiveViewSpec>`.
+   */
+  using std__shared_ptr_HybridRiveViewSpec_ = std::shared_ptr<HybridRiveViewSpec>;
+  std::shared_ptr<HybridRiveViewSpec> create_std__shared_ptr_HybridRiveViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridRiveViewSpec_(std__shared_ptr_HybridRiveViewSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridRiveViewSpec>
+  using std__weak_ptr_HybridRiveViewSpec_ = std::weak_ptr<HybridRiveViewSpec>;
+  inline std__weak_ptr_HybridRiveViewSpec_ weakify_std__shared_ptr_HybridRiveViewSpec_(const std::shared_ptr<HybridRiveViewSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
+  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>
+  using Result_std__optional_std__shared_ptr_HybridViewModelInstanceSpec___ = Result<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>;
+  inline Result_std__optional_std__shared_ptr_HybridViewModelInstanceSpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelInstanceSpec___(const std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>& value) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>::withValue(value);
+  }
+  inline Result_std__optional_std__shared_ptr_HybridViewModelInstanceSpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelInstanceSpec___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<void>>>
+  using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
+    return Result<std::string>::withError(error);
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelPropertySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridViewModelPropertySpec>`.
+   */
+  using std__shared_ptr_HybridViewModelPropertySpec_ = std::shared_ptr<HybridViewModelPropertySpec>;
+  std::shared_ptr<HybridViewModelPropertySpec> create_std__shared_ptr_HybridViewModelPropertySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridViewModelPropertySpec_(std__shared_ptr_HybridViewModelPropertySpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridViewModelPropertySpec>
+  using std__weak_ptr_HybridViewModelPropertySpec_ = std::weak_ptr<HybridViewModelPropertySpec>;
+  inline std__weak_ptr_HybridViewModelPropertySpec_ weakify_std__shared_ptr_HybridViewModelPropertySpec_(const std::shared_ptr<HybridViewModelPropertySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelNumberPropertySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridViewModelNumberPropertySpec>`.
+   */
+  using std__shared_ptr_HybridViewModelNumberPropertySpec_ = std::shared_ptr<HybridViewModelNumberPropertySpec>;
+  std::shared_ptr<HybridViewModelNumberPropertySpec> create_std__shared_ptr_HybridViewModelNumberPropertySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridViewModelNumberPropertySpec_(std__shared_ptr_HybridViewModelNumberPropertySpec_ cppType);
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelPropertySpec>
+  inline std::shared_ptr<HybridViewModelPropertySpec> upcast_ViewModelNumberProperty_to_ViewModelProperty(std::shared_ptr<HybridViewModelNumberPropertySpec> child) noexcept { return child; }
+  
+  // pragma MARK: std::weak_ptr<HybridViewModelNumberPropertySpec>
+  using std__weak_ptr_HybridViewModelNumberPropertySpec_ = std::weak_ptr<HybridViewModelNumberPropertySpec>;
+  inline std__weak_ptr_HybridViewModelNumberPropertySpec_ weakify_std__shared_ptr_HybridViewModelNumberPropertySpec_(const std::shared_ptr<HybridViewModelNumberPropertySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridViewModelNumberPropertySpec__ = std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>;
+  inline std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>> create_std__optional_std__shared_ptr_HybridViewModelNumberPropertySpec__(const std::shared_ptr<HybridViewModelNumberPropertySpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelNumberPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridViewModelNumberPropertySpec> get_std__optional_std__shared_ptr_HybridViewModelNumberPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelStringPropertySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridViewModelStringPropertySpec>`.
+   */
+  using std__shared_ptr_HybridViewModelStringPropertySpec_ = std::shared_ptr<HybridViewModelStringPropertySpec>;
+  std::shared_ptr<HybridViewModelStringPropertySpec> create_std__shared_ptr_HybridViewModelStringPropertySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridViewModelStringPropertySpec_(std__shared_ptr_HybridViewModelStringPropertySpec_ cppType);
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelPropertySpec>
+  inline std::shared_ptr<HybridViewModelPropertySpec> upcast_ViewModelStringProperty_to_ViewModelProperty(std::shared_ptr<HybridViewModelStringPropertySpec> child) noexcept { return child; }
+  
+  // pragma MARK: std::weak_ptr<HybridViewModelStringPropertySpec>
+  using std__weak_ptr_HybridViewModelStringPropertySpec_ = std::weak_ptr<HybridViewModelStringPropertySpec>;
+  inline std__weak_ptr_HybridViewModelStringPropertySpec_ weakify_std__shared_ptr_HybridViewModelStringPropertySpec_(const std::shared_ptr<HybridViewModelStringPropertySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridViewModelStringPropertySpec__ = std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>;
+  inline std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>> create_std__optional_std__shared_ptr_HybridViewModelStringPropertySpec__(const std::shared_ptr<HybridViewModelStringPropertySpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelStringPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridViewModelStringPropertySpec> get_std__optional_std__shared_ptr_HybridViewModelStringPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelBooleanPropertySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridViewModelBooleanPropertySpec>`.
+   */
+  using std__shared_ptr_HybridViewModelBooleanPropertySpec_ = std::shared_ptr<HybridViewModelBooleanPropertySpec>;
+  std::shared_ptr<HybridViewModelBooleanPropertySpec> create_std__shared_ptr_HybridViewModelBooleanPropertySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridViewModelBooleanPropertySpec_(std__shared_ptr_HybridViewModelBooleanPropertySpec_ cppType);
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelPropertySpec>
+  inline std::shared_ptr<HybridViewModelPropertySpec> upcast_ViewModelBooleanProperty_to_ViewModelProperty(std::shared_ptr<HybridViewModelBooleanPropertySpec> child) noexcept { return child; }
+  
+  // pragma MARK: std::weak_ptr<HybridViewModelBooleanPropertySpec>
+  using std__weak_ptr_HybridViewModelBooleanPropertySpec_ = std::weak_ptr<HybridViewModelBooleanPropertySpec>;
+  inline std__weak_ptr_HybridViewModelBooleanPropertySpec_ weakify_std__shared_ptr_HybridViewModelBooleanPropertySpec_(const std::shared_ptr<HybridViewModelBooleanPropertySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridViewModelBooleanPropertySpec__ = std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>;
+  inline std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>> create_std__optional_std__shared_ptr_HybridViewModelBooleanPropertySpec__(const std::shared_ptr<HybridViewModelBooleanPropertySpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelBooleanPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridViewModelBooleanPropertySpec> get_std__optional_std__shared_ptr_HybridViewModelBooleanPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelColorPropertySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridViewModelColorPropertySpec>`.
+   */
+  using std__shared_ptr_HybridViewModelColorPropertySpec_ = std::shared_ptr<HybridViewModelColorPropertySpec>;
+  std::shared_ptr<HybridViewModelColorPropertySpec> create_std__shared_ptr_HybridViewModelColorPropertySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridViewModelColorPropertySpec_(std__shared_ptr_HybridViewModelColorPropertySpec_ cppType);
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelPropertySpec>
+  inline std::shared_ptr<HybridViewModelPropertySpec> upcast_ViewModelColorProperty_to_ViewModelProperty(std::shared_ptr<HybridViewModelColorPropertySpec> child) noexcept { return child; }
+  
+  // pragma MARK: std::weak_ptr<HybridViewModelColorPropertySpec>
+  using std__weak_ptr_HybridViewModelColorPropertySpec_ = std::weak_ptr<HybridViewModelColorPropertySpec>;
+  inline std__weak_ptr_HybridViewModelColorPropertySpec_ weakify_std__shared_ptr_HybridViewModelColorPropertySpec_(const std::shared_ptr<HybridViewModelColorPropertySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridViewModelColorPropertySpec__ = std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>;
+  inline std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>> create_std__optional_std__shared_ptr_HybridViewModelColorPropertySpec__(const std::shared_ptr<HybridViewModelColorPropertySpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelColorPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridViewModelColorPropertySpec> get_std__optional_std__shared_ptr_HybridViewModelColorPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelEnumPropertySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridViewModelEnumPropertySpec>`.
+   */
+  using std__shared_ptr_HybridViewModelEnumPropertySpec_ = std::shared_ptr<HybridViewModelEnumPropertySpec>;
+  std::shared_ptr<HybridViewModelEnumPropertySpec> create_std__shared_ptr_HybridViewModelEnumPropertySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridViewModelEnumPropertySpec_(std__shared_ptr_HybridViewModelEnumPropertySpec_ cppType);
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelPropertySpec>
+  inline std::shared_ptr<HybridViewModelPropertySpec> upcast_ViewModelEnumProperty_to_ViewModelProperty(std::shared_ptr<HybridViewModelEnumPropertySpec> child) noexcept { return child; }
+  
+  // pragma MARK: std::weak_ptr<HybridViewModelEnumPropertySpec>
+  using std__weak_ptr_HybridViewModelEnumPropertySpec_ = std::weak_ptr<HybridViewModelEnumPropertySpec>;
+  inline std__weak_ptr_HybridViewModelEnumPropertySpec_ weakify_std__shared_ptr_HybridViewModelEnumPropertySpec_(const std::shared_ptr<HybridViewModelEnumPropertySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridViewModelEnumPropertySpec__ = std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>;
+  inline std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>> create_std__optional_std__shared_ptr_HybridViewModelEnumPropertySpec__(const std::shared_ptr<HybridViewModelEnumPropertySpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelEnumPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridViewModelEnumPropertySpec> get_std__optional_std__shared_ptr_HybridViewModelEnumPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelTriggerPropertySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridViewModelTriggerPropertySpec>`.
+   */
+  using std__shared_ptr_HybridViewModelTriggerPropertySpec_ = std::shared_ptr<HybridViewModelTriggerPropertySpec>;
+  std::shared_ptr<HybridViewModelTriggerPropertySpec> create_std__shared_ptr_HybridViewModelTriggerPropertySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridViewModelTriggerPropertySpec_(std__shared_ptr_HybridViewModelTriggerPropertySpec_ cppType);
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelPropertySpec>
+  inline std::shared_ptr<HybridViewModelPropertySpec> upcast_ViewModelTriggerProperty_to_ViewModelProperty(std::shared_ptr<HybridViewModelTriggerPropertySpec> child) noexcept { return child; }
+  
+  // pragma MARK: std::weak_ptr<HybridViewModelTriggerPropertySpec>
+  using std__weak_ptr_HybridViewModelTriggerPropertySpec_ = std::weak_ptr<HybridViewModelTriggerPropertySpec>;
+  inline std__weak_ptr_HybridViewModelTriggerPropertySpec_ weakify_std__shared_ptr_HybridViewModelTriggerPropertySpec_(const std::shared_ptr<HybridViewModelTriggerPropertySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridViewModelTriggerPropertySpec__ = std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>;
+  inline std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>> create_std__optional_std__shared_ptr_HybridViewModelTriggerPropertySpec__(const std::shared_ptr<HybridViewModelTriggerPropertySpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelTriggerPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridViewModelTriggerPropertySpec> get_std__optional_std__shared_ptr_HybridViewModelTriggerPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelImagePropertySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridViewModelImagePropertySpec>`.
+   */
+  using std__shared_ptr_HybridViewModelImagePropertySpec_ = std::shared_ptr<HybridViewModelImagePropertySpec>;
+  std::shared_ptr<HybridViewModelImagePropertySpec> create_std__shared_ptr_HybridViewModelImagePropertySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridViewModelImagePropertySpec_(std__shared_ptr_HybridViewModelImagePropertySpec_ cppType);
+  
+  // pragma MARK: std::shared_ptr<HybridViewModelPropertySpec>
+  inline std::shared_ptr<HybridViewModelPropertySpec> upcast_ViewModelImageProperty_to_ViewModelProperty(std::shared_ptr<HybridViewModelImagePropertySpec> child) noexcept { return child; }
+  
+  // pragma MARK: std::weak_ptr<HybridViewModelImagePropertySpec>
+  using std__weak_ptr_HybridViewModelImagePropertySpec_ = std::weak_ptr<HybridViewModelImagePropertySpec>;
+  inline std__weak_ptr_HybridViewModelImagePropertySpec_ weakify_std__shared_ptr_HybridViewModelImagePropertySpec_(const std::shared_ptr<HybridViewModelImagePropertySpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridViewModelImagePropertySpec__ = std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>;
+  inline std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>> create_std__optional_std__shared_ptr_HybridViewModelImagePropertySpec__(const std::shared_ptr<HybridViewModelImagePropertySpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelImagePropertySpec__(const std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridViewModelImagePropertySpec> get_std__optional_std__shared_ptr_HybridViewModelImagePropertySpec__(const std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: Result<std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>>
+  using Result_std__optional_std__shared_ptr_HybridViewModelNumberPropertySpec___ = Result<std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>>;
+  inline Result_std__optional_std__shared_ptr_HybridViewModelNumberPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelNumberPropertySpec___(const std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>& value) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>>::withValue(value);
+  }
+  inline Result_std__optional_std__shared_ptr_HybridViewModelNumberPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelNumberPropertySpec___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelNumberPropertySpec>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>>
+  using Result_std__optional_std__shared_ptr_HybridViewModelStringPropertySpec___ = Result<std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>>;
+  inline Result_std__optional_std__shared_ptr_HybridViewModelStringPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelStringPropertySpec___(const std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>& value) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>>::withValue(value);
+  }
+  inline Result_std__optional_std__shared_ptr_HybridViewModelStringPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelStringPropertySpec___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelStringPropertySpec>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>>
+  using Result_std__optional_std__shared_ptr_HybridViewModelBooleanPropertySpec___ = Result<std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>>;
+  inline Result_std__optional_std__shared_ptr_HybridViewModelBooleanPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelBooleanPropertySpec___(const std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>& value) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>>::withValue(value);
+  }
+  inline Result_std__optional_std__shared_ptr_HybridViewModelBooleanPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelBooleanPropertySpec___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelBooleanPropertySpec>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>>
+  using Result_std__optional_std__shared_ptr_HybridViewModelColorPropertySpec___ = Result<std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>>;
+  inline Result_std__optional_std__shared_ptr_HybridViewModelColorPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelColorPropertySpec___(const std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>& value) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>>::withValue(value);
+  }
+  inline Result_std__optional_std__shared_ptr_HybridViewModelColorPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelColorPropertySpec___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelColorPropertySpec>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>>
+  using Result_std__optional_std__shared_ptr_HybridViewModelEnumPropertySpec___ = Result<std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>>;
+  inline Result_std__optional_std__shared_ptr_HybridViewModelEnumPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelEnumPropertySpec___(const std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>& value) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>>::withValue(value);
+  }
+  inline Result_std__optional_std__shared_ptr_HybridViewModelEnumPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelEnumPropertySpec___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelEnumPropertySpec>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>>
+  using Result_std__optional_std__shared_ptr_HybridViewModelTriggerPropertySpec___ = Result<std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>>;
+  inline Result_std__optional_std__shared_ptr_HybridViewModelTriggerPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelTriggerPropertySpec___(const std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>& value) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>>::withValue(value);
+  }
+  inline Result_std__optional_std__shared_ptr_HybridViewModelTriggerPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelTriggerPropertySpec___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelTriggerPropertySpec>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>>
+  using Result_std__optional_std__shared_ptr_HybridViewModelImagePropertySpec___ = Result<std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>>;
+  inline Result_std__optional_std__shared_ptr_HybridViewModelImagePropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelImagePropertySpec___(const std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>& value) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>>::withValue(value);
+  }
+  inline Result_std__optional_std__shared_ptr_HybridViewModelImagePropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelImagePropertySpec___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::shared_ptr<HybridViewModelImagePropertySpec>>>::withError(error);
+  }
+  
+  // pragma MARK: std::function<void(double /* value */)>
+  /**
+   * Specialized version of `std::function<void(double)>`.
+   */
+  using Func_void_double = std::function<void(double /* value */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * value * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_Wrapper final {
+  public:
+    explicit Func_void_double_Wrapper(std::function<void(double /* value */)>&& func): _function(std::make_unique<std::function<void(double /* value */)>>(std::move(func))) {}
+    inline void call(double value) const noexcept {
+      _function->operator()(value);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* value */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) noexcept {
+    return Func_void_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* value */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* value */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * value * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_Wrapper final {
+  public:
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* value */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* value */)>>(std::move(func))) {}
+    inline void call(std::string value) const noexcept {
+      _function->operator()(value);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* value */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
+    return Func_void_std__string_Wrapper(std::move(value));
+  }
+
+} // namespace margelo::nitro::rive::bridge::swift