react-native-nitro-player 0.3.0-alpha.9 → 0.4.0

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

@@ -10,12 +10,16 @@
 #include <fbjni/fbjni.h>
 #include "PlayerState.hpp"
 
+#include "CurrentPlayingType.hpp"
+#include "JCurrentPlayingType.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/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include <NitroModules/JNull.hpp>
 #include <NitroModules/Null.hpp>
 #include <optional>
@@ -53,13 +57,16 @@ namespace margelo::nitro::nitroplayer {
       jni::local_ref<JVariant_NullType_String> currentPlaylistId = this->getFieldValue(fieldCurrentPlaylistId);
       static const auto fieldCurrentIndex = clazz->getField<double>("currentIndex");
       double currentIndex = this->getFieldValue(fieldCurrentIndex);
+      static const auto fieldCurrentPlayingType = clazz->getField<JCurrentPlayingType>("currentPlayingType");
+      jni::local_ref<JCurrentPlayingType> currentPlayingType = this->getFieldValue(fieldCurrentPlayingType);
       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
+        currentIndex,
+        currentPlayingType->toCpp()
       );
     }
 
@@ -69,7 +76,7 @@ namespace margelo::nitro::nitroplayer {
      */
     [[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);
+      using JSignature = JPlayerState(jni::alias_ref<JVariant_NullType_TrackItem>, double, double, jni::alias_ref<JTrackPlayerState>, jni::alias_ref<JVariant_NullType_String>, double, jni::alias_ref<JCurrentPlayingType>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -79,7 +86,8 @@ namespace margelo::nitro::nitroplayer {
         value.totalDuration,
         JTrackPlayerState::fromCpp(value.currentState),
         value.currentPlaylistId.has_value() ? JVariant_NullType_String::fromCpp(value.currentPlaylistId.value()) : nullptr,
-        value.currentIndex
+        value.currentIndex,
+        JCurrentPlayingType::fromCpp(value.currentPlayingType)
       );
     }
   };

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

@@ -13,6 +13,8 @@
 #include "JTrackItem.hpp"
 #include "JVariant_NullType_String.hpp"
 #include "TrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include <NitroModules/JNull.hpp>
 #include <NitroModules/Null.hpp>
 #include <optional>

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

@@ -0,0 +1,59 @@
+///
+/// JPresetType.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 "PresetType.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "PresetType" and the the Kotlin enum "PresetType".
+   */
+  struct JPresetType final: public jni::JavaClass<JPresetType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/PresetType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum PresetType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PresetType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<PresetType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JPresetType> fromCpp(PresetType value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldBUILT_IN = clazz->getStaticField<JPresetType>("BUILT_IN");
+      static const auto fieldCUSTOM = clazz->getStaticField<JPresetType>("CUSTOM");
+      
+      switch (value) {
+        case PresetType::BUILT_IN:
+          return clazz->getStaticFieldValue(fieldBUILT_IN);
+        case PresetType::CUSTOM:
+          return clazz->getStaticFieldValue(fieldCUSTOM);
+        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++/JStorageLocation.hpp

@@ -0,0 +1,59 @@
+///
+/// JStorageLocation.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 "StorageLocation.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "StorageLocation" and the the Kotlin enum "StorageLocation".
+   */
+  struct JStorageLocation final: public jni::JavaClass<JStorageLocation> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/StorageLocation;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum StorageLocation.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    StorageLocation toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<StorageLocation>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JStorageLocation> fromCpp(StorageLocation value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPRIVATE = clazz->getStaticField<JStorageLocation>("PRIVATE");
+      static const auto fieldPUBLIC = clazz->getStaticField<JStorageLocation>("PUBLIC");
+      
+      switch (value) {
+        case StorageLocation::PRIVATE:
+          return clazz->getStaticFieldValue(fieldPRIVATE);
+        case StorageLocation::PUBLIC:
+          return clazz->getStaticFieldValue(fieldPUBLIC);
+        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++/JTrackItem.hpp

@@ -11,6 +11,8 @@
 #include "TrackItem.hpp"
 
 #include "JVariant_NullType_String.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include <NitroModules/JNull.hpp>
 #include <NitroModules/Null.hpp>
 #include <optional>
@@ -50,6 +52,8 @@ namespace margelo::nitro::nitroplayer {
       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);
+      static const auto fieldExtraPayload = clazz->getField<JAnyMap::javaobject>("extraPayload");
+      jni::local_ref<JAnyMap::javaobject> extraPayload = this->getFieldValue(fieldExtraPayload);
       return TrackItem(
         id->toStdString(),
         title->toStdString(),
@@ -57,7 +61,8 @@ namespace margelo::nitro::nitroplayer {
         album->toStdString(),
         duration,
         url->toStdString(),
-        artwork != nullptr ? std::make_optional(artwork->toCpp()) : std::nullopt
+        artwork != nullptr ? std::make_optional(artwork->toCpp()) : std::nullopt,
+        extraPayload != nullptr ? std::make_optional(extraPayload->cthis()->getMap()) : std::nullopt
       );
     }
 
@@ -67,7 +72,7 @@ namespace margelo::nitro::nitroplayer {
      */
     [[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>);
+      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>, jni::alias_ref<JAnyMap::javaobject>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -78,7 +83,8 @@ namespace margelo::nitro::nitroplayer {
         jni::make_jstring(value.album),
         value.duration,
         jni::make_jstring(value.url),
-        value.artwork.has_value() ? JVariant_NullType_String::fromCpp(value.artwork.value()) : nullptr
+        value.artwork.has_value() ? JVariant_NullType_String::fromCpp(value.artwork.value()) : nullptr,
+        value.extraPayload.has_value() ? JAnyMap::create(value.extraPayload.value()) : nullptr
       );
     }
   };

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

@@ -41,15 +41,15 @@ namespace margelo::nitro::nitroplayer {
     [[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 fieldPLAYING = clazz->getStaticField<JTrackPlayerState>("PLAYING");
       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::PLAYING:
+          return clazz->getStaticFieldValue(fieldPLAYING);
         case TrackPlayerState::STOPPED:
           return clazz->getStaticFieldValue(fieldSTOPPED);
         default:

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

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_Double.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_Double.hpp"
+
+namespace margelo::nitro::nitroplayer {
+  /**
+   * Converts JVariant_NullType_Double to std::variant<nitro::NullType, double>
+   */
+  std::variant<nitro::NullType, double> JVariant_NullType_Double::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_Double_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_Double_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_Double_impl::Second::javaClassStatic())) {
+      // It's a `double`
+      auto jniValue = static_cast<const JVariant_NullType_Double_impl::Second*>(this)->getValue();
+      return jniValue;
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,69 @@
+///
+/// JVariant_NullType_Double.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 <variant>
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Double".
+   */
+  class JVariant_NullType_Double: public jni::JavaClass<JVariant_NullType_Double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_Double;";
+
+    static jni::local_ref<JVariant_NullType_Double> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Double(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_Double> create_1(double value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Double(double)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_Double> fromCpp(const std::variant<nitro::NullType, double>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(std::get<1>(variant));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, double> toCpp() const;
+  };
+
+  namespace JVariant_NullType_Double_impl {
+    class First: public jni::JavaClass<First, JVariant_NullType_Double> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_Double$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_Double> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_Double$Second;";
+    
+      [[nodiscard]] double getValue() const {
+        static const auto field = javaClassStatic()->getField<double>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_Double_impl
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_DownloadError.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_DownloadError.hpp"
+
+namespace margelo::nitro::nitroplayer {
+  /**
+   * Converts JVariant_NullType_DownloadError to std::variant<nitro::NullType, DownloadError>
+   */
+  std::variant<nitro::NullType, DownloadError> JVariant_NullType_DownloadError::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_DownloadError_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_DownloadError_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_DownloadError_impl::Second::javaClassStatic())) {
+      // It's a `DownloadError`
+      auto jniValue = static_cast<const JVariant_NullType_DownloadError_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_DownloadError.hpp

@@ -0,0 +1,74 @@
+///
+/// JVariant_NullType_DownloadError.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 "DownloadError.hpp"
+#include <variant>
+#include <NitroModules/JNull.hpp>
+#include "JDownloadError.hpp"
+#include <string>
+#include "DownloadErrorReason.hpp"
+#include "JDownloadErrorReason.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_DownloadError".
+   */
+  class JVariant_NullType_DownloadError: public jni::JavaClass<JVariant_NullType_DownloadError> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_DownloadError;";
+
+    static jni::local_ref<JVariant_NullType_DownloadError> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_DownloadError(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_DownloadError> create_1(jni::alias_ref<JDownloadError> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_DownloadError(jni::alias_ref<JDownloadError>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_DownloadError> fromCpp(const std::variant<nitro::NullType, DownloadError>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(JDownloadError::fromCpp(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, DownloadError> toCpp() const;
+  };
+
+  namespace JVariant_NullType_DownloadError_impl {
+    class First: public jni::JavaClass<First, JVariant_NullType_DownloadError> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_DownloadError$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_DownloadError> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_DownloadError$Second;";
+    
+      [[nodiscard]] jni::local_ref<JDownloadError> getValue() const {
+        static const auto field = javaClassStatic()->getField<JDownloadError>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_DownloadError_impl
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_DownloadTask.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_DownloadTask.hpp"
+
+namespace margelo::nitro::nitroplayer {
+  /**
+   * Converts JVariant_NullType_DownloadTask to std::variant<nitro::NullType, DownloadTask>
+   */
+  std::variant<nitro::NullType, DownloadTask> JVariant_NullType_DownloadTask::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_DownloadTask_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_DownloadTask_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_DownloadTask_impl::Second::javaClassStatic())) {
+      // It's a `DownloadTask`
+      auto jniValue = static_cast<const JVariant_NullType_DownloadTask_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_DownloadTask.hpp

@@ -0,0 +1,84 @@
+///
+/// JVariant_NullType_DownloadTask.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 "DownloadTask.hpp"
+#include <variant>
+#include <NitroModules/JNull.hpp>
+#include "JDownloadTask.hpp"
+#include <string>
+#include <optional>
+#include "JVariant_NullType_String.hpp"
+#include "DownloadState.hpp"
+#include "JDownloadState.hpp"
+#include "DownloadProgress.hpp"
+#include "JDownloadProgress.hpp"
+#include "JVariant_NullType_Double.hpp"
+#include "DownloadError.hpp"
+#include "JVariant_NullType_DownloadError.hpp"
+#include "JDownloadError.hpp"
+#include "DownloadErrorReason.hpp"
+#include "JDownloadErrorReason.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_DownloadTask".
+   */
+  class JVariant_NullType_DownloadTask: public jni::JavaClass<JVariant_NullType_DownloadTask> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_DownloadTask;";
+
+    static jni::local_ref<JVariant_NullType_DownloadTask> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_DownloadTask(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_DownloadTask> create_1(jni::alias_ref<JDownloadTask> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_DownloadTask(jni::alias_ref<JDownloadTask>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_DownloadTask> fromCpp(const std::variant<nitro::NullType, DownloadTask>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(JDownloadTask::fromCpp(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, DownloadTask> toCpp() const;
+  };
+
+  namespace JVariant_NullType_DownloadTask_impl {
+    class First: public jni::JavaClass<First, JVariant_NullType_DownloadTask> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_DownloadTask$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_DownloadTask> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Variant_NullType_DownloadTask$Second;";
+    
+      [[nodiscard]] jni::local_ref<JDownloadTask> getValue() const {
+        static const auto field = javaClassStatic()->getField<JDownloadTask>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_DownloadTask_impl
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_DownloadedPlaylist.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_DownloadedPlaylist.hpp"
+
+namespace margelo::nitro::nitroplayer {
+  /**
+   * Converts JVariant_NullType_DownloadedPlaylist to std::variant<nitro::NullType, DownloadedPlaylist>
+   */
+  std::variant<nitro::NullType, DownloadedPlaylist> JVariant_NullType_DownloadedPlaylist::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_DownloadedPlaylist_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_DownloadedPlaylist_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_DownloadedPlaylist_impl::Second::javaClassStatic())) {
+      // It's a `DownloadedPlaylist`
+      auto jniValue = static_cast<const JVariant_NullType_DownloadedPlaylist_impl::Second*>(this)->getValue();
+      return jniValue->toCpp();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitroplayer