@iternio/react-native-auto-play 0.0.1

package/nitrogen/generated/android/c++/JHybridSearchTemplateSpec.cpp

@@ -0,0 +1,118 @@
+///
+/// JHybridSearchTemplateSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridSearchTemplateSpec.hpp"
+
+// Forward declaration of `SearchTemplateConfig` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct SearchTemplateConfig; }
+// Forward declaration of `NitroAction` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAction; }
+// Forward declaration of `GlyphImage` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct GlyphImage; }
+// Forward declaration of `AssetImage` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct AssetImage; }
+// Forward declaration of `NitroColor` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor; }
+// Forward declaration of `NitroActionType` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroActionType; }
+// Forward declaration of `NitroAlignment` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroAlignment; }
+// Forward declaration of `NitroButtonStyle` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroButtonStyle; }
+// Forward declaration of `AutoText` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct AutoText; }
+// Forward declaration of `Distance` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct Distance; }
+// Forward declaration of `DistanceUnits` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class DistanceUnits; }
+// Forward declaration of `NitroSection` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroSection; }
+// Forward declaration of `NitroRow` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroRow; }
+// Forward declaration of `NitroSectionType` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroSectionType; }
+
+#include "SearchTemplateConfig.hpp"
+#include "JSearchTemplateConfig.hpp"
+#include <string>
+#include <optional>
+#include <functional>
+#include "JFunc_void_std__optional_bool_.hpp"
+#include "JFunc_void.hpp"
+#include "NitroAction.hpp"
+#include <vector>
+#include "JNitroAction.hpp"
+#include "GlyphImage.hpp"
+#include "AssetImage.hpp"
+#include <variant>
+#include "JVariant_GlyphImage_AssetImage.hpp"
+#include "JGlyphImage.hpp"
+#include "NitroColor.hpp"
+#include "JNitroColor.hpp"
+#include "JAssetImage.hpp"
+#include "NitroActionType.hpp"
+#include "JNitroActionType.hpp"
+#include "NitroAlignment.hpp"
+#include "JNitroAlignment.hpp"
+#include "NitroButtonStyle.hpp"
+#include "JNitroButtonStyle.hpp"
+#include "AutoText.hpp"
+#include "JAutoText.hpp"
+#include "Distance.hpp"
+#include "JDistance.hpp"
+#include "DistanceUnits.hpp"
+#include "JDistanceUnits.hpp"
+#include "NitroSection.hpp"
+#include "JNitroSection.hpp"
+#include "NitroRow.hpp"
+#include "JNitroRow.hpp"
+#include "NitroSectionType.hpp"
+#include "JNitroSectionType.hpp"
+#include "JFunc_void_std__string.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  jni::local_ref<JHybridSearchTemplateSpec::jhybriddata> JHybridSearchTemplateSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridSearchTemplateSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridSearchTemplateSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridSearchTemplateSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridSearchTemplateSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridSearchTemplateSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridSearchTemplateSpec::createSearchTemplate(const SearchTemplateConfig& config) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JSearchTemplateConfig> /* config */)>("createSearchTemplate");
+    method(_javaPart, JSearchTemplateConfig::fromCpp(config));
+  }
+  void JHybridSearchTemplateSpec::updateSearchResults(const std::string& templateId, const NitroSection& results) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<JNitroSection> /* results */)>("updateSearchResults");
+    method(_javaPart, jni::make_jstring(templateId), JNitroSection::fromCpp(results));
+  }
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/c++/JHybridSearchTemplateSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridSearchTemplateSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridSearchTemplateSpec.hpp"
+
+
+
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  class JHybridSearchTemplateSpec: public jni::HybridClass<JHybridSearchTemplateSpec, JHybridObject>,
+                                   public virtual HybridSearchTemplateSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridSearchTemplateSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridSearchTemplateSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridSearchTemplateSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridSearchTemplateSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridSearchTemplateSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void createSearchTemplate(const SearchTemplateConfig& config) override;
+    void updateSearchResults(const std::string& templateId, const NitroSection& results) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridSearchTemplateSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/c++/JImageLane.hpp

@@ -0,0 +1,81 @@
+///
+/// JImageLane.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ImageLane.hpp"
+
+#include "AssetImage.hpp"
+#include "GlyphImage.hpp"
+#include "JAssetImage.hpp"
+#include "JGlyphImage.hpp"
+#include "JNitroColor.hpp"
+#include "JNitroImage.hpp"
+#include "NitroColor.hpp"
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ImageLane" and the the Kotlin data class "ImageLane".
+   */
+  struct JImageLane final: public jni::JavaClass<JImageLane> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/ImageLane;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ImageLane by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ImageLane toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldImage = clazz->getField<JNitroImage>("image");
+      jni::local_ref<JNitroImage> image = this->getFieldValue(fieldImage);
+      static const auto fieldAngles = clazz->getField<jni::JArrayDouble>("angles");
+      jni::local_ref<jni::JArrayDouble> angles = this->getFieldValue(fieldAngles);
+      return ImageLane(
+        image->toCpp(),
+        [&]() {
+          size_t __size = angles->size();
+          std::vector<double> __vector(__size);
+          angles->getRegion(0, __size, __vector.data());
+          return __vector;
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JImageLane::javaobject> fromCpp(const ImageLane& value) {
+      using JSignature = JImageLane(jni::alias_ref<JNitroImage>, jni::alias_ref<jni::JArrayDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JNitroImage::fromCpp(value.image),
+        [&]() {
+          size_t __size = value.angles.size();
+          jni::local_ref<jni::JArrayDouble> __array = jni::JArrayDouble::newArray(__size);
+          __array->setRegion(0, __size, value.angles.data());
+          return __array;
+        }()
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/c++/JInformationTemplateConfig.hpp

@@ -0,0 +1,226 @@
+///
+/// JInformationTemplateConfig.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "InformationTemplateConfig.hpp"
+
+#include "AssetImage.hpp"
+#include "AutoText.hpp"
+#include "Distance.hpp"
+#include "DistanceUnits.hpp"
+#include "GlyphImage.hpp"
+#include "JAssetImage.hpp"
+#include "JAutoText.hpp"
+#include "JDistance.hpp"
+#include "JDistanceUnits.hpp"
+#include "JFunc_void.hpp"
+#include "JFunc_void_std__optional_bool_.hpp"
+#include "JGlyphImage.hpp"
+#include "JNitroAction.hpp"
+#include "JNitroActionType.hpp"
+#include "JNitroAlignment.hpp"
+#include "JNitroBaseMapTemplateConfig.hpp"
+#include "JNitroButtonStyle.hpp"
+#include "JNitroColor.hpp"
+#include "JNitroMapButton.hpp"
+#include "JNitroMapButtonType.hpp"
+#include "JNitroRow.hpp"
+#include "JNitroSection.hpp"
+#include "JNitroSectionType.hpp"
+#include "JVariant_GlyphImage_AssetImage.hpp"
+#include "NitroAction.hpp"
+#include "NitroActionType.hpp"
+#include "NitroAlignment.hpp"
+#include "NitroBaseMapTemplateConfig.hpp"
+#include "NitroButtonStyle.hpp"
+#include "NitroColor.hpp"
+#include "NitroMapButton.hpp"
+#include "NitroMapButtonType.hpp"
+#include "NitroRow.hpp"
+#include "NitroSection.hpp"
+#include "NitroSectionType.hpp"
+#include <functional>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "InformationTemplateConfig" and the the Kotlin data class "InformationTemplateConfig".
+   */
+  struct JInformationTemplateConfig final: public jni::JavaClass<JInformationTemplateConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/InformationTemplateConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct InformationTemplateConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    InformationTemplateConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldId = clazz->getField<jni::JString>("id");
+      jni::local_ref<jni::JString> id = this->getFieldValue(fieldId);
+      static const auto fieldOnWillAppear = clazz->getField<JFunc_void_std__optional_bool_::javaobject>("onWillAppear");
+      jni::local_ref<JFunc_void_std__optional_bool_::javaobject> onWillAppear = this->getFieldValue(fieldOnWillAppear);
+      static const auto fieldOnWillDisappear = clazz->getField<JFunc_void_std__optional_bool_::javaobject>("onWillDisappear");
+      jni::local_ref<JFunc_void_std__optional_bool_::javaobject> onWillDisappear = this->getFieldValue(fieldOnWillDisappear);
+      static const auto fieldOnDidAppear = clazz->getField<JFunc_void_std__optional_bool_::javaobject>("onDidAppear");
+      jni::local_ref<JFunc_void_std__optional_bool_::javaobject> onDidAppear = this->getFieldValue(fieldOnDidAppear);
+      static const auto fieldOnDidDisappear = clazz->getField<JFunc_void_std__optional_bool_::javaobject>("onDidDisappear");
+      jni::local_ref<JFunc_void_std__optional_bool_::javaobject> onDidDisappear = this->getFieldValue(fieldOnDidDisappear);
+      static const auto fieldOnPopped = clazz->getField<JFunc_void::javaobject>("onPopped");
+      jni::local_ref<JFunc_void::javaobject> onPopped = this->getFieldValue(fieldOnPopped);
+      static const auto fieldAutoDismissMs = clazz->getField<jni::JDouble>("autoDismissMs");
+      jni::local_ref<jni::JDouble> autoDismissMs = this->getFieldValue(fieldAutoDismissMs);
+      static const auto fieldHeaderActions = clazz->getField<jni::JArrayClass<JNitroAction>>("headerActions");
+      jni::local_ref<jni::JArrayClass<JNitroAction>> headerActions = this->getFieldValue(fieldHeaderActions);
+      static const auto fieldTitle = clazz->getField<JAutoText>("title");
+      jni::local_ref<JAutoText> title = this->getFieldValue(fieldTitle);
+      static const auto fieldSection = clazz->getField<JNitroSection>("section");
+      jni::local_ref<JNitroSection> section = this->getFieldValue(fieldSection);
+      static const auto fieldActions = clazz->getField<jni::JArrayClass<JNitroAction>>("actions");
+      jni::local_ref<jni::JArrayClass<JNitroAction>> actions = this->getFieldValue(fieldActions);
+      static const auto fieldMapConfig = clazz->getField<JNitroBaseMapTemplateConfig>("mapConfig");
+      jni::local_ref<JNitroBaseMapTemplateConfig> mapConfig = this->getFieldValue(fieldMapConfig);
+      return InformationTemplateConfig(
+        id->toStdString(),
+        onWillAppear != nullptr ? std::make_optional([&]() -> std::function<void(std::optional<bool> /* animated */)> {
+          if (onWillAppear->isInstanceOf(JFunc_void_std__optional_bool__cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_std__optional_bool__cxx::javaobject>(onWillAppear);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onWillAppearRef = jni::make_global(onWillAppear);
+            return [onWillAppearRef](std::optional<bool> animated) -> void {
+              return onWillAppearRef->invoke(animated);
+            };
+          }
+        }()) : std::nullopt,
+        onWillDisappear != nullptr ? std::make_optional([&]() -> std::function<void(std::optional<bool> /* animated */)> {
+          if (onWillDisappear->isInstanceOf(JFunc_void_std__optional_bool__cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_std__optional_bool__cxx::javaobject>(onWillDisappear);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onWillDisappearRef = jni::make_global(onWillDisappear);
+            return [onWillDisappearRef](std::optional<bool> animated) -> void {
+              return onWillDisappearRef->invoke(animated);
+            };
+          }
+        }()) : std::nullopt,
+        onDidAppear != nullptr ? std::make_optional([&]() -> std::function<void(std::optional<bool> /* animated */)> {
+          if (onDidAppear->isInstanceOf(JFunc_void_std__optional_bool__cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_std__optional_bool__cxx::javaobject>(onDidAppear);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onDidAppearRef = jni::make_global(onDidAppear);
+            return [onDidAppearRef](std::optional<bool> animated) -> void {
+              return onDidAppearRef->invoke(animated);
+            };
+          }
+        }()) : std::nullopt,
+        onDidDisappear != nullptr ? std::make_optional([&]() -> std::function<void(std::optional<bool> /* animated */)> {
+          if (onDidDisappear->isInstanceOf(JFunc_void_std__optional_bool__cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_std__optional_bool__cxx::javaobject>(onDidDisappear);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onDidDisappearRef = jni::make_global(onDidDisappear);
+            return [onDidDisappearRef](std::optional<bool> animated) -> void {
+              return onDidDisappearRef->invoke(animated);
+            };
+          }
+        }()) : std::nullopt,
+        onPopped != nullptr ? std::make_optional([&]() -> std::function<void()> {
+          if (onPopped->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(onPopped);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onPoppedRef = jni::make_global(onPopped);
+            return [onPoppedRef]() -> void {
+              return onPoppedRef->invoke();
+            };
+          }
+        }()) : std::nullopt,
+        autoDismissMs != nullptr ? std::make_optional(autoDismissMs->value()) : std::nullopt,
+        headerActions != nullptr ? std::make_optional([&]() {
+          size_t __size = headerActions->size();
+          std::vector<NitroAction> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = headerActions->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }()) : std::nullopt,
+        title->toCpp(),
+        section->toCpp(),
+        actions != nullptr ? std::make_optional([&]() {
+          size_t __size = actions->size();
+          std::vector<NitroAction> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = actions->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }()) : std::nullopt,
+        mapConfig != nullptr ? std::make_optional(mapConfig->toCpp()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JInformationTemplateConfig::javaobject> fromCpp(const InformationTemplateConfig& value) {
+      using JSignature = JInformationTemplateConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JArrayClass<JNitroAction>>, jni::alias_ref<JAutoText>, jni::alias_ref<JNitroSection>, jni::alias_ref<jni::JArrayClass<JNitroAction>>, jni::alias_ref<JNitroBaseMapTemplateConfig>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.id),
+        value.onWillAppear.has_value() ? JFunc_void_std__optional_bool__cxx::fromCpp(value.onWillAppear.value()) : nullptr,
+        value.onWillDisappear.has_value() ? JFunc_void_std__optional_bool__cxx::fromCpp(value.onWillDisappear.value()) : nullptr,
+        value.onDidAppear.has_value() ? JFunc_void_std__optional_bool__cxx::fromCpp(value.onDidAppear.value()) : nullptr,
+        value.onDidDisappear.has_value() ? JFunc_void_std__optional_bool__cxx::fromCpp(value.onDidDisappear.value()) : nullptr,
+        value.onPopped.has_value() ? JFunc_void_cxx::fromCpp(value.onPopped.value()) : nullptr,
+        value.autoDismissMs.has_value() ? jni::JDouble::valueOf(value.autoDismissMs.value()) : nullptr,
+        value.headerActions.has_value() ? [&]() {
+          size_t __size = value.headerActions.value().size();
+          jni::local_ref<jni::JArrayClass<JNitroAction>> __array = jni::JArrayClass<JNitroAction>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.headerActions.value()[__i];
+            auto __elementJni = JNitroAction::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }() : nullptr,
+        JAutoText::fromCpp(value.title),
+        JNitroSection::fromCpp(value.section),
+        value.actions.has_value() ? [&]() {
+          size_t __size = value.actions.value().size();
+          jni::local_ref<jni::JArrayClass<JNitroAction>> __array = jni::JArrayClass<JNitroAction>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.actions.value()[__i];
+            auto __elementJni = JNitroAction::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }() : nullptr,
+        value.mapConfig.has_value() ? JNitroBaseMapTemplateConfig::fromCpp(value.mapConfig.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/c++/JKeepType.hpp

@@ -0,0 +1,62 @@
+///
+/// JKeepType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "KeepType.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "KeepType" and the the Kotlin enum "KeepType".
+   */
+  struct JKeepType final: public jni::JavaClass<JKeepType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/KeepType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum KeepType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    KeepType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<KeepType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JKeepType> fromCpp(KeepType value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLEFT = clazz->getStaticField<JKeepType>("LEFT");
+      static const auto fieldRIGHT = clazz->getStaticField<JKeepType>("RIGHT");
+      static const auto fieldFOLLOWROAD = clazz->getStaticField<JKeepType>("FOLLOWROAD");
+      
+      switch (value) {
+        case KeepType::LEFT:
+          return clazz->getStaticFieldValue(fieldLEFT);
+        case KeepType::RIGHT:
+          return clazz->getStaticFieldValue(fieldRIGHT);
+        case KeepType::FOLLOWROAD:
+          return clazz->getStaticFieldValue(fieldFOLLOWROAD);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/c++/JLaneGuidance.hpp

@@ -0,0 +1,112 @@
+///
+/// JLaneGuidance.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "LaneGuidance.hpp"
+
+#include "AssetImage.hpp"
+#include "GlyphImage.hpp"
+#include "ImageLane.hpp"
+#include "JAssetImage.hpp"
+#include "JGlyphImage.hpp"
+#include "JImageLane.hpp"
+#include "JNitroColor.hpp"
+#include "JNitroImage.hpp"
+#include "JPreferredImageLane.hpp"
+#include "JVariant_PreferredImageLane_ImageLane.hpp"
+#include "NitroColor.hpp"
+#include "PreferredImageLane.hpp"
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LaneGuidance" and the the Kotlin data class "LaneGuidance".
+   */
+  struct JLaneGuidance final: public jni::JavaClass<JLaneGuidance> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/LaneGuidance;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LaneGuidance by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LaneGuidance toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldInstructionVariants = clazz->getField<jni::JArrayClass<jni::JString>>("instructionVariants");
+      jni::local_ref<jni::JArrayClass<jni::JString>> instructionVariants = this->getFieldValue(fieldInstructionVariants);
+      static const auto fieldLanes = clazz->getField<jni::JArrayClass<JVariant_PreferredImageLane_ImageLane>>("lanes");
+      jni::local_ref<jni::JArrayClass<JVariant_PreferredImageLane_ImageLane>> lanes = this->getFieldValue(fieldLanes);
+      return LaneGuidance(
+        [&]() {
+          size_t __size = instructionVariants->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = instructionVariants->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }(),
+        [&]() {
+          size_t __size = lanes->size();
+          std::vector<std::variant<PreferredImageLane, ImageLane>> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = lanes->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JLaneGuidance::javaobject> fromCpp(const LaneGuidance& value) {
+      using JSignature = JLaneGuidance(jni::alias_ref<jni::JArrayClass<jni::JString>>, jni::alias_ref<jni::JArrayClass<JVariant_PreferredImageLane_ImageLane>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        [&]() {
+          size_t __size = value.instructionVariants.size();
+          jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.instructionVariants[__i];
+            auto __elementJni = jni::make_jstring(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(),
+        [&]() {
+          size_t __size = value.lanes.size();
+          jni::local_ref<jni::JArrayClass<JVariant_PreferredImageLane_ImageLane>> __array = jni::JArrayClass<JVariant_PreferredImageLane_ImageLane>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.lanes[__i];
+            auto __elementJni = JVariant_PreferredImageLane_ImageLane::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }()
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay