react-native-audio-browser 0.1.1 → 0.2.0-next.1

package/nitrogen/generated/shared/c++/NativeRouteEntry.hpp

@@ -68,7 +68,7 @@ namespace margelo::nitro::audiobrowser {
   struct NativeRouteEntry final {
   public:
     std::string path     SWIFT_PRIVATE;
-    std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>> browseCallback     SWIFT_PRIVATE;
+    std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>> browseCallback     SWIFT_PRIVATE;
     std::optional<TransformableRequestConfig> browseConfig     SWIFT_PRIVATE;
     std::optional<ResolvedTrack> browseStatic     SWIFT_PRIVATE;
     std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>> searchCallback     SWIFT_PRIVATE;
@@ -78,7 +78,7 @@ namespace margelo::nitro::audiobrowser {
 
   public:
     NativeRouteEntry() = default;
-    explicit NativeRouteEntry(std::string path, std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>> browseCallback, std::optional<TransformableRequestConfig> browseConfig, std::optional<ResolvedTrack> browseStatic, std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>> searchCallback, std::optional<TransformableRequestConfig> searchConfig, std::optional<MediaRequestConfig> media, std::optional<ArtworkRequestConfig> artwork): path(path), browseCallback(browseCallback), browseConfig(browseConfig), browseStatic(browseStatic), searchCallback(searchCallback), searchConfig(searchConfig), media(media), artwork(artwork) {}
+    explicit NativeRouteEntry(std::string path, std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>> browseCallback, std::optional<TransformableRequestConfig> browseConfig, std::optional<ResolvedTrack> browseStatic, std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>> searchCallback, std::optional<TransformableRequestConfig> searchConfig, std::optional<MediaRequestConfig> media, std::optional<ArtworkRequestConfig> artwork): path(path), browseCallback(browseCallback), browseConfig(browseConfig), browseStatic(browseStatic), searchCallback(searchCallback), searchConfig(searchConfig), media(media), artwork(artwork) {}
 
   public:
     // NativeRouteEntry is not equatable because these properties are not equatable: browseCallback, browseConfig, searchCallback, searchConfig, media, artwork
@@ -95,7 +95,7 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::audiobrowser::NativeRouteEntry(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "path"))),
-        JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<margelo::nitro::audiobrowser::ResolvedTrack, margelo::nitro::audiobrowser::BrowseError>>>>>(const margelo::nitro::audiobrowser::BrowserSourceCallbackParam&)>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "browseCallback"))),
+        JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::variant<margelo::nitro::audiobrowser::ResolvedTrack, margelo::nitro::audiobrowser::BrowseError, std::shared_ptr<Promise<std::variant<margelo::nitro::audiobrowser::ResolvedTrack, margelo::nitro::audiobrowser::BrowseError>>>>>>(const margelo::nitro::audiobrowser::BrowserSourceCallbackParam&)>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "browseCallback"))),
         JSIConverter<std::optional<margelo::nitro::audiobrowser::TransformableRequestConfig>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "browseConfig"))),
         JSIConverter<std::optional<margelo::nitro::audiobrowser::ResolvedTrack>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "browseStatic"))),
         JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<margelo::nitro::audiobrowser::Track>>>>>(const margelo::nitro::audiobrowser::SearchParams&)>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "searchCallback"))),
