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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,89 @@
+///
+/// JFunc_void_std__optional_ResolvedTrack_.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 "ResolvedTrack.hpp"
+#include <optional>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JResolvedTrack.hpp"
+#include <string>
+#include "Track.hpp"
+#include <vector>
+#include "JTrack.hpp"
+#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 `(content: ResolvedTrack?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__optional_ResolvedTrack_: public jni::JavaClass<JFunc_void_std__optional_ResolvedTrack_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_std__optional_ResolvedTrack_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__optional_ResolvedTrack_` instance holds through JNI.
+     */
+    void invoke(const std::optional<ResolvedTrack>& content) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JResolvedTrack> /* content */)>("invoke");
+      method(self(), content.has_value() ? JResolvedTrack::fromCpp(content.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__optional_ResolvedTrack_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__optional_ResolvedTrack__cxx final: public jni::HybridClass<JFunc_void_std__optional_ResolvedTrack__cxx, JFunc_void_std__optional_ResolvedTrack_> {
+  public:
+    static jni::local_ref<JFunc_void_std__optional_ResolvedTrack_::javaobject> fromCpp(const std::function<void(const std::optional<ResolvedTrack>& /* content */)>& func) {
+      return JFunc_void_std__optional_ResolvedTrack__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__optional_ResolvedTrack__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JResolvedTrack> content) {
+      _func(content != nullptr ? std::make_optional(content->toCpp()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::optional<ResolvedTrack>& /* content */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_std__optional_ResolvedTrack__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__optional_ResolvedTrack__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__optional_ResolvedTrack__cxx(const std::function<void(const std::optional<ResolvedTrack>& /* content */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::optional<ResolvedTrack>& /* content */)> _func;
+  };
+
+} // namespace margelo::nitro::audiobrowser