///
/// RNRive-Swift-Cxx-Bridge.hpp
/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
/// https://github.com/mrousavy/nitro
/// Copyright © 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 `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 `HybridRiveViewSpec` to properly resolve imports.
namespace margelo::nitro::rive { class HybridRiveViewSpec; }
// Forward declaration of `HybridViewModelArtboardPropertySpec` to properly resolve imports.
namespace margelo::nitro::rive { class HybridViewModelArtboardPropertySpec; }
// 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 `HybridViewModelListPropertySpec` to properly resolve imports.
namespace margelo::nitro::rive { class HybridViewModelListPropertySpec; }
// 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 `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 `HybridRiveViewSpec_cxx` to properly resolve imports.
namespace RNRive { class HybridRiveViewSpec_cxx; }
// Forward declaration of `HybridViewModelArtboardPropertySpec_cxx` to properly resolve imports.
namespace RNRive { class HybridViewModelArtboardPropertySpec_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 `HybridViewModelListPropertySpec_cxx` to properly resolve imports.
namespace RNRive { class HybridViewModelListPropertySpec_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 "HybridBindableArtboardSpec.hpp"
#include "HybridFallbackFontSpec.hpp"
#include "HybridRiveFileFactorySpec.hpp"
#include "HybridRiveFileSpec.hpp"
#include "HybridRiveFontConfigSpec.hpp"
#include "HybridRiveImageFactorySpec.hpp"
#include "HybridRiveImageSpec.hpp"
#include "HybridRiveRuntimeSpec.hpp"
#include "HybridRiveViewSpec.hpp"
#include "HybridViewModelArtboardPropertySpec.hpp"
#include "HybridViewModelBooleanPropertySpec.hpp"
#include "HybridViewModelColorPropertySpec.hpp"
#include "HybridViewModelEnumPropertySpec.hpp"
#include "HybridViewModelImagePropertySpec.hpp"
#include "HybridViewModelInstanceSpec.hpp"
#include "HybridViewModelListPropertySpec.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>
#include <vector>

/**
 * 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<HybridBindableArtboardSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridBindableArtboardSpec>`.
   */
  using std__shared_ptr_HybridBindableArtboardSpec_ = std::shared_ptr<HybridBindableArtboardSpec>;
  std::shared_ptr<HybridBindableArtboardSpec> create_std__shared_ptr_HybridBindableArtboardSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridBindableArtboardSpec_(std__shared_ptr_HybridBindableArtboardSpec_ cppType);
  
  // pragma MARK: std::weak_ptr<HybridBindableArtboardSpec>
  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::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.value();
  }
  
  // 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.value();
  }
  
  // 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.value();
  }
  
  // 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.value();
  }
  
  // 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.value();
  }
  
  // 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.value();
  }
  
  // pragma MARK: std::vector<std::string>
  /**
   * Specialized version of `std::vector<std::string>`.
   */
  using std__vector_std__string_ = std::vector<std::string>;
  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
    std::vector<std::string> vector;
    vector.reserve(size);
    return vector;
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::vector<std::string>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::vector<std::string>>>`.
   */
  using std__shared_ptr_Promise_std__vector_std__string___ = std::shared_ptr<Promise<std::vector<std::string>>>;
  inline std::shared_ptr<Promise<std::vector<std::string>>> create_std__shared_ptr_Promise_std__vector_std__string___() noexcept {
    return Promise<std::vector<std::string>>::create();
  }
  inline PromiseHolder<std::vector<std::string>> wrap_std__shared_ptr_Promise_std__vector_std__string___(std::shared_ptr<Promise<std::vector<std::string>>> promise) noexcept {
    return PromiseHolder<std::vector<std::string>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::vector<std::string>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::vector<std::string>&)>`.
   */
  using Func_void_std__vector_std__string_ = std::function<void(const std::vector<std::string>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::vector<std::string>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__vector_std__string__Wrapper final {
  public:
    explicit Func_void_std__vector_std__string__Wrapper(std::function<void(const std::vector<std::string>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<std::string>& /* result */)>>(std::move(func))) {}
    inline void call(std::vector<std::string> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::vector<std::string>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__vector_std__string_ create_Func_void_std__vector_std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__vector_std__string__Wrapper wrap_Func_void_std__vector_std__string_(Func_void_std__vector_std__string_ value) noexcept {
    return Func_void_std__vector_std__string__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::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>>`.
   */
  using std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelSpec____ = std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>>;
  inline std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>> create_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelSpec____() noexcept {
    return Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>::create();
  }
  inline PromiseHolder<std::optional<std::shared_ptr<HybridViewModelSpec>>> wrap_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelSpec____(std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>> promise) noexcept {
    return PromiseHolder<std::optional<std::shared_ptr<HybridViewModelSpec>>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::optional<std::shared_ptr<HybridViewModelSpec>>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::optional<std::shared_ptr<HybridViewModelSpec>>&)>`.
   */
  using Func_void_std__optional_std__shared_ptr_HybridViewModelSpec__ = std::function<void(const std::optional<std::shared_ptr<HybridViewModelSpec>>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::optional<std::shared_ptr<HybridViewModelSpec>>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__optional_std__shared_ptr_HybridViewModelSpec___Wrapper final {
  public:
    explicit Func_void_std__optional_std__shared_ptr_HybridViewModelSpec___Wrapper(std::function<void(const std::optional<std::shared_ptr<HybridViewModelSpec>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::shared_ptr<HybridViewModelSpec>>& /* result */)>>(std::move(func))) {}
    inline void call(std::optional<std::shared_ptr<HybridViewModelSpec>> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::optional<std::shared_ptr<HybridViewModelSpec>>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__optional_std__shared_ptr_HybridViewModelSpec__ create_Func_void_std__optional_std__shared_ptr_HybridViewModelSpec__(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__optional_std__shared_ptr_HybridViewModelSpec___Wrapper wrap_Func_void_std__optional_std__shared_ptr_HybridViewModelSpec__(Func_void_std__optional_std__shared_ptr_HybridViewModelSpec__ value) noexcept {
    return Func_void_std__optional_std__shared_ptr_HybridViewModelSpec___Wrapper(std::move(value));
  }
  
  // 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.value();
  }
  
  // pragma MARK: std::shared_ptr<Promise<double>>
  /**
   * Specialized version of `std::shared_ptr<Promise<double>>`.
   */
  using std__shared_ptr_Promise_double__ = std::shared_ptr<Promise<double>>;
  inline std::shared_ptr<Promise<double>> create_std__shared_ptr_Promise_double__() noexcept {
    return Promise<double>::create();
  }
  inline PromiseHolder<double> wrap_std__shared_ptr_Promise_double__(std::shared_ptr<Promise<double>> promise) noexcept {
    return PromiseHolder<double>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(double /* result */)>
  /**
   * Specialized version of `std::function<void(double)>`.
   */
  using Func_void_double = std::function<void(double /* result */)>;
  /**
   * Wrapper class for a `std::function<void(double / * result * /)>`, this can be used from Swift.
   */
  class Func_void_double_Wrapper final {
  public:
    explicit Func_void_double_Wrapper(std::function<void(double /* result */)>&& func): _function(std::make_unique<std::function<void(double /* result */)>>(std::move(func))) {}
    inline void call(double result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(double /* result */)>> _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::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: Result<std::shared_ptr<Promise<std::vector<std::string>>>>
  using Result_std__shared_ptr_Promise_std__vector_std__string____ = Result<std::shared_ptr<Promise<std::vector<std::string>>>>;
  inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::shared_ptr<Promise<std::vector<std::string>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<std::string>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::vector<std::string>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>>>
  using Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelSpec_____ = Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>>>;
  inline Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelSpec_____ create_Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelSpec_____(const std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelSpec_____ create_Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelSpec_____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelSpec>>>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<double>>>
  using Result_std__shared_ptr_Promise_double___ = Result<std::shared_ptr<Promise<double>>>;
  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::shared_ptr<Promise<double>>& value) noexcept {
    return Result<std::shared_ptr<Promise<double>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<double>>>::withError(error);
  }
  
  // pragma MARK: Result<std::shared_ptr<HybridBindableArtboardSpec>>
  using Result_std__shared_ptr_HybridBindableArtboardSpec__ = Result<std::shared_ptr<HybridBindableArtboardSpec>>;
  inline Result_std__shared_ptr_HybridBindableArtboardSpec__ create_Result_std__shared_ptr_HybridBindableArtboardSpec__(const std::shared_ptr<HybridBindableArtboardSpec>& value) noexcept {
    return Result<std::shared_ptr<HybridBindableArtboardSpec>>::withValue(value);
  }
  inline Result_std__shared_ptr_HybridBindableArtboardSpec__ create_Result_std__shared_ptr_HybridBindableArtboardSpec__(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<HybridBindableArtboardSpec>>::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::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.value();
  }
  
  // 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<HybridFallbackFontSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridFallbackFontSpec>`.
   */
  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<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<HybridFallbackFontSpec>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::shared_ptr<HybridFallbackFontSpec>&)>`.
   */
  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<HybridFallbackFontSpec>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__shared_ptr_HybridFallbackFontSpec__Wrapper final {
  public:
    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<HybridFallbackFontSpec>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  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::vector<std::shared_ptr<HybridFallbackFontSpec>>
  /**
   * Specialized version of `std::vector<std::shared_ptr<HybridFallbackFontSpec>>`.
   */
  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>>
  /**
   * 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::shared_ptr<HybridRiveFontConfigSpec>
  /**
   * Specialized version of `std::shared_ptr<HybridRiveFontConfigSpec>`.
   */
  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<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>>>;
  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: 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<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.value();
  }
  
  // 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.value();
  }
  
  // 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_ final {
    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.value();
  }
  
  // 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.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_ final {
    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.value();
  }
  
  // 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<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 {
    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<Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>>`.
   */
  using std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelInstanceSpec____ = std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>>;
  inline std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>> create_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelInstanceSpec____() noexcept {
    return Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>::create();
  }
  inline PromiseHolder<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>> wrap_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelInstanceSpec____(std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>> promise) noexcept {
    return PromiseHolder<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>&)>`.
   */
  using Func_void_std__optional_std__shared_ptr_HybridViewModelInstanceSpec__ = std::function<void(const std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>& / * result * /)>`, this can be used from Swift.
   */
  class Func_void_std__optional_std__shared_ptr_HybridViewModelInstanceSpec___Wrapper final {
  public:
    explicit Func_void_std__optional_std__shared_ptr_HybridViewModelInstanceSpec___Wrapper(std::function<void(const std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>& /* result */)>>(std::move(func))) {}
    inline void call(std::optional<std::shared_ptr<HybridViewModelInstanceSpec>> result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>& /* result */)>> _function;
  } SWIFT_NONCOPYABLE;
  Func_void_std__optional_std__shared_ptr_HybridViewModelInstanceSpec__ create_Func_void_std__optional_std__shared_ptr_HybridViewModelInstanceSpec__(void* NON_NULL swiftClosureWrapper) noexcept;
  inline Func_void_std__optional_std__shared_ptr_HybridViewModelInstanceSpec___Wrapper wrap_Func_void_std__optional_std__shared_ptr_HybridViewModelInstanceSpec__(Func_void_std__optional_std__shared_ptr_HybridViewModelInstanceSpec__ value) noexcept {
    return Func_void_std__optional_std__shared_ptr_HybridViewModelInstanceSpec___Wrapper(std::move(value));
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>>>
  using Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelInstanceSpec_____ = Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>>>;
  inline Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelInstanceSpec_____ create_Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelInstanceSpec_____(const std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelInstanceSpec_____ create_Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridViewModelInstanceSpec_____(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridViewModelInstanceSpec>>>>>::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.value();
  }
  
  // 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.value();
  }
  
  // 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.value();
  }
  
  // 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.value();
  }
  
  // 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.value();
  }
  
  // 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.value();
  }
  
  // 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.value();
  }
  
  // pragma MARK: std::shared_ptr<HybridViewModelListPropertySpec>
  /**
   * Specialized version of `std::shared_ptr<HybridViewModelListPropertySpec>`.
   */
  using std__shared_ptr_HybridViewModelListPropertySpec_ = std::shared_ptr<HybridViewModelListPropertySpec>;
  std::shared_ptr<HybridViewModelListPropertySpec> create_std__shared_ptr_HybridViewModelListPropertySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridViewModelListPropertySpec_(std__shared_ptr_HybridViewModelListPropertySpec_ cppType);
  
  // pragma MARK: std::shared_ptr<HybridViewModelPropertySpec>
  inline std::shared_ptr<HybridViewModelPropertySpec> upcast_ViewModelListProperty_to_ViewModelProperty(std::shared_ptr<HybridViewModelListPropertySpec> child) noexcept { return child; }
  
  // pragma MARK: std::weak_ptr<HybridViewModelListPropertySpec>
  using std__weak_ptr_HybridViewModelListPropertySpec_ = std::weak_ptr<HybridViewModelListPropertySpec>;
  inline std__weak_ptr_HybridViewModelListPropertySpec_ weakify_std__shared_ptr_HybridViewModelListPropertySpec_(const std::shared_ptr<HybridViewModelListPropertySpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>
  /**
   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>`.
   */
  using std__optional_std__shared_ptr_HybridViewModelListPropertySpec__ = std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>;
  inline std::optional<std::shared_ptr<HybridViewModelListPropertySpec>> create_std__optional_std__shared_ptr_HybridViewModelListPropertySpec__(const std::shared_ptr<HybridViewModelListPropertySpec>& value) noexcept {
    return std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>(value);
  }
  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelListPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::shared_ptr<HybridViewModelListPropertySpec> get_std__optional_std__shared_ptr_HybridViewModelListPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>& optional) noexcept {
    return optional.value();
  }
  
  // pragma MARK: std::shared_ptr<HybridViewModelArtboardPropertySpec>
  /**
   * Specialized version of `std::shared_ptr<HybridViewModelArtboardPropertySpec>`.
   */
  using std__shared_ptr_HybridViewModelArtboardPropertySpec_ = std::shared_ptr<HybridViewModelArtboardPropertySpec>;
  std::shared_ptr<HybridViewModelArtboardPropertySpec> create_std__shared_ptr_HybridViewModelArtboardPropertySpec_(void* NON_NULL swiftUnsafePointer) noexcept;
  void* NON_NULL get_std__shared_ptr_HybridViewModelArtboardPropertySpec_(std__shared_ptr_HybridViewModelArtboardPropertySpec_ cppType);
  
  // pragma MARK: std::shared_ptr<HybridViewModelPropertySpec>
  inline std::shared_ptr<HybridViewModelPropertySpec> upcast_ViewModelArtboardProperty_to_ViewModelProperty(std::shared_ptr<HybridViewModelArtboardPropertySpec> child) noexcept { return child; }
  
  // pragma MARK: std::weak_ptr<HybridViewModelArtboardPropertySpec>
  using std__weak_ptr_HybridViewModelArtboardPropertySpec_ = std::weak_ptr<HybridViewModelArtboardPropertySpec>;
  inline std__weak_ptr_HybridViewModelArtboardPropertySpec_ weakify_std__shared_ptr_HybridViewModelArtboardPropertySpec_(const std::shared_ptr<HybridViewModelArtboardPropertySpec>& strong) noexcept { return strong; }
  
  // pragma MARK: std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>
  /**
   * Specialized version of `std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>`.
   */
  using std__optional_std__shared_ptr_HybridViewModelArtboardPropertySpec__ = std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>;
  inline std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>> create_std__optional_std__shared_ptr_HybridViewModelArtboardPropertySpec__(const std::shared_ptr<HybridViewModelArtboardPropertySpec>& value) noexcept {
    return std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>(value);
  }
  inline bool has_value_std__optional_std__shared_ptr_HybridViewModelArtboardPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::shared_ptr<HybridViewModelArtboardPropertySpec> get_std__optional_std__shared_ptr_HybridViewModelArtboardPropertySpec__(const std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>& optional) noexcept {
    return optional.value();
  }
  
  // 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: Result<std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>>
  using Result_std__optional_std__shared_ptr_HybridViewModelListPropertySpec___ = Result<std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>>;
  inline Result_std__optional_std__shared_ptr_HybridViewModelListPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelListPropertySpec___(const std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>& value) noexcept {
    return Result<std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>>::withValue(value);
  }
  inline Result_std__optional_std__shared_ptr_HybridViewModelListPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelListPropertySpec___(const std::exception_ptr& error) noexcept {
    return Result<std::optional<std::shared_ptr<HybridViewModelListPropertySpec>>>::withError(error);
  }
  
  // pragma MARK: Result<std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>>
  using Result_std__optional_std__shared_ptr_HybridViewModelArtboardPropertySpec___ = Result<std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>>;
  inline Result_std__optional_std__shared_ptr_HybridViewModelArtboardPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelArtboardPropertySpec___(const std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>& value) noexcept {
    return Result<std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>>::withValue(value);
  }
  inline Result_std__optional_std__shared_ptr_HybridViewModelArtboardPropertySpec___ create_Result_std__optional_std__shared_ptr_HybridViewModelArtboardPropertySpec___(const std::exception_ptr& error) noexcept {
    return Result<std::optional<std::shared_ptr<HybridViewModelArtboardPropertySpec>>>::withError(error);
  }
  
  // pragma MARK: Result<std::function<void()>>
  using Result_std__function_void____ = Result<std::function<void()>>;
  inline Result_std__function_void____ create_Result_std__function_void____(const std::function<void()>& value) noexcept {
    return Result<std::function<void()>>::withValue(value);
  }
  inline Result_std__function_void____ create_Result_std__function_void____(const std::exception_ptr& error) noexcept {
    return Result<std::function<void()>>::withError(error);
  }
  
  // pragma MARK: std::shared_ptr<Promise<std::string>>
  /**
   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
   */
  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() noexcept {
    return Promise<std::string>::create();
  }
  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) noexcept {
    return PromiseHolder<std::string>(std::move(promise));
  }
  
  // pragma MARK: std::function<void(const std::string& /* result */)>
  /**
   * Specialized version of `std::function<void(const std::string&)>`.
   */
  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
  /**
   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, 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& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
    inline void call(std::string result) const noexcept {
      _function->operator()(result);
    }
  private:
    std::unique_ptr<std::function<void(const std::string& /* result */)>> _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));
  }
  
  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) noexcept {
    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
  }
  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
  }
  
  // pragma MARK: std::optional<std::shared_ptr<HybridBindableArtboardSpec>>
  /**
   * Specialized version of `std::optional<std::shared_ptr<HybridBindableArtboardSpec>>`.
   */
  using std__optional_std__shared_ptr_HybridBindableArtboardSpec__ = std::optional<std::shared_ptr<HybridBindableArtboardSpec>>;
  inline std::optional<std::shared_ptr<HybridBindableArtboardSpec>> create_std__optional_std__shared_ptr_HybridBindableArtboardSpec__(const std::shared_ptr<HybridBindableArtboardSpec>& value) noexcept {
    return std::optional<std::shared_ptr<HybridBindableArtboardSpec>>(value);
  }
  inline bool has_value_std__optional_std__shared_ptr_HybridBindableArtboardSpec__(const std::optional<std::shared_ptr<HybridBindableArtboardSpec>>& optional) noexcept {
    return optional.has_value();
  }
  inline std::shared_ptr<HybridBindableArtboardSpec> get_std__optional_std__shared_ptr_HybridBindableArtboardSpec__(const std::optional<std::shared_ptr<HybridBindableArtboardSpec>>& optional) noexcept {
    return optional.value();
  }

} // namespace margelo::nitro::rive::bridge::swift