@@ -107,7 +107,7 @@ namespace margelo::nitro {
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::audiobrowser::NativeRouteEntry& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "path"), JSIConverter<std::string>::toJSI(runtime, arg.path));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "browseCallback"), JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<margelo::nitro::audiobrowser::ResolvedTrack, margelo::nitro::audiobrowser::BrowseError>>>>>(const margelo::nitro::audiobrowser::BrowserSourceCallbackParam&)>>>::toJSI(runtime, arg.browseCallback));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "browseCallback"), JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::variant<margelo::nitro::audiobrowser::ResolvedTrack, margelo::nitro::audiobrowser::BrowseError, std::shared_ptr<Promise<std::variant<margelo::nitro::audiobrowser::ResolvedTrack, margelo::nitro::audiobrowser::BrowseError>>>>>>(const margelo::nitro::audiobrowser::BrowserSourceCallbackParam&)>>>::toJSI(runtime, arg.browseCallback));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "browseConfig"), JSIConverter<std::optional<margelo::nitro::audiobrowser::TransformableRequestConfig>>::toJSI(runtime, arg.browseConfig));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "browseStatic"), JSIConverter<std::optional<margelo::nitro::audiobrowser::ResolvedTrack>>::toJSI(runtime, arg.browseStatic));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "searchCallback"), JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<margelo::nitro::audiobrowser::Track>>>>>(const margelo::nitro::audiobrowser::SearchParams&)>>>::toJSI(runtime, arg.searchCallback));
@@ -125,7 +125,7 @@ namespace margelo::nitro {
         return false;
       }
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "path")))) return false;
-      if (!JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<margelo::nitro::audiobrowser::ResolvedTrack, margelo::nitro::audiobrowser::BrowseError>>>>>(const margelo::nitro::audiobrowser::BrowserSourceCallbackParam&)>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "browseCallback")))) return false;
+      if (!JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::variant<margelo::nitro::audiobrowser::ResolvedTrack, margelo::nitro::audiobrowser::BrowseError, std::shared_ptr<Promise<std::variant<margelo::nitro::audiobrowser::ResolvedTrack, margelo::nitro::audiobrowser::BrowseError>>>>>>(const margelo::nitro::audiobrowser::BrowserSourceCallbackParam&)>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "browseCallback")))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::TransformableRequestConfig>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "browseConfig")))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::ResolvedTrack>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "browseStatic")))) return false;
       if (!JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<margelo::nitro::audiobrowser::Track>>>>>(const margelo::nitro::audiobrowser::SearchParams&)>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "searchCallback")))) return false;

package/nitrogen/generated/shared/c++/NativeSetupPlayerOptions.hpp

@@ -0,0 +1,138 @@
+///
+/// NativeSetupPlayerOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `NativeAndroidSetupOptions` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NativeAndroidSetupOptions; }
+// Forward declaration of `NativeIOSSetupOptions` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NativeIOSSetupOptions; }
+// Forward declaration of `NativeUpdateOptions` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NativeUpdateOptions; }
+// Forward declaration of `NowPlayingUpdate` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NowPlayingUpdate; }
+// Forward declaration of `FormatNowPlayingParams` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct FormatNowPlayingParams; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class RepeatMode; }
+// Forward declaration of `RetryConfig` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RetryConfig; }
+
+#include "NativeAndroidSetupOptions.hpp"
+#include <optional>
+#include "NativeIOSSetupOptions.hpp"
+#include "NativeUpdateOptions.hpp"
+#include "NowPlayingUpdate.hpp"
+#include <NitroModules/Promise.hpp>
+#include "FormatNowPlayingParams.hpp"
+#include <functional>
+#include "RepeatMode.hpp"
+#include "RetryConfig.hpp"
+#include <variant>
+
+namespace margelo::nitro::audiobrowser {
+
+  /**
+   * A struct which can be represented as a JavaScript object (NativeSetupPlayerOptions).
+   */
+  struct NativeSetupPlayerOptions final {
+  public:
+    std::optional<NativeAndroidSetupOptions> android     SWIFT_PRIVATE;
+    std::optional<NativeIOSSetupOptions> ios     SWIFT_PRIVATE;
+    std::optional<NativeUpdateOptions> options     SWIFT_PRIVATE;
+    std::optional<bool> autoUpdateNowPlayingMetadata     SWIFT_PRIVATE;
+    std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>> nowPlayingMetadataFormatter     SWIFT_PRIVATE;
+    std::optional<bool> playWhenReady     SWIFT_PRIVATE;
+    std::optional<RepeatMode> repeatMode     SWIFT_PRIVATE;
+    std::optional<std::variant<bool, RetryConfig>> retry     SWIFT_PRIVATE;
+    std::optional<bool> keepSessionAliveOnError     SWIFT_PRIVATE;
+
+  public:
+    NativeSetupPlayerOptions() = default;
+    explicit NativeSetupPlayerOptions(std::optional<NativeAndroidSetupOptions> android, std::optional<NativeIOSSetupOptions> ios, std::optional<NativeUpdateOptions> options, std::optional<bool> autoUpdateNowPlayingMetadata, std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>> nowPlayingMetadataFormatter, std::optional<bool> playWhenReady, std::optional<RepeatMode> repeatMode, std::optional<std::variant<bool, RetryConfig>> retry, std::optional<bool> keepSessionAliveOnError): android(android), ios(ios), options(options), autoUpdateNowPlayingMetadata(autoUpdateNowPlayingMetadata), nowPlayingMetadataFormatter(nowPlayingMetadataFormatter), playWhenReady(playWhenReady), repeatMode(repeatMode), retry(retry), keepSessionAliveOnError(keepSessionAliveOnError) {}
+
+  public:
+    // NativeSetupPlayerOptions is not equatable because these properties are not equatable: nowPlayingMetadataFormatter
+  };
+
+} // namespace margelo::nitro::audiobrowser
+
+namespace margelo::nitro {
+
+  // C++ NativeSetupPlayerOptions <> JS NativeSetupPlayerOptions (object)
+  template <>
+  struct JSIConverter<margelo::nitro::audiobrowser::NativeSetupPlayerOptions> final {
+    static inline margelo::nitro::audiobrowser::NativeSetupPlayerOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::audiobrowser::NativeSetupPlayerOptions(
+        JSIConverter<std::optional<margelo::nitro::audiobrowser::NativeAndroidSetupOptions>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "android"))),
+        JSIConverter<std::optional<margelo::nitro::audiobrowser::NativeIOSSetupOptions>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ios"))),
+        JSIConverter<std::optional<margelo::nitro::audiobrowser::NativeUpdateOptions>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "options"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "autoUpdateNowPlayingMetadata"))),
+        JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::optional<margelo::nitro::audiobrowser::NowPlayingUpdate>>>(const margelo::nitro::audiobrowser::FormatNowPlayingParams&)>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nowPlayingMetadataFormatter"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "playWhenReady"))),
+        JSIConverter<std::optional<margelo::nitro::audiobrowser::RepeatMode>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "repeatMode"))),
+        JSIConverter<std::optional<std::variant<bool, margelo::nitro::audiobrowser::RetryConfig>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "retry"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "keepSessionAliveOnError")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::audiobrowser::NativeSetupPlayerOptions& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "android"), JSIConverter<std::optional<margelo::nitro::audiobrowser::NativeAndroidSetupOptions>>::toJSI(runtime, arg.android));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "ios"), JSIConverter<std::optional<margelo::nitro::audiobrowser::NativeIOSSetupOptions>>::toJSI(runtime, arg.ios));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "options"), JSIConverter<std::optional<margelo::nitro::audiobrowser::NativeUpdateOptions>>::toJSI(runtime, arg.options));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "autoUpdateNowPlayingMetadata"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.autoUpdateNowPlayingMetadata));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "nowPlayingMetadataFormatter"), JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::optional<margelo::nitro::audiobrowser::NowPlayingUpdate>>>(const margelo::nitro::audiobrowser::FormatNowPlayingParams&)>>>::toJSI(runtime, arg.nowPlayingMetadataFormatter));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "playWhenReady"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.playWhenReady));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "repeatMode"), JSIConverter<std::optional<margelo::nitro::audiobrowser::RepeatMode>>::toJSI(runtime, arg.repeatMode));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "retry"), JSIConverter<std::optional<std::variant<bool, margelo::nitro::audiobrowser::RetryConfig>>>::toJSI(runtime, arg.retry));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "keepSessionAliveOnError"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.keepSessionAliveOnError));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::NativeAndroidSetupOptions>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "android")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::NativeIOSSetupOptions>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ios")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::NativeUpdateOptions>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "options")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "autoUpdateNowPlayingMetadata")))) return false;
+      if (!JSIConverter<std::optional<std::function<std::shared_ptr<Promise<std::optional<margelo::nitro::audiobrowser::NowPlayingUpdate>>>(const margelo::nitro::audiobrowser::FormatNowPlayingParams&)>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "nowPlayingMetadataFormatter")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "playWhenReady")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::RepeatMode>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "repeatMode")))) return false;
+      if (!JSIConverter<std::optional<std::variant<bool, margelo::nitro::audiobrowser::RetryConfig>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "retry")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "keepSessionAliveOnError")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/NativeUpdateOptions.hpp

@@ -30,15 +30,17 @@
 
 // Forward declaration of `NitroAndroidUpdateOptions` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct NitroAndroidUpdateOptions; }
+// Forward declaration of `NitroIOSUpdateOptions` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NitroIOSUpdateOptions; }
 // Forward declaration of `PlayerCapabilities` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct PlayerCapabilities; }
 
 #include "NitroAndroidUpdateOptions.hpp"
 #include <optional>
+#include "NitroIOSUpdateOptions.hpp"
 #include <NitroModules/Null.hpp>
 #include <variant>
 #include "PlayerCapabilities.hpp"
-#include <vector>
 
 namespace margelo::nitro::audiobrowser {
 
@@ -48,15 +50,15 @@ namespace margelo::nitro::audiobrowser {
   struct NativeUpdateOptions final {
   public:
     std::optional<NitroAndroidUpdateOptions> android     SWIFT_PRIVATE;
+    std::optional<NitroIOSUpdateOptions> ios     SWIFT_PRIVATE;
     std::optional<double> forwardJumpInterval     SWIFT_PRIVATE;
     std::optional<double> backwardJumpInterval     SWIFT_PRIVATE;
     std::optional<std::variant<nitro::NullType, double>> progressUpdateEventInterval     SWIFT_PRIVATE;
     std::optional<PlayerCapabilities> capabilities     SWIFT_PRIVATE;
-    std::optional<std::vector<double>> iosPlaybackRates     SWIFT_PRIVATE;
 
   public:
     NativeUpdateOptions() = default;
-    explicit NativeUpdateOptions(std::optional<NitroAndroidUpdateOptions> android, std::optional<double> forwardJumpInterval, std::optional<double> backwardJumpInterval, std::optional<std::variant<nitro::NullType, double>> progressUpdateEventInterval, std::optional<PlayerCapabilities> capabilities, std::optional<std::vector<double>> iosPlaybackRates): android(android), forwardJumpInterval(forwardJumpInterval), backwardJumpInterval(backwardJumpInterval), progressUpdateEventInterval(progressUpdateEventInterval), capabilities(capabilities), iosPlaybackRates(iosPlaybackRates) {}
+    explicit NativeUpdateOptions(std::optional<NitroAndroidUpdateOptions> android, std::optional<NitroIOSUpdateOptions> ios, std::optional<double> forwardJumpInterval, std::optional<double> backwardJumpInterval, std::optional<std::variant<nitro::NullType, double>> progressUpdateEventInterval, std::optional<PlayerCapabilities> capabilities): android(android), ios(ios), forwardJumpInterval(forwardJumpInterval), backwardJumpInterval(backwardJumpInterval), progressUpdateEventInterval(progressUpdateEventInterval), capabilities(capabilities) {}
 
   public:
     friend bool operator==(const NativeUpdateOptions& lhs, const NativeUpdateOptions& rhs) = default;
@@ -73,21 +75,21 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::audiobrowser::NativeUpdateOptions(
         JSIConverter<std::optional<margelo::nitro::audiobrowser::NitroAndroidUpdateOptions>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "android"))),
+        JSIConverter<std::optional<margelo::nitro::audiobrowser::NitroIOSUpdateOptions>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ios"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "forwardJumpInterval"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "backwardJumpInterval"))),
         JSIConverter<std::optional<std::variant<nitro::NullType, double>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "progressUpdateEventInterval"))),
-        JSIConverter<std::optional<margelo::nitro::audiobrowser::PlayerCapabilities>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "capabilities"))),
-        JSIConverter<std::optional<std::vector<double>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "iosPlaybackRates")))
+        JSIConverter<std::optional<margelo::nitro::audiobrowser::PlayerCapabilities>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "capabilities")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::audiobrowser::NativeUpdateOptions& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "android"), JSIConverter<std::optional<margelo::nitro::audiobrowser::NitroAndroidUpdateOptions>>::toJSI(runtime, arg.android));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "ios"), JSIConverter<std::optional<margelo::nitro::audiobrowser::NitroIOSUpdateOptions>>::toJSI(runtime, arg.ios));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "forwardJumpInterval"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.forwardJumpInterval));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "backwardJumpInterval"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.backwardJumpInterval));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "progressUpdateEventInterval"), JSIConverter<std::optional<std::variant<nitro::NullType, double>>>::toJSI(runtime, arg.progressUpdateEventInterval));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "capabilities"), JSIConverter<std::optional<margelo::nitro::audiobrowser::PlayerCapabilities>>::toJSI(runtime, arg.capabilities));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "iosPlaybackRates"), JSIConverter<std::optional<std::vector<double>>>::toJSI(runtime, arg.iosPlaybackRates));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -99,11 +101,11 @@ namespace margelo::nitro {
         return false;
       }
       if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::NitroAndroidUpdateOptions>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "android")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::NitroIOSUpdateOptions>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ios")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "forwardJumpInterval")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "backwardJumpInterval")))) return false;
       if (!JSIConverter<std::optional<std::variant<nitro::NullType, double>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "progressUpdateEventInterval")))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::PlayerCapabilities>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "capabilities")))) return false;
-      if (!JSIConverter<std::optional<std::vector<double>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "iosPlaybackRates")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/NavigationErrorType.hpp

@@ -34,6 +34,8 @@ namespace margelo::nitro::audiobrowser {
     HTTP_ERROR      SWIFT_NAME(httpError) = 2,
     CALLBACK_ERROR      SWIFT_NAME(callbackError) = 3,
     UNKNOWN_ERROR      SWIFT_NAME(unknownError) = 4,
+    EMPTY_CONTENT      SWIFT_NAME(emptyContent) = 5,
+    TIMEOUT      SWIFT_NAME(timeout) = 6,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::audiobrowser
@@ -51,6 +53,8 @@ namespace margelo::nitro {
         case hashString("http-error"): return margelo::nitro::audiobrowser::NavigationErrorType::HTTP_ERROR;
         case hashString("callback-error"): return margelo::nitro::audiobrowser::NavigationErrorType::CALLBACK_ERROR;
         case hashString("unknown-error"): return margelo::nitro::audiobrowser::NavigationErrorType::UNKNOWN_ERROR;
+        case hashString("empty-content"): return margelo::nitro::audiobrowser::NavigationErrorType::EMPTY_CONTENT;
+        case hashString("timeout"): return margelo::nitro::audiobrowser::NavigationErrorType::TIMEOUT;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NavigationErrorType - invalid value!");
       }
@@ -62,6 +66,8 @@ namespace margelo::nitro {
         case margelo::nitro::audiobrowser::NavigationErrorType::HTTP_ERROR: return JSIConverter<std::string>::toJSI(runtime, "http-error");
         case margelo::nitro::audiobrowser::NavigationErrorType::CALLBACK_ERROR: return JSIConverter<std::string>::toJSI(runtime, "callback-error");
         case margelo::nitro::audiobrowser::NavigationErrorType::UNKNOWN_ERROR: return JSIConverter<std::string>::toJSI(runtime, "unknown-error");
+        case margelo::nitro::audiobrowser::NavigationErrorType::EMPTY_CONTENT: return JSIConverter<std::string>::toJSI(runtime, "empty-content");
+        case margelo::nitro::audiobrowser::NavigationErrorType::TIMEOUT: return JSIConverter<std::string>::toJSI(runtime, "timeout");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert NavigationErrorType to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -78,6 +84,8 @@ namespace margelo::nitro {
         case hashString("http-error"):
         case hashString("callback-error"):
         case hashString("unknown-error"):
+        case hashString("empty-content"):
+        case hashString("timeout"):
           return true;
         default:
           return false;

package/nitrogen/generated/shared/c++/NitroAndroidUpdateOptions.hpp

@@ -30,14 +30,11 @@
 
 // Forward declaration of `AppKilledPlaybackBehavior` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { enum class AppKilledPlaybackBehavior; }
-// Forward declaration of `RatingType` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { enum class RatingType; }
 // Forward declaration of `NotificationButtonLayout` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct NotificationButtonLayout; }
 
 #include "AppKilledPlaybackBehavior.hpp"
 #include <optional>
-#include "RatingType.hpp"
 #include <NitroModules/Null.hpp>
 #include "NotificationButtonLayout.hpp"
 #include <variant>
@@ -51,13 +48,11 @@ namespace margelo::nitro::audiobrowser {
   public:
     std::optional<AppKilledPlaybackBehavior> appKilledPlaybackBehavior     SWIFT_PRIVATE;
     std::optional<bool> skipSilence     SWIFT_PRIVATE;
-    std::optional<bool> shuffle     SWIFT_PRIVATE;
-    std::optional<RatingType> ratingType     SWIFT_PRIVATE;
     std::optional<std::variant<nitro::NullType, NotificationButtonLayout>> notificationButtons     SWIFT_PRIVATE;
 
   public:
     NitroAndroidUpdateOptions() = default;
-    explicit NitroAndroidUpdateOptions(std::optional<AppKilledPlaybackBehavior> appKilledPlaybackBehavior, std::optional<bool> skipSilence, std::optional<bool> shuffle, std::optional<RatingType> ratingType, std::optional<std::variant<nitro::NullType, NotificationButtonLayout>> notificationButtons): appKilledPlaybackBehavior(appKilledPlaybackBehavior), skipSilence(skipSilence), shuffle(shuffle), ratingType(ratingType), notificationButtons(notificationButtons) {}
+    explicit NitroAndroidUpdateOptions(std::optional<AppKilledPlaybackBehavior> appKilledPlaybackBehavior, std::optional<bool> skipSilence, std::optional<std::variant<nitro::NullType, NotificationButtonLayout>> notificationButtons): appKilledPlaybackBehavior(appKilledPlaybackBehavior), skipSilence(skipSilence), notificationButtons(notificationButtons) {}
 
   public:
     friend bool operator==(const NitroAndroidUpdateOptions& lhs, const NitroAndroidUpdateOptions& rhs) = default;
@@ -75,8 +70,6 @@ namespace margelo::nitro {
       return margelo::nitro::audiobrowser::NitroAndroidUpdateOptions(
         JSIConverter<std::optional<margelo::nitro::audiobrowser::AppKilledPlaybackBehavior>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "appKilledPlaybackBehavior"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "skipSilence"))),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "shuffle"))),
-        JSIConverter<std::optional<margelo::nitro::audiobrowser::RatingType>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ratingType"))),
         JSIConverter<std::optional<std::variant<nitro::NullType, margelo::nitro::audiobrowser::NotificationButtonLayout>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "notificationButtons")))
       );
     }
@@ -84,8 +77,6 @@ namespace margelo::nitro {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "appKilledPlaybackBehavior"), JSIConverter<std::optional<margelo::nitro::audiobrowser::AppKilledPlaybackBehavior>>::toJSI(runtime, arg.appKilledPlaybackBehavior));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "skipSilence"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.skipSilence));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "shuffle"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.shuffle));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "ratingType"), JSIConverter<std::optional<margelo::nitro::audiobrowser::RatingType>>::toJSI(runtime, arg.ratingType));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "notificationButtons"), JSIConverter<std::optional<std::variant<nitro::NullType, margelo::nitro::audiobrowser::NotificationButtonLayout>>>::toJSI(runtime, arg.notificationButtons));
       return obj;
     }
@@ -99,8 +90,6 @@ namespace margelo::nitro {
       }
       if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::AppKilledPlaybackBehavior>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "appKilledPlaybackBehavior")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "skipSilence")))) return false;
-      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "shuffle")))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::RatingType>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ratingType")))) return false;
       if (!JSIConverter<std::optional<std::variant<nitro::NullType, margelo::nitro::audiobrowser::NotificationButtonLayout>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "notificationButtons")))) return false;
       return true;
     }

package/nitrogen/generated/shared/c++/NitroIOSUpdateOptions.hpp

@@ -0,0 +1,92 @@
+///
+/// NitroIOSUpdateOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `CarPlayNowPlayingButton` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class CarPlayNowPlayingButton; }
+
+#include <vector>
+#include <optional>
+#include "CarPlayNowPlayingButton.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  /**
+   * A struct which can be represented as a JavaScript object (NitroIOSUpdateOptions).
+   */
+  struct NitroIOSUpdateOptions final {
+  public:
+    std::optional<std::vector<double>> playbackRates     SWIFT_PRIVATE;
+    std::optional<bool> carPlayUpNextButton     SWIFT_PRIVATE;
+    std::optional<std::vector<CarPlayNowPlayingButton>> carPlayNowPlayingButtons     SWIFT_PRIVATE;
+
+  public:
+    NitroIOSUpdateOptions() = default;
+    explicit NitroIOSUpdateOptions(std::optional<std::vector<double>> playbackRates, std::optional<bool> carPlayUpNextButton, std::optional<std::vector<CarPlayNowPlayingButton>> carPlayNowPlayingButtons): playbackRates(playbackRates), carPlayUpNextButton(carPlayUpNextButton), carPlayNowPlayingButtons(carPlayNowPlayingButtons) {}
+
+  };
+
+} // namespace margelo::nitro::audiobrowser
+
+namespace margelo::nitro {
+
+  // C++ NitroIOSUpdateOptions <> JS NitroIOSUpdateOptions (object)
+  template <>
+  struct JSIConverter<margelo::nitro::audiobrowser::NitroIOSUpdateOptions> final {
+    static inline margelo::nitro::audiobrowser::NitroIOSUpdateOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::audiobrowser::NitroIOSUpdateOptions(
+        JSIConverter<std::optional<std::vector<double>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "playbackRates"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "carPlayUpNextButton"))),
+        JSIConverter<std::optional<std::vector<margelo::nitro::audiobrowser::CarPlayNowPlayingButton>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "carPlayNowPlayingButtons")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::audiobrowser::NitroIOSUpdateOptions& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "playbackRates"), JSIConverter<std::optional<std::vector<double>>>::toJSI(runtime, arg.playbackRates));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "carPlayUpNextButton"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.carPlayUpNextButton));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "carPlayNowPlayingButtons"), JSIConverter<std::optional<std::vector<margelo::nitro::audiobrowser::CarPlayNowPlayingButton>>>::toJSI(runtime, arg.carPlayNowPlayingButtons));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<std::vector<double>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "playbackRates")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "carPlayUpNextButton")))) return false;
+      if (!JSIConverter<std::optional<std::vector<margelo::nitro::audiobrowser::CarPlayNowPlayingButton>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "carPlayNowPlayingButtons")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/NotificationButton.hpp

@@ -29,11 +29,11 @@ namespace margelo::nitro::audiobrowser {
    * An enum which can be represented as a JavaScript union (NotificationButton).
    */
   enum class NotificationButton {
-    FAVORITE      SWIFT_NAME(favorite) = 0,
-    SKIP_TO_PREVIOUS      SWIFT_NAME(skipToPrevious) = 1,
-    SKIP_TO_NEXT      SWIFT_NAME(skipToNext) = 2,
-    JUMP_BACKWARD      SWIFT_NAME(jumpBackward) = 3,
-    JUMP_FORWARD      SWIFT_NAME(jumpForward) = 4,
+    SKIP_TO_PREVIOUS      SWIFT_NAME(skipToPrevious) = 0,
+    SKIP_TO_NEXT      SWIFT_NAME(skipToNext) = 1,
+    JUMP_BACKWARD      SWIFT_NAME(jumpBackward) = 2,
+    JUMP_FORWARD      SWIFT_NAME(jumpForward) = 3,
+    FAVORITE      SWIFT_NAME(favorite) = 4,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::audiobrowser
@@ -46,22 +46,22 @@ namespace margelo::nitro {
     static inline margelo::nitro::audiobrowser::NotificationButton fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("favorite"): return margelo::nitro::audiobrowser::NotificationButton::FAVORITE;
         case hashString("skip-to-previous"): return margelo::nitro::audiobrowser::NotificationButton::SKIP_TO_PREVIOUS;
         case hashString("skip-to-next"): return margelo::nitro::audiobrowser::NotificationButton::SKIP_TO_NEXT;
         case hashString("jump-backward"): return margelo::nitro::audiobrowser::NotificationButton::JUMP_BACKWARD;
         case hashString("jump-forward"): return margelo::nitro::audiobrowser::NotificationButton::JUMP_FORWARD;
+        case hashString("favorite"): return margelo::nitro::audiobrowser::NotificationButton::FAVORITE;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NotificationButton - invalid value!");
       }
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::audiobrowser::NotificationButton arg) {
       switch (arg) {
-        case margelo::nitro::audiobrowser::NotificationButton::FAVORITE: return JSIConverter<std::string>::toJSI(runtime, "favorite");
         case margelo::nitro::audiobrowser::NotificationButton::SKIP_TO_PREVIOUS: return JSIConverter<std::string>::toJSI(runtime, "skip-to-previous");
         case margelo::nitro::audiobrowser::NotificationButton::SKIP_TO_NEXT: return JSIConverter<std::string>::toJSI(runtime, "skip-to-next");
         case margelo::nitro::audiobrowser::NotificationButton::JUMP_BACKWARD: return JSIConverter<std::string>::toJSI(runtime, "jump-backward");
         case margelo::nitro::audiobrowser::NotificationButton::JUMP_FORWARD: return JSIConverter<std::string>::toJSI(runtime, "jump-forward");
+        case margelo::nitro::audiobrowser::NotificationButton::FAVORITE: return JSIConverter<std::string>::toJSI(runtime, "favorite");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert NotificationButton to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -73,11 +73,11 @@ namespace margelo::nitro {
       }
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("favorite"):
         case hashString("skip-to-previous"):
         case hashString("skip-to-next"):
         case hashString("jump-backward"):
         case hashString("jump-forward"):
+        case hashString("favorite"):
           return true;
         default:
           return false;

package/nitrogen/generated/shared/c++/NowPlayingMetadata.hpp

@@ -28,22 +28,10 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-// Forward declaration of `HeartRating` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { struct HeartRating; }
-// Forward declaration of `ThumbsRating` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { struct ThumbsRating; }
-// Forward declaration of `StarRating` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { struct StarRating; }
-// Forward declaration of `PercentageRating` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { struct PercentageRating; }
+
 
 #include <optional>
 #include <string>
-#include "HeartRating.hpp"
-#include "ThumbsRating.hpp"
-#include "StarRating.hpp"
-#include "PercentageRating.hpp"
-#include <variant>
 
 namespace margelo::nitro::audiobrowser {
 
@@ -61,11 +49,10 @@ namespace margelo::nitro::audiobrowser {
     std::optional<std::string> description     SWIFT_PRIVATE;
     std::optional<std::string> mediaId     SWIFT_PRIVATE;
     std::optional<std::string> genre     SWIFT_PRIVATE;
-    std::optional<std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>> rating     SWIFT_PRIVATE;
 
   public:
     NowPlayingMetadata() = default;
-    explicit NowPlayingMetadata(std::optional<double> elapsedTime, std::optional<std::string> title, std::optional<std::string> album, std::optional<std::string> artist, std::optional<double> duration, std::optional<std::string> artwork, std::optional<std::string> description, std::optional<std::string> mediaId, std::optional<std::string> genre, std::optional<std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>> rating): elapsedTime(elapsedTime), title(title), album(album), artist(artist), duration(duration), artwork(artwork), description(description), mediaId(mediaId), genre(genre), rating(rating) {}
+    explicit NowPlayingMetadata(std::optional<double> elapsedTime, std::optional<std::string> title, std::optional<std::string> album, std::optional<std::string> artist, std::optional<double> duration, std::optional<std::string> artwork, std::optional<std::string> description, std::optional<std::string> mediaId, std::optional<std::string> genre): elapsedTime(elapsedTime), title(title), album(album), artist(artist), duration(duration), artwork(artwork), description(description), mediaId(mediaId), genre(genre) {}
 
   public:
     friend bool operator==(const NowPlayingMetadata& lhs, const NowPlayingMetadata& rhs) = default;
@@ -89,8 +76,7 @@ namespace margelo::nitro {
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artwork"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "description"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mediaId"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "genre"))),
-        JSIConverter<std::optional<std::variant<margelo::nitro::audiobrowser::HeartRating, margelo::nitro::audiobrowser::ThumbsRating, margelo::nitro::audiobrowser::StarRating, margelo::nitro::audiobrowser::PercentageRating>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "rating")))
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "genre")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::audiobrowser::NowPlayingMetadata& arg) {
@@ -104,7 +90,6 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "description"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.description));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "mediaId"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.mediaId));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "genre"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.genre));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "rating"), JSIConverter<std::optional<std::variant<margelo::nitro::audiobrowser::HeartRating, margelo::nitro::audiobrowser::ThumbsRating, margelo::nitro::audiobrowser::StarRating, margelo::nitro::audiobrowser::PercentageRating>>>::toJSI(runtime, arg.rating));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -124,7 +109,6 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "description")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mediaId")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "genre")))) return false;
-      if (!JSIConverter<std::optional<std::variant<margelo::nitro::audiobrowser::HeartRating, margelo::nitro::audiobrowser::ThumbsRating, margelo::nitro::audiobrowser::StarRating, margelo::nitro::audiobrowser::PercentageRating>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "rating")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/NowPlayingUpdate.hpp

@@ -42,10 +42,11 @@ namespace margelo::nitro::audiobrowser {
   public:
     std::optional<std::string> title     SWIFT_PRIVATE;
     std::optional<std::string> artist     SWIFT_PRIVATE;
+    std::optional<std::string> album     SWIFT_PRIVATE;
 
   public:
     NowPlayingUpdate() = default;
-    explicit NowPlayingUpdate(std::optional<std::string> title, std::optional<std::string> artist): title(title), artist(artist) {}
+    explicit NowPlayingUpdate(std::optional<std::string> title, std::optional<std::string> artist, std::optional<std::string> album): title(title), artist(artist), album(album) {}
 
   public:
     friend bool operator==(const NowPlayingUpdate& lhs, const NowPlayingUpdate& rhs) = default;
@@ -62,13 +63,15 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::audiobrowser::NowPlayingUpdate(
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "title"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artist")))
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artist"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "album")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::audiobrowser::NowPlayingUpdate& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "title"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.title));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "artist"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.artist));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "album"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.album));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -81,6 +84,7 @@ namespace margelo::nitro {
       }
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "title")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artist")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "album")))) return false;
       return true;
     }
   };