@iternio/react-native-auto-play 0.5.14-beta.1 → 0.6.1

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

@@ -97,6 +97,30 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class Maneuve
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig; }
 // Forward declaration of `ManeuverState` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ManeuverState; }
+// Forward declaration of `NitroOptionsPanelConfig` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroOptionsPanelConfig; }
+// Forward declaration of `NitroSection` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroSection; }
+// Forward declaration of `NitroOptionsPanelGridSection` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroOptionsPanelGridSection; }
+// Forward declaration of `NitroOptionsPanelChargerSection` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroOptionsPanelChargerSection; }
+// Forward declaration of `NitroRow` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroRow; }
+// Forward declaration of `ListImageType` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ListImageType; }
+// Forward declaration of `WaypointCoordinate` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct WaypointCoordinate; }
+// Forward declaration of `NitroSectionType` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroSectionType; }
+// Forward declaration of `NitroGridButton` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroGridButton; }
+// Forward declaration of `NitroChargerOutlet` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroChargerOutlet; }
+// Forward declaration of `ChargingConnector` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ChargingConnector; }
+// Forward declaration of `NitroChargerLocation` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroChargerLocation; }
 
 #include "TripSelectorCallback.hpp"
 #include "JTripSelectorCallback.hpp"
@@ -211,6 +235,31 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class Maneuve
 #include "JTripConfig.hpp"
 #include "ManeuverState.hpp"
 #include "JManeuverState.hpp"
+#include "NitroOptionsPanelConfig.hpp"
+#include "JNitroOptionsPanelConfig.hpp"
+#include "NitroSection.hpp"
+#include "NitroOptionsPanelGridSection.hpp"
+#include "NitroOptionsPanelChargerSection.hpp"
+#include "JNitroOptionsPanelSection.hpp"
+#include "JNitroSection.hpp"
+#include "NitroRow.hpp"
+#include "JNitroRow.hpp"
+#include "ListImageType.hpp"
+#include "JListImageType.hpp"
+#include "WaypointCoordinate.hpp"
+#include "JWaypointCoordinate.hpp"
+#include "NitroSectionType.hpp"
+#include "JNitroSectionType.hpp"
+#include "JNitroOptionsPanelGridSection.hpp"
+#include "NitroGridButton.hpp"
+#include "JNitroGridButton.hpp"
+#include "JNitroOptionsPanelChargerSection.hpp"
+#include "NitroChargerOutlet.hpp"
+#include "JNitroChargerOutlet.hpp"
+#include "ChargingConnector.hpp"
+#include "JChargingConnector.hpp"
+#include "NitroChargerLocation.hpp"
+#include "JNitroChargerLocation.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -333,9 +382,20 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<JNitroManeuver> /* maneuvers */)>("updateManeuvers");
     method(_javaPart, jni::make_jstring(templateId), JNitroManeuver::fromCpp(maneuvers));
   }
-  void JHybridMapTemplateSpec::startNavigation(const std::string& templateId, const TripConfig& trip) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<JTripConfig> /* trip */)>("startNavigation");
-    method(_javaPart, jni::make_jstring(templateId), JTripConfig::fromCpp(trip));
+  std::shared_ptr<Promise<void>> JHybridMapTemplateSpec::startNavigation(const std::string& templateId, const TripConfig& trip) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<JTripConfig> /* trip */)>("startNavigation");
+    auto __result = method(_javaPart, jni::make_jstring(templateId), JTripConfig::fromCpp(trip));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
   void JHybridMapTemplateSpec::stopNavigation(const std::string& templateId) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* templateId */)>("stopNavigation");
@@ -345,5 +405,20 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<JManeuverState> /* state */)>("setManeuverState");
     method(_javaPart, jni::make_jstring(templateId), JManeuverState::fromCpp(state));
   }
+  std::shared_ptr<Promise<void>> JHybridMapTemplateSpec::updateOptionsPanel(const std::string& templateId, const std::optional<NitroOptionsPanelConfig>& config) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<JNitroOptionsPanelConfig> /* config */)>("updateOptionsPanel");
+    auto __result = method(_javaPart, jni::make_jstring(templateId), config.has_value() ? JNitroOptionsPanelConfig::fromCpp(config.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -64,9 +64,10 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     void updateVisibleTravelEstimate(const std::string& templateId, VisibleTravelEstimate visibleTravelEstimate) override;
     void updateTravelEstimates(const std::string& templateId, const std::vector<TripPoint>& steps) override;
     void updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>& maneuvers) override;
-    void startNavigation(const std::string& templateId, const TripConfig& trip) override;
+    std::shared_ptr<Promise<void>> startNavigation(const std::string& templateId, const TripConfig& trip) override;
     void stopNavigation(const std::string& templateId) override;
     void setManeuverState(const std::string& templateId, ManeuverState state) override;
+    std::shared_ptr<Promise<void>> updateOptionsPanel(const std::string& templateId, const std::optional<NitroOptionsPanelConfig>& config) override;
 
   private:
     jni::global_ref<JHybridMapTemplateSpec::JavaPart> _javaPart;

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

@@ -35,6 +35,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class Distanc
 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 `ListImageType` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ListImageType; }
+// Forward declaration of `WaypointCoordinate` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct WaypointCoordinate; }
+// Forward declaration of `DurationWithTimeZone` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct DurationWithTimeZone; }
 // Forward declaration of `NitroSectionType` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroSectionType; }
 
@@ -78,6 +84,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroSe
 #include "JNitroSection.hpp"
 #include "NitroRow.hpp"
 #include "JNitroRow.hpp"
+#include "ListImageType.hpp"
+#include "JListImageType.hpp"
+#include "WaypointCoordinate.hpp"
+#include "JWaypointCoordinate.hpp"
+#include "DurationWithTimeZone.hpp"
+#include "JDurationWithTimeZone.hpp"
 #include "NitroSectionType.hpp"
 #include "JNitroSectionType.hpp"
 #include "JFunc_void_std__string.hpp"

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

@@ -14,15 +14,18 @@
 #include "AutoText.hpp"
 #include "Distance.hpp"
 #include "DistanceUnits.hpp"
+#include "DurationWithTimeZone.hpp"
 #include "GlyphImage.hpp"
 #include "JAssetImage.hpp"
 #include "JAutoText.hpp"
 #include "JDistance.hpp"
 #include "JDistanceUnits.hpp"
+#include "JDurationWithTimeZone.hpp"
 #include "JFunc_void.hpp"
 #include "JFunc_void_bool.hpp"
 #include "JFunc_void_std__optional_bool_.hpp"
 #include "JGlyphImage.hpp"
+#include "JListImageType.hpp"
 #include "JNitroAction.hpp"
 #include "JNitroActionType.hpp"
 #include "JNitroAlignment.hpp"
@@ -37,6 +40,8 @@
 #include "JNitroSectionType.hpp"
 #include "JRemoteImage.hpp"
 #include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
+#include "JWaypointCoordinate.hpp"
+#include "ListImageType.hpp"
 #include "NitroAction.hpp"
 #include "NitroActionType.hpp"
 #include "NitroAlignment.hpp"
@@ -49,6 +54,7 @@
 #include "NitroSection.hpp"
 #include "NitroSectionType.hpp"
 #include "RemoteImage.hpp"
+#include "WaypointCoordinate.hpp"
 #include <NitroModules/JNICallable.hpp>
 #include <functional>
 #include <optional>

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

@@ -0,0 +1,67 @@
+///
+/// JListImageType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ListImageType.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ListImageType" and the the Kotlin enum "ListImageType".
+   */
+  struct JListImageType final: public jni::JavaClass<JListImageType> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/ListImageType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ListImageType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ListImageType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ListImageType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JListImageType> fromCpp(ListImageType value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case ListImageType::LARGE:
+          static const auto fieldLARGE = clazz->getStaticField<JListImageType>("LARGE");
+          return clazz->getStaticFieldValue(fieldLARGE);
+        case ListImageType::MEDIUM:
+          static const auto fieldMEDIUM = clazz->getStaticField<JListImageType>("MEDIUM");
+          return clazz->getStaticFieldValue(fieldMEDIUM);
+        case ListImageType::SMALL:
+          static const auto fieldSMALL = clazz->getStaticField<JListImageType>("SMALL");
+          return clazz->getStaticFieldValue(fieldSMALL);
+        case ListImageType::EXTRA_SMALL:
+          static const auto fieldEXTRA_SMALL = clazz->getStaticField<JListImageType>("EXTRA_SMALL");
+          return clazz->getStaticFieldValue(fieldEXTRA_SMALL);
+        case ListImageType::ICON:
+          static const auto fieldICON = clazz->getStaticField<JListImageType>("ICON");
+          return clazz->getStaticFieldValue(fieldICON);
+        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++/JListTemplateConfig.hpp

@@ -14,15 +14,18 @@
 #include "AutoText.hpp"
 #include "Distance.hpp"
 #include "DistanceUnits.hpp"
+#include "DurationWithTimeZone.hpp"
 #include "GlyphImage.hpp"
 #include "JAssetImage.hpp"
 #include "JAutoText.hpp"
 #include "JDistance.hpp"
 #include "JDistanceUnits.hpp"
+#include "JDurationWithTimeZone.hpp"
 #include "JFunc_void.hpp"
 #include "JFunc_void_bool.hpp"
 #include "JFunc_void_std__optional_bool_.hpp"
 #include "JGlyphImage.hpp"
+#include "JListImageType.hpp"
 #include "JNitroAction.hpp"
 #include "JNitroActionType.hpp"
 #include "JNitroAlignment.hpp"
@@ -37,6 +40,8 @@
 #include "JNitroSectionType.hpp"
 #include "JRemoteImage.hpp"
 #include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
+#include "JWaypointCoordinate.hpp"
+#include "ListImageType.hpp"
 #include "NitroAction.hpp"
 #include "NitroActionType.hpp"
 #include "NitroAlignment.hpp"
@@ -49,6 +54,7 @@
 #include "NitroSection.hpp"
 #include "NitroSectionType.hpp"
 #include "RemoteImage.hpp"
+#include "WaypointCoordinate.hpp"
 #include <NitroModules/JNICallable.hpp>
 #include <functional>
 #include <optional>

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

@@ -0,0 +1,115 @@
+///
+/// JNitroChargerLocation.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "NitroChargerLocation.hpp"
+
+#include "AssetImage.hpp"
+#include "Distance.hpp"
+#include "DistanceUnits.hpp"
+#include "DurationWithTimeZone.hpp"
+#include "GlyphImage.hpp"
+#include "JAssetImage.hpp"
+#include "JDistance.hpp"
+#include "JDistanceUnits.hpp"
+#include "JDurationWithTimeZone.hpp"
+#include "JFunc_void.hpp"
+#include "JGlyphImage.hpp"
+#include "JNitroColor.hpp"
+#include "JRemoteImage.hpp"
+#include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
+#include "JWaypointCoordinate.hpp"
+#include "NitroColor.hpp"
+#include "RemoteImage.hpp"
+#include "WaypointCoordinate.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <functional>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "NitroChargerLocation" and the the Kotlin data class "NitroChargerLocation".
+   */
+  struct JNitroChargerLocation final: public jni::JavaClass<JNitroChargerLocation> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/NitroChargerLocation;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NitroChargerLocation by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NitroChargerLocation toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldAddress = clazz->getField<jni::JString>("address");
+      jni::local_ref<jni::JString> address = this->getFieldValue(fieldAddress);
+      static const auto fieldCoordinate = clazz->getField<JWaypointCoordinate>("coordinate");
+      jni::local_ref<JWaypointCoordinate> coordinate = this->getFieldValue(fieldCoordinate);
+      static const auto fieldDistance = clazz->getField<JDistance>("distance");
+      jni::local_ref<JDistance> distance = this->getFieldValue(fieldDistance);
+      static const auto fieldDuration = clazz->getField<JDurationWithTimeZone>("duration");
+      jni::local_ref<JDurationWithTimeZone> duration = this->getFieldValue(fieldDuration);
+      static const auto fieldVisible = clazz->getField<jni::JBoolean>("visible");
+      jni::local_ref<jni::JBoolean> visible = this->getFieldValue(fieldVisible);
+      static const auto fieldImage = clazz->getField<JVariant_GlyphImage_AssetImage_RemoteImage>("image");
+      jni::local_ref<JVariant_GlyphImage_AssetImage_RemoteImage> image = this->getFieldValue(fieldImage);
+      static const auto fieldOnPress = clazz->getField<JFunc_void::javaobject>("onPress");
+      jni::local_ref<JFunc_void::javaobject> onPress = this->getFieldValue(fieldOnPress);
+      return NitroChargerLocation(
+        name != nullptr ? std::make_optional(name->toStdString()) : std::nullopt,
+        address != nullptr ? std::make_optional(address->toStdString()) : std::nullopt,
+        coordinate->toCpp(),
+        distance->toCpp(),
+        duration->toCpp(),
+        visible != nullptr ? std::make_optional(static_cast<bool>(visible->value())) : std::nullopt,
+        image != nullptr ? std::make_optional(image->toCpp()) : std::nullopt,
+        onPress != nullptr ? std::make_optional([&]() -> std::function<void()> {
+          if (onPress->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(onPress);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onPressRef = jni::make_global(onPress);
+            return JNICallable<JFunc_void, void()>(std::move(onPressRef));
+          }
+        }()) : 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<JNitroChargerLocation::javaobject> fromCpp(const NitroChargerLocation& value) {
+      using JSignature = JNitroChargerLocation(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JWaypointCoordinate>, jni::alias_ref<JDistance>, jni::alias_ref<JDurationWithTimeZone>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JVariant_GlyphImage_AssetImage_RemoteImage>, jni::alias_ref<JFunc_void::javaobject>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.name.has_value() ? jni::make_jstring(value.name.value()) : nullptr,
+        value.address.has_value() ? jni::make_jstring(value.address.value()) : nullptr,
+        JWaypointCoordinate::fromCpp(value.coordinate),
+        JDistance::fromCpp(value.distance),
+        JDurationWithTimeZone::fromCpp(value.duration),
+        value.visible.has_value() ? jni::JBoolean::valueOf(value.visible.value()) : nullptr,
+        value.image.has_value() ? JVariant_GlyphImage_AssetImage_RemoteImage::fromCpp(value.image.value()) : nullptr,
+        value.onPress.has_value() ? JFunc_void_cxx::fromCpp(value.onPress.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -0,0 +1,82 @@
+///
+/// JNitroChargerOutlet.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "NitroChargerOutlet.hpp"
+
+#include "ChargingConnector.hpp"
+#include "JChargingConnector.hpp"
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <functional>
+#include <optional>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "NitroChargerOutlet" and the the Kotlin data class "NitroChargerOutlet".
+   */
+  struct JNitroChargerOutlet final: public jni::JavaClass<JNitroChargerOutlet> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/NitroChargerOutlet;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NitroChargerOutlet by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NitroChargerOutlet toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldConnector = clazz->getField<JChargingConnector>("connector");
+      jni::local_ref<JChargingConnector> connector = this->getFieldValue(fieldConnector);
+      static const auto fieldVoltage = clazz->getField<double>("voltage");
+      double voltage = this->getFieldValue(fieldVoltage);
+      static const auto fieldPowerKw = clazz->getField<double>("powerKw");
+      double powerKw = this->getFieldValue(fieldPowerKw);
+      static const auto fieldOnPress = clazz->getField<JFunc_void::javaobject>("onPress");
+      jni::local_ref<JFunc_void::javaobject> onPress = this->getFieldValue(fieldOnPress);
+      return NitroChargerOutlet(
+        connector->toCpp(),
+        voltage,
+        powerKw,
+        onPress != nullptr ? std::make_optional([&]() -> std::function<void()> {
+          if (onPress->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(onPress);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onPressRef = jni::make_global(onPress);
+            return JNICallable<JFunc_void, void()>(std::move(onPressRef));
+          }
+        }()) : 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<JNitroChargerOutlet::javaobject> fromCpp(const NitroChargerOutlet& value) {
+      using JSignature = JNitroChargerOutlet(jni::alias_ref<JChargingConnector>, double, double, jni::alias_ref<JFunc_void::javaobject>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JChargingConnector::fromCpp(value.connector),
+        value.voltage,
+        value.powerKw,
+        value.onPress.has_value() ? JFunc_void_cxx::fromCpp(value.onPress.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -10,7 +10,7 @@
 #include <fbjni/fbjni.h>
 #include "NitroColor.hpp"
 
-
+#include <optional>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -35,9 +35,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       double lightColor = this->getFieldValue(fieldLightColor);
       static const auto fieldDarkColor = clazz->getField<double>("darkColor");
       double darkColor = this->getFieldValue(fieldDarkColor);
+      static const auto fieldIsDefault = clazz->getField<jni::JBoolean>("isDefault");
+      jni::local_ref<jni::JBoolean> isDefault = this->getFieldValue(fieldIsDefault);
       return NitroColor(
         lightColor,
-        darkColor
+        darkColor,
+        isDefault != nullptr ? std::make_optional(static_cast<bool>(isDefault->value())) : std::nullopt
       );
     }
 
@@ -47,13 +50,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
      */
     [[maybe_unused]]
     static jni::local_ref<JNitroColor::javaobject> fromCpp(const NitroColor& value) {
-      using JSignature = JNitroColor(double, double);
+      using JSignature = JNitroColor(double, double, jni::alias_ref<jni::JBoolean>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         value.lightColor,
-        value.darkColor
+        value.darkColor,
+        value.isDefault.has_value() ? jni::JBoolean::valueOf(value.isDefault.value()) : nullptr
       );
     }
   };

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

@@ -0,0 +1,112 @@
+///
+/// JNitroOptionsPanelChargerSection.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "NitroOptionsPanelChargerSection.hpp"
+
+#include "AssetImage.hpp"
+#include "ChargingConnector.hpp"
+#include "Distance.hpp"
+#include "DistanceUnits.hpp"
+#include "DurationWithTimeZone.hpp"
+#include "GlyphImage.hpp"
+#include "JAssetImage.hpp"
+#include "JChargingConnector.hpp"
+#include "JDistance.hpp"
+#include "JDistanceUnits.hpp"
+#include "JDurationWithTimeZone.hpp"
+#include "JFunc_void.hpp"
+#include "JGlyphImage.hpp"
+#include "JNitroChargerLocation.hpp"
+#include "JNitroChargerOutlet.hpp"
+#include "JNitroColor.hpp"
+#include "JRemoteImage.hpp"
+#include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
+#include "JWaypointCoordinate.hpp"
+#include "NitroChargerLocation.hpp"
+#include "NitroChargerOutlet.hpp"
+#include "NitroColor.hpp"
+#include "RemoteImage.hpp"
+#include "WaypointCoordinate.hpp"
+#include <NitroModules/JNICallable.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 "NitroOptionsPanelChargerSection" and the the Kotlin data class "NitroOptionsPanelChargerSection".
+   */
+  struct JNitroOptionsPanelChargerSection final: public jni::JavaClass<JNitroOptionsPanelChargerSection> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/NitroOptionsPanelChargerSection;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NitroOptionsPanelChargerSection by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NitroOptionsPanelChargerSection toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTitle = clazz->getField<jni::JString>("title");
+      jni::local_ref<jni::JString> title = this->getFieldValue(fieldTitle);
+      static const auto fieldOutlets = clazz->getField<jni::JArrayClass<JNitroChargerOutlet>>("outlets");
+      jni::local_ref<jni::JArrayClass<JNitroChargerOutlet>> outlets = this->getFieldValue(fieldOutlets);
+      static const auto fieldLocation = clazz->getField<JNitroChargerLocation>("location");
+      jni::local_ref<JNitroChargerLocation> location = this->getFieldValue(fieldLocation);
+      return NitroOptionsPanelChargerSection(
+        title != nullptr ? std::make_optional(title->toStdString()) : std::nullopt,
+        [&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<NitroChargerOutlet> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(outlets),
+        location != nullptr ? std::make_optional(location->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<JNitroOptionsPanelChargerSection::javaobject> fromCpp(const NitroOptionsPanelChargerSection& value) {
+      using JSignature = JNitroOptionsPanelChargerSection(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JArrayClass<JNitroChargerOutlet>>, jni::alias_ref<JNitroChargerLocation>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.title.has_value() ? jni::make_jstring(value.title.value()) : nullptr,
+        [&](auto&& __input) {
+          size_t __size = __input.size();
+          jni::local_ref<jni::JArrayClass<JNitroChargerOutlet>> __array = jni::JArrayClass<JNitroChargerOutlet>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = __input[__i];
+            auto __elementJni = JNitroChargerOutlet::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(value.outlets),
+        value.location.has_value() ? JNitroChargerLocation::fromCpp(value.location.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay