react-native-nitro-player 0.0.1

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

@@ -0,0 +1,87 @@
+///
+/// JPlayerState.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PlayerState.hpp"
+
+#include "JTrackItem.hpp"
+#include "JTrackPlayerState.hpp"
+#include "JVariant_NullType_String.hpp"
+#include "JVariant_NullType_TrackItem.hpp"
+#include "TrackItem.hpp"
+#include "TrackPlayerState.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PlayerState" and the the Kotlin data class "PlayerState".
+   */
+  struct JPlayerState final: public jni::JavaClass<JPlayerState> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/PlayerState;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PlayerState by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PlayerState toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCurrentTrack = clazz->getField<JVariant_NullType_TrackItem>("currentTrack");
+      jni::local_ref<JVariant_NullType_TrackItem> currentTrack = this->getFieldValue(fieldCurrentTrack);
+      static const auto fieldCurrentPosition = clazz->getField<double>("currentPosition");
+      double currentPosition = this->getFieldValue(fieldCurrentPosition);
+      static const auto fieldTotalDuration = clazz->getField<double>("totalDuration");
+      double totalDuration = this->getFieldValue(fieldTotalDuration);
+      static const auto fieldCurrentState = clazz->getField<JTrackPlayerState>("currentState");
+      jni::local_ref<JTrackPlayerState> currentState = this->getFieldValue(fieldCurrentState);
+      static const auto fieldCurrentPlaylistId = clazz->getField<JVariant_NullType_String>("currentPlaylistId");
+      jni::local_ref<JVariant_NullType_String> currentPlaylistId = this->getFieldValue(fieldCurrentPlaylistId);
+      static const auto fieldCurrentIndex = clazz->getField<double>("currentIndex");
+      double currentIndex = this->getFieldValue(fieldCurrentIndex);
+      return PlayerState(
+        currentTrack != nullptr ? std::make_optional(currentTrack->toCpp()) : std::nullopt,
+        currentPosition,
+        totalDuration,
+        currentState->toCpp(),
+        currentPlaylistId != nullptr ? std::make_optional(currentPlaylistId->toCpp()) : std::nullopt,
+        currentIndex
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPlayerState::javaobject> fromCpp(const PlayerState& value) {
+      using JSignature = JPlayerState(jni::alias_ref<JVariant_NullType_TrackItem>, double, double, jni::alias_ref<JTrackPlayerState>, jni::alias_ref<JVariant_NullType_String>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.currentTrack.has_value() ? JVariant_NullType_TrackItem::fromCpp(value.currentTrack.value()) : nullptr,
+        value.currentPosition,
+        value.totalDuration,
+        JTrackPlayerState::fromCpp(value.currentState),
+        value.currentPlaylistId.has_value() ? JVariant_NullType_String::fromCpp(value.currentPlaylistId.value()) : nullptr,
+        value.currentIndex
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,99 @@
+///
+/// JPlaylist.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Playlist.hpp"
+
+#include "JTrackItem.hpp"
+#include "JVariant_NullType_String.hpp"
+#include "TrackItem.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Playlist" and the the Kotlin data class "Playlist".
+   */
+  struct JPlaylist final: public jni::JavaClass<JPlaylist> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Playlist;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Playlist by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Playlist 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 fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldDescription = clazz->getField<JVariant_NullType_String>("description");
+      jni::local_ref<JVariant_NullType_String> description = this->getFieldValue(fieldDescription);
+      static const auto fieldArtwork = clazz->getField<JVariant_NullType_String>("artwork");
+      jni::local_ref<JVariant_NullType_String> artwork = this->getFieldValue(fieldArtwork);
+      static const auto fieldTracks = clazz->getField<jni::JArrayClass<JTrackItem>>("tracks");
+      jni::local_ref<jni::JArrayClass<JTrackItem>> tracks = this->getFieldValue(fieldTracks);
+      return Playlist(
+        id->toStdString(),
+        name->toStdString(),
+        description != nullptr ? std::make_optional(description->toCpp()) : std::nullopt,
+        artwork != nullptr ? std::make_optional(artwork->toCpp()) : std::nullopt,
+        [&]() {
+          size_t __size = tracks->size();
+          std::vector<TrackItem> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = tracks->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<JPlaylist::javaobject> fromCpp(const Playlist& value) {
+      using JSignature = JPlaylist(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JVariant_NullType_String>, jni::alias_ref<JVariant_NullType_String>, jni::alias_ref<jni::JArrayClass<JTrackItem>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.id),
+        jni::make_jstring(value.name),
+        value.description.has_value() ? JVariant_NullType_String::fromCpp(value.description.value()) : nullptr,
+        value.artwork.has_value() ? JVariant_NullType_String::fromCpp(value.artwork.value()) : nullptr,
+        [&]() {
+          size_t __size = value.tracks.size();
+          jni::local_ref<jni::JArrayClass<JTrackItem>> __array = jni::JArrayClass<JTrackItem>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.tracks[__i];
+            auto __elementJni = JTrackItem::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }()
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

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

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

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

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

@@ -0,0 +1,69 @@
+///
+/// JTAudioDevice.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "TAudioDevice.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "TAudioDevice" and the the Kotlin data class "TAudioDevice".
+   */
+  struct JTAudioDevice final: public jni::JavaClass<JTAudioDevice> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/TAudioDevice;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct TAudioDevice by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    TAudioDevice toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldId = clazz->getField<double>("id");
+      double id = this->getFieldValue(fieldId);
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldType = clazz->getField<double>("type");
+      double type = this->getFieldValue(fieldType);
+      static const auto fieldIsActive = clazz->getField<jboolean>("isActive");
+      jboolean isActive = this->getFieldValue(fieldIsActive);
+      return TAudioDevice(
+        id,
+        name->toStdString(),
+        type,
+        static_cast<bool>(isActive)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JTAudioDevice::javaobject> fromCpp(const TAudioDevice& value) {
+      using JSignature = JTAudioDevice(double, jni::alias_ref<jni::JString>, double, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.id,
+        jni::make_jstring(value.name),
+        value.type,
+        value.isActive
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,86 @@
+///
+/// JTrackItem.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "TrackItem.hpp"
+
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "TrackItem" and the the Kotlin data class "TrackItem".
+   */
+  struct JTrackItem final: public jni::JavaClass<JTrackItem> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/TrackItem;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct TrackItem by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    TrackItem 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 fieldTitle = clazz->getField<jni::JString>("title");
+      jni::local_ref<jni::JString> title = this->getFieldValue(fieldTitle);
+      static const auto fieldArtist = clazz->getField<jni::JString>("artist");
+      jni::local_ref<jni::JString> artist = this->getFieldValue(fieldArtist);
+      static const auto fieldAlbum = clazz->getField<jni::JString>("album");
+      jni::local_ref<jni::JString> album = this->getFieldValue(fieldAlbum);
+      static const auto fieldDuration = clazz->getField<double>("duration");
+      double duration = this->getFieldValue(fieldDuration);
+      static const auto fieldUrl = clazz->getField<jni::JString>("url");
+      jni::local_ref<jni::JString> url = this->getFieldValue(fieldUrl);
+      static const auto fieldArtwork = clazz->getField<JVariant_NullType_String>("artwork");
+      jni::local_ref<JVariant_NullType_String> artwork = this->getFieldValue(fieldArtwork);
+      return TrackItem(
+        id->toStdString(),
+        title->toStdString(),
+        artist->toStdString(),
+        album->toStdString(),
+        duration,
+        url->toStdString(),
+        artwork != nullptr ? std::make_optional(artwork->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<JTrackItem::javaobject> fromCpp(const TrackItem& value) {
+      using JSignature = JTrackItem(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, double, jni::alias_ref<jni::JString>, jni::alias_ref<JVariant_NullType_String>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.id),
+        jni::make_jstring(value.title),
+        jni::make_jstring(value.artist),
+        jni::make_jstring(value.album),
+        value.duration,
+        jni::make_jstring(value.url),
+        value.artwork.has_value() ? JVariant_NullType_String::fromCpp(value.artwork.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

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

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

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_Playlist.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JVariant_NullType_Playlist.hpp"
+
+namespace margelo::nitro::nitroplayer {
+  /**
+   * Converts JVariant_NullType_Playlist to std::variant<nitro::NullType, Playlist>
+   */
+  std::variant<nitro::NullType, Playlist> JVariant_NullType_Playlist::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_Playlist_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_Playlist_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_Playlist_impl::Second::javaClassStatic())) {
+      // It's a `Playlist`
+      auto jniValue = static_cast<const JVariant_NullType_Playlist_impl::Second*>(this)->getValue();
+      return jniValue->toCpp();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,77 @@
+///
+/// JVariant_NullType_Playlist.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <variant>
+
+#include <NitroModules/Null.hpp>
+#include "Playlist.hpp"
+#include <variant>
+#include <NitroModules/JNull.hpp>
+#include "JPlaylist.hpp"
+#include <string>
+#include <optional>
+#include "JVariant_NullType_String.hpp"
+#include "TrackItem.hpp"
+#include <vector>
+#include "JTrackItem.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Playlist".
+   */
+  class JVariant_NullType_Playlist: public jni::JavaClass<JVariant_NullType_Playlist> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_Playlist;";
+
+    static jni::local_ref<JVariant_NullType_Playlist> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Playlist(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_Playlist> create_1(jni::alias_ref<JPlaylist> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Playlist(jni::alias_ref<JPlaylist>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_Playlist> fromCpp(const std::variant<nitro::NullType, Playlist>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(JPlaylist::fromCpp(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, Playlist> toCpp() const;
+  };
+
+  namespace JVariant_NullType_Playlist_impl {
+    class First: public jni::JavaClass<First, JVariant_NullType_Playlist> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_Playlist$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second: public jni::JavaClass<Second, JVariant_NullType_Playlist> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_Playlist$Second;";
+    
+      [[nodiscard]] jni::local_ref<JPlaylist> getValue() const {
+        static const auto field = javaClassStatic()->getField<JPlaylist>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_Playlist_impl
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_String.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JVariant_NullType_String.hpp"
+
+namespace margelo::nitro::nitroplayer {
+  /**
+   * Converts JVariant_NullType_String to std::variant<nitro::NullType, std::string>
+   */
+  std::variant<nitro::NullType, std::string> JVariant_NullType_String::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_String_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_String_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_String_impl::Second::javaClassStatic())) {
+      // It's a `std::string`
+      auto jniValue = static_cast<const JVariant_NullType_String_impl::Second*>(this)->getValue();
+      return jniValue->toStdString();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitroplayer