@5stones/react-native-audio-browser 0.1.0

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

@@ -0,0 +1,83 @@
+///
+/// JFunc_void_NavigationErrorEvent.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 <functional>
+
+#include "NavigationErrorEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JNavigationErrorEvent.hpp"
+#include "NavigationError.hpp"
+#include <optional>
+#include "JNavigationError.hpp"
+#include "NavigationErrorType.hpp"
+#include "JNavigationErrorType.hpp"
+#include <string>
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: NavigationErrorEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_NavigationErrorEvent: public jni::JavaClass<JFunc_void_NavigationErrorEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_NavigationErrorEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_NavigationErrorEvent` instance holds through JNI.
+     */
+    void invoke(const NavigationErrorEvent& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JNavigationErrorEvent> /* data */)>("invoke");
+      method(self(), JNavigationErrorEvent::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_NavigationErrorEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_NavigationErrorEvent_cxx final: public jni::HybridClass<JFunc_void_NavigationErrorEvent_cxx, JFunc_void_NavigationErrorEvent> {
+  public:
+    static jni::local_ref<JFunc_void_NavigationErrorEvent::javaobject> fromCpp(const std::function<void(const NavigationErrorEvent& /* data */)>& func) {
+      return JFunc_void_NavigationErrorEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_NavigationErrorEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JNavigationErrorEvent> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const NavigationErrorEvent& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_NavigationErrorEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_NavigationErrorEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_NavigationErrorEvent_cxx(const std::function<void(const NavigationErrorEvent& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const NavigationErrorEvent& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::audiobrowser

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

@@ -0,0 +1,89 @@
+///
+/// JFunc_void_NowPlayingMetadata.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 <functional>
+
+#include "NowPlayingMetadata.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JNowPlayingMetadata.hpp"
+#include <optional>
+#include <string>
+#include "HeartRating.hpp"
+#include "ThumbsRating.hpp"
+#include "StarRating.hpp"
+#include "PercentageRating.hpp"
+#include <variant>
+#include "JVariant_HeartRating_ThumbsRating_StarRating_PercentageRating.hpp"
+#include "JHeartRating.hpp"
+#include "JThumbsRating.hpp"
+#include "JStarRating.hpp"
+#include "JPercentageRating.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(metadata: NowPlayingMetadata) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_NowPlayingMetadata: public jni::JavaClass<JFunc_void_NowPlayingMetadata> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_NowPlayingMetadata;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_NowPlayingMetadata` instance holds through JNI.
+     */
+    void invoke(const NowPlayingMetadata& metadata) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JNowPlayingMetadata> /* metadata */)>("invoke");
+      method(self(), JNowPlayingMetadata::fromCpp(metadata));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_NowPlayingMetadata that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_NowPlayingMetadata_cxx final: public jni::HybridClass<JFunc_void_NowPlayingMetadata_cxx, JFunc_void_NowPlayingMetadata> {
+  public:
+    static jni::local_ref<JFunc_void_NowPlayingMetadata::javaobject> fromCpp(const std::function<void(const NowPlayingMetadata& /* metadata */)>& func) {
+      return JFunc_void_NowPlayingMetadata_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_NowPlayingMetadata_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JNowPlayingMetadata> metadata) {
+      _func(metadata->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const NowPlayingMetadata& /* metadata */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_NowPlayingMetadata_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_NowPlayingMetadata_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_NowPlayingMetadata_cxx(const std::function<void(const NowPlayingMetadata& /* metadata */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const NowPlayingMetadata& /* metadata */)> _func;
+  };
+
+} // namespace margelo::nitro::audiobrowser

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

@@ -0,0 +1,98 @@
+///
+/// JFunc_void_Options.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 <functional>
+
+#include "Options.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JOptions.hpp"
+#include "AndroidOptions.hpp"
+#include <optional>
+#include "JAndroidOptions.hpp"
+#include "AppKilledPlaybackBehavior.hpp"
+#include "JAppKilledPlaybackBehavior.hpp"
+#include "RatingType.hpp"
+#include "JRatingType.hpp"
+#include <NitroModules/Null.hpp>
+#include "NotificationButtonLayout.hpp"
+#include <variant>
+#include "JVariant_NullType_NotificationButtonLayout.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JNotificationButtonLayout.hpp"
+#include "NotificationButton.hpp"
+#include "JNotificationButton.hpp"
+#include <vector>
+#include "JVariant_NullType_Double.hpp"
+#include "PlayerCapabilities.hpp"
+#include "JPlayerCapabilities.hpp"
+#include "RepeatMode.hpp"
+#include "JRepeatMode.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: Options) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_Options: public jni::JavaClass<JFunc_void_Options> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_Options;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_Options` instance holds through JNI.
+     */
+    void invoke(const Options& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JOptions> /* event */)>("invoke");
+      method(self(), JOptions::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_Options that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_Options_cxx final: public jni::HybridClass<JFunc_void_Options_cxx, JFunc_void_Options> {
+  public:
+    static jni::local_ref<JFunc_void_Options::javaobject> fromCpp(const std::function<void(const Options& /* event */)>& func) {
+      return JFunc_void_Options_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_Options_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JOptions> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const Options& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_Options_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_Options_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_Options_cxx(const std::function<void(const Options& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const Options& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::audiobrowser

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

@@ -0,0 +1,83 @@
+///
+/// JFunc_void_Playback.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 <functional>
+
+#include "Playback.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JPlayback.hpp"
+#include "PlaybackState.hpp"
+#include "JPlaybackState.hpp"
+#include "PlaybackError.hpp"
+#include <optional>
+#include "JPlaybackError.hpp"
+#include <string>
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: Playback) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_Playback: public jni::JavaClass<JFunc_void_Playback> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_Playback;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_Playback` instance holds through JNI.
+     */
+    void invoke(const Playback& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPlayback> /* data */)>("invoke");
+      method(self(), JPlayback::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_Playback that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_Playback_cxx final: public jni::HybridClass<JFunc_void_Playback_cxx, JFunc_void_Playback> {
+  public:
+    static jni::local_ref<JFunc_void_Playback::javaobject> fromCpp(const std::function<void(const Playback& /* data */)>& func) {
+      return JFunc_void_Playback_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_Playback_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JPlayback> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const Playback& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_Playback_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_Playback_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_Playback_cxx(const std::function<void(const Playback& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const Playback& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::audiobrowser

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

@@ -0,0 +1,88 @@
+///
+/// JFunc_void_PlaybackActiveTrackChangedEvent.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 <functional>
+
+#include "PlaybackActiveTrackChangedEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JPlaybackActiveTrackChangedEvent.hpp"
+#include <optional>
+#include "Track.hpp"
+#include "JTrack.hpp"
+#include <string>
+#include "ImageSource.hpp"
+#include "JImageSource.hpp"
+#include "HttpMethod.hpp"
+#include "JHttpMethod.hpp"
+#include <unordered_map>
+#include "TrackStyle.hpp"
+#include "JTrackStyle.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: PlaybackActiveTrackChangedEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_PlaybackActiveTrackChangedEvent: public jni::JavaClass<JFunc_void_PlaybackActiveTrackChangedEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_PlaybackActiveTrackChangedEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_PlaybackActiveTrackChangedEvent` instance holds through JNI.
+     */
+    void invoke(const PlaybackActiveTrackChangedEvent& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPlaybackActiveTrackChangedEvent> /* data */)>("invoke");
+      method(self(), JPlaybackActiveTrackChangedEvent::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_PlaybackActiveTrackChangedEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_PlaybackActiveTrackChangedEvent_cxx final: public jni::HybridClass<JFunc_void_PlaybackActiveTrackChangedEvent_cxx, JFunc_void_PlaybackActiveTrackChangedEvent> {
+  public:
+    static jni::local_ref<JFunc_void_PlaybackActiveTrackChangedEvent::javaobject> fromCpp(const std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)>& func) {
+      return JFunc_void_PlaybackActiveTrackChangedEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_PlaybackActiveTrackChangedEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JPlaybackActiveTrackChangedEvent> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_PlaybackActiveTrackChangedEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_PlaybackActiveTrackChangedEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_PlaybackActiveTrackChangedEvent_cxx(const std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::audiobrowser

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

@@ -0,0 +1,81 @@
+///
+/// JFunc_void_PlaybackErrorEvent.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 <functional>
+
+#include "PlaybackErrorEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JPlaybackErrorEvent.hpp"
+#include "PlaybackError.hpp"
+#include <optional>
+#include "JPlaybackError.hpp"
+#include <string>
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: PlaybackErrorEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_PlaybackErrorEvent: public jni::JavaClass<JFunc_void_PlaybackErrorEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_PlaybackErrorEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_PlaybackErrorEvent` instance holds through JNI.
+     */
+    void invoke(const PlaybackErrorEvent& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPlaybackErrorEvent> /* data */)>("invoke");
+      method(self(), JPlaybackErrorEvent::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_PlaybackErrorEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_PlaybackErrorEvent_cxx final: public jni::HybridClass<JFunc_void_PlaybackErrorEvent_cxx, JFunc_void_PlaybackErrorEvent> {
+  public:
+    static jni::local_ref<JFunc_void_PlaybackErrorEvent::javaobject> fromCpp(const std::function<void(const PlaybackErrorEvent& /* data */)>& func) {
+      return JFunc_void_PlaybackErrorEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_PlaybackErrorEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JPlaybackErrorEvent> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const PlaybackErrorEvent& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_PlaybackErrorEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_PlaybackErrorEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_PlaybackErrorEvent_cxx(const std::function<void(const PlaybackErrorEvent& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const PlaybackErrorEvent& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::audiobrowser

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_PlaybackPlayWhenReadyChangedEvent.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 <functional>
+
+#include "PlaybackPlayWhenReadyChangedEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JPlaybackPlayWhenReadyChangedEvent.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: PlaybackPlayWhenReadyChangedEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_PlaybackPlayWhenReadyChangedEvent: public jni::JavaClass<JFunc_void_PlaybackPlayWhenReadyChangedEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_PlaybackPlayWhenReadyChangedEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_PlaybackPlayWhenReadyChangedEvent` instance holds through JNI.
+     */
+    void invoke(const PlaybackPlayWhenReadyChangedEvent& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPlaybackPlayWhenReadyChangedEvent> /* data */)>("invoke");
+      method(self(), JPlaybackPlayWhenReadyChangedEvent::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_PlaybackPlayWhenReadyChangedEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_PlaybackPlayWhenReadyChangedEvent_cxx final: public jni::HybridClass<JFunc_void_PlaybackPlayWhenReadyChangedEvent_cxx, JFunc_void_PlaybackPlayWhenReadyChangedEvent> {
+  public:
+    static jni::local_ref<JFunc_void_PlaybackPlayWhenReadyChangedEvent::javaobject> fromCpp(const std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)>& func) {
+      return JFunc_void_PlaybackPlayWhenReadyChangedEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_PlaybackPlayWhenReadyChangedEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JPlaybackPlayWhenReadyChangedEvent> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_PlaybackPlayWhenReadyChangedEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_PlaybackPlayWhenReadyChangedEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_PlaybackPlayWhenReadyChangedEvent_cxx(const std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::audiobrowser

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_PlaybackProgressUpdatedEvent.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 <functional>
+
+#include "PlaybackProgressUpdatedEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JPlaybackProgressUpdatedEvent.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: PlaybackProgressUpdatedEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_PlaybackProgressUpdatedEvent: public jni::JavaClass<JFunc_void_PlaybackProgressUpdatedEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_PlaybackProgressUpdatedEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_PlaybackProgressUpdatedEvent` instance holds through JNI.
+     */
+    void invoke(const PlaybackProgressUpdatedEvent& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPlaybackProgressUpdatedEvent> /* data */)>("invoke");
+      method(self(), JPlaybackProgressUpdatedEvent::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_PlaybackProgressUpdatedEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_PlaybackProgressUpdatedEvent_cxx final: public jni::HybridClass<JFunc_void_PlaybackProgressUpdatedEvent_cxx, JFunc_void_PlaybackProgressUpdatedEvent> {
+  public:
+    static jni::local_ref<JFunc_void_PlaybackProgressUpdatedEvent::javaobject> fromCpp(const std::function<void(const PlaybackProgressUpdatedEvent& /* data */)>& func) {
+      return JFunc_void_PlaybackProgressUpdatedEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_PlaybackProgressUpdatedEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JPlaybackProgressUpdatedEvent> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const PlaybackProgressUpdatedEvent& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_PlaybackProgressUpdatedEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_PlaybackProgressUpdatedEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_PlaybackProgressUpdatedEvent_cxx(const std::function<void(const PlaybackProgressUpdatedEvent& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const PlaybackProgressUpdatedEvent& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::audiobrowser