react-native-audio-browser 0.2.0-next.3 → 0.2.0-next.31

package/nitrogen/generated/ios/AudioBrowser-Swift-Cxx-Bridge.hpp

@@ -18,6 +18,8 @@ namespace margelo::nitro::audiobrowser { struct AndroidOptions; }
 namespace margelo::nitro::audiobrowser { enum class AndroidPlayerWakeMode; }
 // Forward declaration of `AppKilledPlaybackBehavior` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { enum class AppKilledPlaybackBehavior; }
+// Forward declaration of `ArtworkRendering` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class ArtworkRendering; }
 // Forward declaration of `ArtworkRequestConfig` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct ArtworkRequestConfig; }
 // Forward declaration of `ArtworkVariants` to properly resolve imports.
@@ -34,18 +36,18 @@ namespace margelo::nitro::audiobrowser { struct BrowseError; }
 namespace margelo::nitro::audiobrowser { struct BrowserSourceCallbackParam; }
 // Forward declaration of `CarPlayNowPlayingButton` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { enum class CarPlayNowPlayingButton; }
+// Forward declaration of `CarPlayPlayingIndicatorLocation` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class CarPlayPlayingIndicatorLocation; }
 // Forward declaration of `CarPlaySiriListButtonPosition` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { enum class CarPlaySiriListButtonPosition; }
+// Forward declaration of `CardImage` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class CardImage; }
 // Forward declaration of `ChapterMetadata` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct ChapterMetadata; }
 // Forward declaration of `EqualizerSettings` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct EqualizerSettings; }
 // Forward declaration of `FavoriteChangedEvent` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct FavoriteChangedEvent; }
-// Forward declaration of `FavoriteConfig` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { struct FavoriteConfig; }
-// Forward declaration of `FavoritesMatchMode` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { enum class FavoritesMatchMode; }
 // Forward declaration of `FormatNavigationErrorParams` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct FormatNavigationErrorParams; }
 // Forward declaration of `FormatNowPlayingParams` to properly resolve imports.
@@ -60,6 +62,8 @@ namespace margelo::nitro::audiobrowser { struct GateEvent; }
 namespace margelo::nitro::audiobrowser { enum class GateReason; }
 // Forward declaration of `Gate` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct Gate; }
+// Forward declaration of `GridTile` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class GridTile; }
 // Forward declaration of `HttpMethod` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { enum class HttpMethod; }
 // Forward declaration of `HybridAudioBrowserSpec` to properly resolve imports.
@@ -78,8 +82,8 @@ namespace margelo::nitro::audiobrowser { struct IOSOptions; }
 namespace margelo::nitro::audiobrowser { struct ImageContext; }
 // Forward declaration of `ImageQueryParams` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct ImageQueryParams; }
-// Forward declaration of `ImageRowItem` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { struct ImageRowItem; }
+// Forward declaration of `ImageShape` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class ImageShape; }
 // Forward declaration of `ImageSource` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct ImageSource; }
 // Forward declaration of `MediaReference` to properly resolve imports.
@@ -100,6 +104,8 @@ namespace margelo::nitro::audiobrowser { struct NativeRouteEntry; }
 namespace margelo::nitro::audiobrowser { struct NativeUpdateOptions; }
 // Forward declaration of `NavigationErrorEvent` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct NavigationErrorEvent; }
+// Forward declaration of `NavigationErrorKind` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class NavigationErrorKind; }
 // Forward declaration of `NavigationErrorType` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { enum class NavigationErrorType; }
 // Forward declaration of `NavigationError` to properly resolve imports.
@@ -108,10 +114,6 @@ namespace margelo::nitro::audiobrowser { struct NavigationError; }
 namespace margelo::nitro::audiobrowser { struct NitroAndroidUpdateOptions; }
 // Forward declaration of `NitroIOSUpdateOptions` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct NitroIOSUpdateOptions; }
-// Forward declaration of `NotificationButtonLayout` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { struct NotificationButtonLayout; }
-// Forward declaration of `NotificationButton` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { enum class NotificationButton; }
 // Forward declaration of `NowPlayingMetadata` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct NowPlayingMetadata; }
 // Forward declaration of `NowPlayingUpdate` to properly resolve imports.
@@ -146,6 +148,10 @@ namespace margelo::nitro::audiobrowser { struct PlayerCapabilities; }
 namespace margelo::nitro::audiobrowser { struct PlayingState; }
 // Forward declaration of `Progress` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct Progress; }
+// Forward declaration of `RemoteButtonLayout` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteButtonLayout; }
+// Forward declaration of `RemoteButton` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class RemoteButton; }
 // Forward declaration of `RemoteJumpBackwardEvent` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct RemoteJumpBackwardEvent; }
 // Forward declaration of `RemoteJumpForwardEvent` to properly resolve imports.
@@ -172,12 +178,18 @@ namespace margelo::nitro::audiobrowser { struct RetryConfig; }
 namespace margelo::nitro::audiobrowser { enum class SearchMode; }
 // Forward declaration of `SearchParams` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct SearchParams; }
+// Forward declaration of `SectionStyle` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct SectionStyle; }
+// Forward declaration of `Section` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct Section; }
 // Forward declaration of `SleepTimerEndOfTrack` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct SleepTimerEndOfTrack; }
 // Forward declaration of `SleepTimerTime` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct SleepTimerTime; }
 // Forward declaration of `StallReason` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { enum class StallReason; }
+// Forward declaration of `StyleDisplay` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class StyleDisplay; }
 // Forward declaration of `TimedMetadata` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct TimedMetadata; }
 // Forward declaration of `TrackLoadEvent` to properly resolve imports.
@@ -187,7 +199,7 @@ namespace margelo::nitro::audiobrowser { struct TrackMetadata; }
 // Forward declaration of `TrackRequest` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct TrackRequest; }
 // Forward declaration of `TrackStyle` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { enum class TrackStyle; }
+namespace margelo::nitro::audiobrowser { struct TrackStyle; }
 // Forward declaration of `Track` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct Track; }
 // Forward declaration of `TransformableRequestConfig` to properly resolve imports.
@@ -203,6 +215,7 @@ namespace AudioBrowser { class HybridAudioBrowserSpec_cxx; }
 #include "AndroidOptions.hpp"
 #include "AndroidPlayerWakeMode.hpp"
 #include "AppKilledPlaybackBehavior.hpp"
+#include "ArtworkRendering.hpp"
 #include "ArtworkRequestConfig.hpp"
 #include "ArtworkVariants.hpp"
 #include "BatteryOptimizationStatus.hpp"
@@ -211,12 +224,12 @@ namespace AudioBrowser { class HybridAudioBrowserSpec_cxx; }
 #include "BrowseError.hpp"
 #include "BrowserSourceCallbackParam.hpp"
 #include "CarPlayNowPlayingButton.hpp"
+#include "CarPlayPlayingIndicatorLocation.hpp"
 #include "CarPlaySiriListButtonPosition.hpp"
+#include "CardImage.hpp"
 #include "ChapterMetadata.hpp"
 #include "EqualizerSettings.hpp"
 #include "FavoriteChangedEvent.hpp"
-#include "FavoriteConfig.hpp"
-#include "FavoritesMatchMode.hpp"
 #include "FormatNavigationErrorParams.hpp"
 #include "FormatNowPlayingParams.hpp"
 #include "FormattedNavigationError.hpp"
@@ -224,6 +237,7 @@ namespace AudioBrowser { class HybridAudioBrowserSpec_cxx; }
 #include "GateDecision.hpp"
 #include "GateEvent.hpp"
 #include "GateReason.hpp"
+#include "GridTile.hpp"
 #include "HttpMethod.hpp"
 #include "HybridAudioBrowserSpec.hpp"
 #include "IOSCategory.hpp"
@@ -233,7 +247,7 @@ namespace AudioBrowser { class HybridAudioBrowserSpec_cxx; }
 #include "IOSOptions.hpp"
 #include "ImageContext.hpp"
 #include "ImageQueryParams.hpp"
-#include "ImageRowItem.hpp"
+#include "ImageShape.hpp"
 #include "ImageSource.hpp"
 #include "MediaReference.hpp"
 #include "MediaRequestConfig.hpp"
@@ -245,11 +259,10 @@ namespace AudioBrowser { class HybridAudioBrowserSpec_cxx; }
 #include "NativeUpdateOptions.hpp"
 #include "NavigationError.hpp"
 #include "NavigationErrorEvent.hpp"
+#include "NavigationErrorKind.hpp"
 #include "NavigationErrorType.hpp"
 #include "NitroAndroidUpdateOptions.hpp"
 #include "NitroIOSUpdateOptions.hpp"
-#include "NotificationButton.hpp"
-#include "NotificationButtonLayout.hpp"
 #include "NowPlayingMetadata.hpp"
 #include "NowPlayingUpdate.hpp"
 #include "Options.hpp"
@@ -267,6 +280,8 @@ namespace AudioBrowser { class HybridAudioBrowserSpec_cxx; }
 #include "PlayerCapabilities.hpp"
 #include "PlayingState.hpp"
 #include "Progress.hpp"
+#include "RemoteButton.hpp"
+#include "RemoteButtonLayout.hpp"
 #include "RemoteJumpBackwardEvent.hpp"
 #include "RemoteJumpForwardEvent.hpp"
 #include "RemotePlayIdEvent.hpp"
@@ -280,9 +295,12 @@ namespace AudioBrowser { class HybridAudioBrowserSpec_cxx; }
 #include "RetryConfig.hpp"
 #include "SearchMode.hpp"
 #include "SearchParams.hpp"
+#include "Section.hpp"
+#include "SectionStyle.hpp"
 #include "SleepTimerEndOfTrack.hpp"
 #include "SleepTimerTime.hpp"
 #include "StallReason.hpp"
+#include "StyleDisplay.hpp"
 #include "TimedMetadata.hpp"
 #include "Track.hpp"
 #include "TrackLoadEvent.hpp"
@@ -324,21 +342,6 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::variant<std::string, ArtworkVariants>>
-  /**
-   * Specialized version of `std::optional<std::variant<std::string, ArtworkVariants>>`.
-   */
-  using std__optional_std__variant_std__string__ArtworkVariants__ = std::optional<std::variant<std::string, ArtworkVariants>>;
-  inline std::optional<std::variant<std::string, ArtworkVariants>> create_std__optional_std__variant_std__string__ArtworkVariants__(const std::variant<std::string, ArtworkVariants>& value) noexcept {
-    return std::optional<std::variant<std::string, ArtworkVariants>>(value);
-  }
-  inline bool has_value_std__optional_std__variant_std__string__ArtworkVariants__(const std::optional<std::variant<std::string, ArtworkVariants>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::variant<std::string, ArtworkVariants> get_std__optional_std__variant_std__string__ArtworkVariants__(const std::optional<std::variant<std::string, ArtworkVariants>>& optional) noexcept {
-    return optional.value();
-  }
-  
   // pragma MARK: std::variant<std::string, ArtworkVariants>
   /**
    * Wrapper struct for `std::variant<std::string, ArtworkVariants>`.
@@ -368,18 +371,18 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return std__variant_std__string__ArtworkVariants_(value);
   }
   
-  // pragma MARK: std::optional<ImageSource>
+  // pragma MARK: std::optional<std::variant<std::string, ArtworkVariants>>
   /**
-   * Specialized version of `std::optional<ImageSource>`.
+   * Specialized version of `std::optional<std::variant<std::string, ArtworkVariants>>`.
    */
-  using std__optional_ImageSource_ = std::optional<ImageSource>;
-  inline std::optional<ImageSource> create_std__optional_ImageSource_(const ImageSource& value) noexcept {
-    return std::optional<ImageSource>(value);
+  using std__optional_std__variant_std__string__ArtworkVariants__ = std::optional<std::variant<std::string, ArtworkVariants>>;
+  inline std::optional<std::variant<std::string, ArtworkVariants>> create_std__optional_std__variant_std__string__ArtworkVariants__(const std::variant<std::string, ArtworkVariants>& value) noexcept {
+    return std::optional<std::variant<std::string, ArtworkVariants>>(value);
   }
-  inline bool has_value_std__optional_ImageSource_(const std::optional<ImageSource>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_std__string__ArtworkVariants__(const std::optional<std::variant<std::string, ArtworkVariants>>& optional) noexcept {
     return optional.has_value();
   }
-  inline ImageSource get_std__optional_ImageSource_(const std::optional<ImageSource>& optional) noexcept {
+  inline std::variant<std::string, ArtworkVariants> get_std__optional_std__variant_std__string__ArtworkVariants__(const std::optional<std::variant<std::string, ArtworkVariants>>& optional) noexcept {
     return optional.value();
   }
   
@@ -398,21 +401,6 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::unordered_map<std::string, std::string>>
-  /**
-   * Specialized version of `std::optional<std::unordered_map<std::string, std::string>>`.
-   */
-  using std__optional_std__unordered_map_std__string__std__string__ = std::optional<std::unordered_map<std::string, std::string>>;
-  inline std::optional<std::unordered_map<std::string, std::string>> create_std__optional_std__unordered_map_std__string__std__string__(const std::unordered_map<std::string, std::string>& value) noexcept {
-    return std::optional<std::unordered_map<std::string, std::string>>(value);
-  }
-  inline bool has_value_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::unordered_map<std::string, std::string> get_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
-    return optional.value();
-  }
-  
   // pragma MARK: std::unordered_map<std::string, std::string>
   /**
    * Specialized version of `std::unordered_map<std::string, std::string>`.
@@ -438,33 +426,48 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     map.emplace(key, value);
   }
   
-  // pragma MARK: std::optional<TrackRequest>
+  // pragma MARK: std::optional<std::unordered_map<std::string, std::string>>
   /**
-   * Specialized version of `std::optional<TrackRequest>`.
+   * Specialized version of `std::optional<std::unordered_map<std::string, std::string>>`.
    */
-  using std__optional_TrackRequest_ = std::optional<TrackRequest>;
-  inline std::optional<TrackRequest> create_std__optional_TrackRequest_(const TrackRequest& value) noexcept {
-    return std::optional<TrackRequest>(value);
+  using std__optional_std__unordered_map_std__string__std__string__ = std::optional<std::unordered_map<std::string, std::string>>;
+  inline std::optional<std::unordered_map<std::string, std::string>> create_std__optional_std__unordered_map_std__string__std__string__(const std::unordered_map<std::string, std::string>& value) noexcept {
+    return std::optional<std::unordered_map<std::string, std::string>>(value);
   }
-  inline bool has_value_std__optional_TrackRequest_(const std::optional<TrackRequest>& optional) noexcept {
+  inline bool has_value_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
     return optional.has_value();
   }
-  inline TrackRequest get_std__optional_TrackRequest_(const std::optional<TrackRequest>& optional) noexcept {
+  inline std::unordered_map<std::string, std::string> get_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<bool>
+  // pragma MARK: std::optional<ImageSource>
   /**
-   * Specialized version of `std::optional<bool>`.
+   * Specialized version of `std::optional<ImageSource>`.
    */
-  using std__optional_bool_ = std::optional<bool>;
-  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
-    return std::optional<bool>(value);
+  using std__optional_ImageSource_ = std::optional<ImageSource>;
+  inline std::optional<ImageSource> create_std__optional_ImageSource_(const ImageSource& value) noexcept {
+    return std::optional<ImageSource>(value);
   }
-  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+  inline bool has_value_std__optional_ImageSource_(const std::optional<ImageSource>& optional) noexcept {
     return optional.has_value();
   }
-  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+  inline ImageSource get_std__optional_ImageSource_(const std::optional<ImageSource>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<TrackRequest>
+  /**
+   * Specialized version of `std::optional<TrackRequest>`.
+   */
+  using std__optional_TrackRequest_ = std::optional<TrackRequest>;
+  inline std::optional<TrackRequest> create_std__optional_TrackRequest_(const TrackRequest& value) noexcept {
+    return std::optional<TrackRequest>(value);
+  }
+  inline bool has_value_std__optional_TrackRequest_(const std::optional<TrackRequest>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TrackRequest get_std__optional_TrackRequest_(const std::optional<TrackRequest>& optional) noexcept {
     return optional.value();
   }
   
@@ -483,6 +486,66 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::optional<StyleDisplay>
+  /**
+   * Specialized version of `std::optional<StyleDisplay>`.
+   */
+  using std__optional_StyleDisplay_ = std::optional<StyleDisplay>;
+  inline std::optional<StyleDisplay> create_std__optional_StyleDisplay_(const StyleDisplay& value) noexcept {
+    return std::optional<StyleDisplay>(value);
+  }
+  inline bool has_value_std__optional_StyleDisplay_(const std::optional<StyleDisplay>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline StyleDisplay get_std__optional_StyleDisplay_(const std::optional<StyleDisplay>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<ArtworkRendering>
+  /**
+   * Specialized version of `std::optional<ArtworkRendering>`.
+   */
+  using std__optional_ArtworkRendering_ = std::optional<ArtworkRendering>;
+  inline std::optional<ArtworkRendering> create_std__optional_ArtworkRendering_(const ArtworkRendering& value) noexcept {
+    return std::optional<ArtworkRendering>(value);
+  }
+  inline bool has_value_std__optional_ArtworkRendering_(const std::optional<ArtworkRendering>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ArtworkRendering get_std__optional_ArtworkRendering_(const std::optional<ArtworkRendering>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<ImageShape>
+  /**
+   * Specialized version of `std::optional<ImageShape>`.
+   */
+  using std__optional_ImageShape_ = std::optional<ImageShape>;
+  inline std::optional<ImageShape> create_std__optional_ImageShape_(const ImageShape& value) noexcept {
+    return std::optional<ImageShape>(value);
+  }
+  inline bool has_value_std__optional_ImageShape_(const std::optional<ImageShape>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ImageShape get_std__optional_ImageShape_(const std::optional<ImageShape>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<CardImage>
+  /**
+   * Specialized version of `std::optional<CardImage>`.
+   */
+  using std__optional_CardImage_ = std::optional<CardImage>;
+  inline std::optional<CardImage> create_std__optional_CardImage_(const CardImage& value) noexcept {
+    return std::optional<CardImage>(value);
+  }
+  inline bool has_value_std__optional_CardImage_(const std::optional<CardImage>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline CardImage get_std__optional_CardImage_(const std::optional<CardImage>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<TrackStyle>
   /**
    * Specialized version of `std::optional<TrackStyle>`.
@@ -498,32 +561,21 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::vector<ImageRowItem>>
+  // pragma MARK: std::optional<bool>
   /**
-   * Specialized version of `std::optional<std::vector<ImageRowItem>>`.
+   * Specialized version of `std::optional<bool>`.
    */
-  using std__optional_std__vector_ImageRowItem__ = std::optional<std::vector<ImageRowItem>>;
-  inline std::optional<std::vector<ImageRowItem>> create_std__optional_std__vector_ImageRowItem__(const std::vector<ImageRowItem>& value) noexcept {
-    return std::optional<std::vector<ImageRowItem>>(value);
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
   }
-  inline bool has_value_std__optional_std__vector_ImageRowItem__(const std::optional<std::vector<ImageRowItem>>& optional) noexcept {
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::vector<ImageRowItem> get_std__optional_std__vector_ImageRowItem__(const std::optional<std::vector<ImageRowItem>>& optional) noexcept {
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::vector<ImageRowItem>
-  /**
-   * Specialized version of `std::vector<ImageRowItem>`.
-   */
-  using std__vector_ImageRowItem_ = std::vector<ImageRowItem>;
-  inline std::vector<ImageRowItem> create_std__vector_ImageRowItem_(size_t size) noexcept {
-    std::vector<ImageRowItem> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
   // pragma MARK: std::vector<Track>
   /**
    * Specialized version of `std::vector<Track>`.
@@ -606,6 +658,62 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<GridTile>
+  /**
+   * Specialized version of `std::optional<GridTile>`.
+   */
+  using std__optional_GridTile_ = std::optional<GridTile>;
+  inline std::optional<GridTile> create_std__optional_GridTile_(const GridTile& value) noexcept {
+    return std::optional<GridTile>(value);
+  }
+  inline bool has_value_std__optional_GridTile_(const std::optional<GridTile>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline GridTile get_std__optional_GridTile_(const std::optional<GridTile>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<SectionStyle>
+  /**
+   * Specialized version of `std::optional<SectionStyle>`.
+   */
+  using std__optional_SectionStyle_ = std::optional<SectionStyle>;
+  inline std::optional<SectionStyle> create_std__optional_SectionStyle_(const SectionStyle& value) noexcept {
+    return std::optional<SectionStyle>(value);
+  }
+  inline bool has_value_std__optional_SectionStyle_(const std::optional<SectionStyle>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline SectionStyle get_std__optional_SectionStyle_(const std::optional<SectionStyle>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::vector<Section>
+  /**
+   * Specialized version of `std::vector<Section>`.
+   */
+  using std__vector_Section_ = std::vector<Section>;
+  inline std::vector<Section> create_std__vector_Section_(size_t size) noexcept {
+    std::vector<Section> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<Section>>
+  /**
+   * Specialized version of `std::optional<std::vector<Section>>`.
+   */
+  using std__optional_std__vector_Section__ = std::optional<std::vector<Section>>;
+  inline std::optional<std::vector<Section>> create_std__optional_std__vector_Section__(const std::vector<Section>& value) noexcept {
+    return std::optional<std::vector<Section>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_Section__(const std::optional<std::vector<Section>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<Section> get_std__optional_std__vector_Section__(const std::optional<std::vector<Section>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<CarPlaySiriListButtonPosition>
   /**
    * Specialized version of `std::optional<CarPlaySiriListButtonPosition>`.
@@ -765,34 +873,38 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<TransformableRequestConfig>
+  // pragma MARK: std::shared_ptr<Promise<RequestConfig>>
   /**
-   * Specialized version of `std::optional<TransformableRequestConfig>`.
+   * Specialized version of `std::shared_ptr<Promise<RequestConfig>>`.
    */
-  using std__optional_TransformableRequestConfig_ = std::optional<TransformableRequestConfig>;
-  inline std::optional<TransformableRequestConfig> create_std__optional_TransformableRequestConfig_(const TransformableRequestConfig& value) noexcept {
-    return std::optional<TransformableRequestConfig>(value);
-  }
-  inline bool has_value_std__optional_TransformableRequestConfig_(const std::optional<TransformableRequestConfig>& optional) noexcept {
-    return optional.has_value();
+  using std__shared_ptr_Promise_RequestConfig__ = std::shared_ptr<Promise<RequestConfig>>;
+  inline std::shared_ptr<Promise<RequestConfig>> create_std__shared_ptr_Promise_RequestConfig__() noexcept {
+    return Promise<RequestConfig>::create();
   }
-  inline TransformableRequestConfig get_std__optional_TransformableRequestConfig_(const std::optional<TransformableRequestConfig>& optional) noexcept {
-    return optional.value();
+  inline PromiseHolder<RequestConfig> wrap_std__shared_ptr_Promise_RequestConfig__(std::shared_ptr<Promise<RequestConfig>> promise) noexcept {
+    return PromiseHolder<RequestConfig>(std::move(promise));
   }
   
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>
+  // pragma MARK: std::function<void(const RequestConfig& /* result */)>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& / * request * /, const std::optional<std::unordered_map<std::string, std::string>>& / * routeParams * /)>>`.
+   * Specialized version of `std::function<void(const RequestConfig&)>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_RequestConfig_____request_____const_std__optional_std__unordered_map_std__string__std__string_______routeParams______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_RequestConfig_____request_____const_std__optional_std__unordered_map_std__string__std__string_______routeParams______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>(value);
-  }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_RequestConfig_____request_____const_std__optional_std__unordered_map_std__string__std__string_______routeParams______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_RequestConfig_____request_____const_std__optional_std__unordered_map_std__string__std__string_______routeParams______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>& optional) noexcept {
-    return optional.value();
+  using Func_void_RequestConfig = std::function<void(const RequestConfig& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RequestConfig& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_RequestConfig_Wrapper final {
+  public:
+    explicit Func_void_RequestConfig_Wrapper(std::function<void(const RequestConfig& /* result */)>&& func): _function(std::make_unique<std::function<void(const RequestConfig& /* result */)>>(std::move(func))) {}
+    inline void call(RequestConfig result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RequestConfig& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RequestConfig create_Func_void_RequestConfig(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RequestConfig_Wrapper wrap_Func_void_RequestConfig(Func_void_RequestConfig value) noexcept {
+    return Func_void_RequestConfig_Wrapper(std::move(value));
   }
   
   // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>
@@ -852,38 +964,42 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_void_std__shared_ptr_Promise_RequestConfig___Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<RequestConfig>>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<RequestConfig>>`.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& / * request * /, const std::optional<std::unordered_map<std::string, std::string>>& / * routeParams * /)>>`.
    */
-  using std__shared_ptr_Promise_RequestConfig__ = std::shared_ptr<Promise<RequestConfig>>;
-  inline std::shared_ptr<Promise<RequestConfig>> create_std__shared_ptr_Promise_RequestConfig__() noexcept {
-    return Promise<RequestConfig>::create();
+  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_RequestConfig_____request_____const_std__optional_std__unordered_map_std__string__std__string_______routeParams______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_RequestConfig_____request_____const_std__optional_std__unordered_map_std__string__std__string_______routeParams______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>(value);
   }
-  inline PromiseHolder<RequestConfig> wrap_std__shared_ptr_Promise_RequestConfig__(std::shared_ptr<Promise<RequestConfig>> promise) noexcept {
-    return PromiseHolder<RequestConfig>(std::move(promise));
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_RequestConfig_____request_____const_std__optional_std__unordered_map_std__string__std__string_______routeParams______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_RequestConfig_____request_____const_std__optional_std__unordered_map_std__string__std__string_______routeParams______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::function<void(const RequestConfig& /* result */)>
+  // pragma MARK: std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>
   /**
-   * Specialized version of `std::function<void(const RequestConfig&)>`.
+   * Specialized version of `std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig&, const std::optional<std::unordered_map<std::string, std::string>>&)>`.
    */
-  using Func_void_RequestConfig = std::function<void(const RequestConfig& /* result */)>;
+  using Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__ = std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>;
   /**
-   * Wrapper class for a `std::function<void(const RequestConfig& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& / * request * /, const std::optional<std::unordered_map<std::string, std::string>>& / * routeParams * /)>`, this can be used from Swift.
    */
-  class Func_void_RequestConfig_Wrapper final {
+  class Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper final {
   public:
-    explicit Func_void_RequestConfig_Wrapper(std::function<void(const RequestConfig& /* result */)>&& func): _function(std::make_unique<std::function<void(const RequestConfig& /* result */)>>(std::move(func))) {}
-    inline void call(RequestConfig result) const noexcept {
-      _function->operator()(result);
+    explicit Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper(std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<RequestConfig>> call(RequestConfig request, std::optional<std::unordered_map<std::string, std::string>> routeParams) const noexcept {
+      auto __result = _function->operator()(request, routeParams);
+      return __result;
     }
   private:
-    std::unique_ptr<std::function<void(const RequestConfig& /* result */)>> _function;
+    std::unique_ptr<std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_RequestConfig create_Func_void_RequestConfig(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_RequestConfig_Wrapper wrap_Func_void_RequestConfig(Func_void_RequestConfig value) noexcept {
-    return Func_void_RequestConfig_Wrapper(std::move(value));
+  Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__ create_Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper wrap_Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__(Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__ value) noexcept {
+    return Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper(std::move(value));
   }
   
   // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>
@@ -901,42 +1017,53 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>
+  // pragma MARK: std::optional<TransformableRequestConfig>
   /**
-   * Specialized version of `std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig&, const std::optional<std::unordered_map<std::string, std::string>>&)>`.
+   * Specialized version of `std::optional<TransformableRequestConfig>`.
    */
-  using Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__ = std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>;
-  /**
-   * Wrapper class for a `std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& / * request * /, const std::optional<std::unordered_map<std::string, std::string>>& / * routeParams * /)>`, this can be used from Swift.
-   */
-  class Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper final {
-  public:
-    explicit Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper(std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>>(std::move(func))) {}
-    inline std::shared_ptr<Promise<RequestConfig>> call(RequestConfig request, std::optional<std::unordered_map<std::string, std::string>> routeParams) const noexcept {
-      auto __result = _function->operator()(request, routeParams);
-      return __result;
-    }
-  private:
-    std::unique_ptr<std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__ create_Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper wrap_Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__(Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__ value) noexcept {
-    return Func_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper(std::move(value));
+  using std__optional_TransformableRequestConfig_ = std::optional<TransformableRequestConfig>;
+  inline std::optional<TransformableRequestConfig> create_std__optional_TransformableRequestConfig_(const TransformableRequestConfig& value) noexcept {
+    return std::optional<TransformableRequestConfig>(value);
+  }
+  inline bool has_value_std__optional_TransformableRequestConfig_(const std::optional<TransformableRequestConfig>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TransformableRequestConfig get_std__optional_TransformableRequestConfig_(const std::optional<TransformableRequestConfig>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>
+  // pragma MARK: std::shared_ptr<Promise<TransformableRequestConfig>>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>`.
+   * Specialized version of `std::shared_ptr<Promise<TransformableRequestConfig>>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_TransformableRequestConfig________ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_TransformableRequestConfig________(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>(value);
+  using std__shared_ptr_Promise_TransformableRequestConfig__ = std::shared_ptr<Promise<TransformableRequestConfig>>;
+  inline std::shared_ptr<Promise<TransformableRequestConfig>> create_std__shared_ptr_Promise_TransformableRequestConfig__() noexcept {
+    return Promise<TransformableRequestConfig>::create();
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_TransformableRequestConfig________(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>& optional) noexcept {
-    return optional.has_value();
+  inline PromiseHolder<TransformableRequestConfig> wrap_std__shared_ptr_Promise_TransformableRequestConfig__(std::shared_ptr<Promise<TransformableRequestConfig>> promise) noexcept {
+    return PromiseHolder<TransformableRequestConfig>(std::move(promise));
   }
-  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_TransformableRequestConfig________(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>& optional) noexcept {
-    return optional.value();
+  
+  // pragma MARK: std::function<void(const TransformableRequestConfig& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const TransformableRequestConfig&)>`.
+   */
+  using Func_void_TransformableRequestConfig = std::function<void(const TransformableRequestConfig& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const TransformableRequestConfig& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_TransformableRequestConfig_Wrapper final {
+  public:
+    explicit Func_void_TransformableRequestConfig_Wrapper(std::function<void(const TransformableRequestConfig& /* result */)>&& func): _function(std::make_unique<std::function<void(const TransformableRequestConfig& /* result */)>>(std::move(func))) {}
+    inline void call(TransformableRequestConfig result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const TransformableRequestConfig& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_TransformableRequestConfig create_Func_void_TransformableRequestConfig(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_TransformableRequestConfig_Wrapper wrap_Func_void_TransformableRequestConfig(Func_void_TransformableRequestConfig value) noexcept {
+    return Func_void_TransformableRequestConfig_Wrapper(std::move(value));
   }
   
   // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>
@@ -996,67 +1123,18 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_void_std__shared_ptr_Promise_TransformableRequestConfig___Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<TransformableRequestConfig>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<TransformableRequestConfig>>`.
-   */
-  using std__shared_ptr_Promise_TransformableRequestConfig__ = std::shared_ptr<Promise<TransformableRequestConfig>>;
-  inline std::shared_ptr<Promise<TransformableRequestConfig>> create_std__shared_ptr_Promise_TransformableRequestConfig__() noexcept {
-    return Promise<TransformableRequestConfig>::create();
-  }
-  inline PromiseHolder<TransformableRequestConfig> wrap_std__shared_ptr_Promise_TransformableRequestConfig__(std::shared_ptr<Promise<TransformableRequestConfig>> promise) noexcept {
-    return PromiseHolder<TransformableRequestConfig>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const TransformableRequestConfig& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const TransformableRequestConfig&)>`.
-   */
-  using Func_void_TransformableRequestConfig = std::function<void(const TransformableRequestConfig& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const TransformableRequestConfig& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_TransformableRequestConfig_Wrapper final {
-  public:
-    explicit Func_void_TransformableRequestConfig_Wrapper(std::function<void(const TransformableRequestConfig& /* result */)>&& func): _function(std::make_unique<std::function<void(const TransformableRequestConfig& /* result */)>>(std::move(func))) {}
-    inline void call(TransformableRequestConfig result) const noexcept {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const TransformableRequestConfig& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_TransformableRequestConfig create_Func_void_TransformableRequestConfig(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_TransformableRequestConfig_Wrapper wrap_Func_void_TransformableRequestConfig(Func_void_TransformableRequestConfig value) noexcept {
-    return Func_void_TransformableRequestConfig_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::optional<MediaRequestConfig>
-  /**
-   * Specialized version of `std::optional<MediaRequestConfig>`.
-   */
-  using std__optional_MediaRequestConfig_ = std::optional<MediaRequestConfig>;
-  inline std::optional<MediaRequestConfig> create_std__optional_MediaRequestConfig_(const MediaRequestConfig& value) noexcept {
-    return std::optional<MediaRequestConfig>(value);
-  }
-  inline bool has_value_std__optional_MediaRequestConfig_(const std::optional<MediaRequestConfig>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline MediaRequestConfig get_std__optional_MediaRequestConfig_(const std::optional<MediaRequestConfig>& optional) noexcept {
-    return optional.value();
-  }
-  
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& / * track * /)>>`.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_Track_____track______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_Track_____track______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>(value);
+  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_TransformableRequestConfig________ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_TransformableRequestConfig________(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>(value);
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>& optional) noexcept {
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_TransformableRequestConfig________(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>& optional) noexcept {
+  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_TransformableRequestConfig________(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<TransformableRequestConfig>>>>()>>& optional) noexcept {
     return optional.value();
   }
   
@@ -1083,18 +1161,18 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& / * track * /)>>`.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& / * track * /)>>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_Track_____track______ = std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>> create_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_Track_____track______(const std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>>(value);
+  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_Track_____track______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_Track_____track______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>(value);
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>>& optional) noexcept {
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)> get_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>>& optional) noexcept {
+  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>& optional) noexcept {
     return optional.value();
   }
   
@@ -1121,33 +1199,48 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_std__shared_ptr_Promise_RequestConfig___Track_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<ArtworkRequestConfig>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>>
   /**
-   * Specialized version of `std::optional<ArtworkRequestConfig>`.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& / * track * /)>>`.
    */
-  using std__optional_ArtworkRequestConfig_ = std::optional<ArtworkRequestConfig>;
-  inline std::optional<ArtworkRequestConfig> create_std__optional_ArtworkRequestConfig_(const ArtworkRequestConfig& value) noexcept {
-    return std::optional<ArtworkRequestConfig>(value);
+  using std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_Track_____track______ = std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>> create_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_Track_____track______(const std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>>(value);
   }
-  inline bool has_value_std__optional_ArtworkRequestConfig_(const std::optional<ArtworkRequestConfig>& optional) noexcept {
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>>& optional) noexcept {
     return optional.has_value();
   }
-  inline ArtworkRequestConfig get_std__optional_ArtworkRequestConfig_(const std::optional<ArtworkRequestConfig>& optional) noexcept {
+  inline std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)> get_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)>>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>
+  // pragma MARK: std::optional<MediaRequestConfig>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& / * params * /)>>`.
+   * Specialized version of `std::optional<MediaRequestConfig>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_MediaTransformParams_____params______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_MediaTransformParams_____params______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>(value);
+  using std__optional_MediaRequestConfig_ = std::optional<MediaRequestConfig>;
+  inline std::optional<MediaRequestConfig> create_std__optional_MediaRequestConfig_(const MediaRequestConfig& value) noexcept {
+    return std::optional<MediaRequestConfig>(value);
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_MediaTransformParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>& optional) noexcept {
+  inline bool has_value_std__optional_MediaRequestConfig_(const std::optional<MediaRequestConfig>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_MediaTransformParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>& optional) noexcept {
+  inline MediaRequestConfig get_std__optional_MediaRequestConfig_(const std::optional<MediaRequestConfig>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<ImageContext>
+  /**
+   * Specialized version of `std::optional<ImageContext>`.
+   */
+  using std__optional_ImageContext_ = std::optional<ImageContext>;
+  inline std::optional<ImageContext> create_std__optional_ImageContext_(const ImageContext& value) noexcept {
+    return std::optional<ImageContext>(value);
+  }
+  inline bool has_value_std__optional_ImageContext_(const std::optional<ImageContext>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ImageContext get_std__optional_ImageContext_(const std::optional<ImageContext>& optional) noexcept {
     return optional.value();
   }
   
@@ -1174,33 +1267,18 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____MediaTransformParams_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<ImageContext>
-  /**
-   * Specialized version of `std::optional<ImageContext>`.
-   */
-  using std__optional_ImageContext_ = std::optional<ImageContext>;
-  inline std::optional<ImageContext> create_std__optional_ImageContext_(const ImageContext& value) noexcept {
-    return std::optional<ImageContext>(value);
-  }
-  inline bool has_value_std__optional_ImageContext_(const std::optional<ImageContext>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline ImageContext get_std__optional_ImageContext_(const std::optional<ImageContext>& optional) noexcept {
-    return optional.value();
-  }
-  
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& / * params * /)>>`.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& / * params * /)>>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_MediaTransformParams_____params______ = std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>> create_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_MediaTransformParams_____params______(const std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>>(value);
+  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_MediaTransformParams_____params______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_MediaTransformParams_____params______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>(value);
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_MediaTransformParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>>& optional) noexcept {
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_MediaTransformParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)> get_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_MediaTransformParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>>& optional) noexcept {
+  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____const_MediaTransformParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>& optional) noexcept {
     return optional.value();
   }
   
@@ -1227,117 +1305,112 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_std__shared_ptr_Promise_RequestConfig___MediaTransformParams_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<ImageQueryParams>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>>
   /**
-   * Specialized version of `std::optional<ImageQueryParams>`.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& / * params * /)>>`.
    */
-  using std__optional_ImageQueryParams_ = std::optional<ImageQueryParams>;
-  inline std::optional<ImageQueryParams> create_std__optional_ImageQueryParams_(const ImageQueryParams& value) noexcept {
-    return std::optional<ImageQueryParams>(value);
+  using std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_MediaTransformParams_____params______ = std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>> create_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_MediaTransformParams_____params______(const std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>>(value);
   }
-  inline bool has_value_std__optional_ImageQueryParams_(const std::optional<ImageQueryParams>& optional) noexcept {
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_MediaTransformParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>>& optional) noexcept {
     return optional.has_value();
   }
-  inline ImageQueryParams get_std__optional_ImageQueryParams_(const std::optional<ImageQueryParams>& optional) noexcept {
+  inline std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)> get_std__optional_std__function_std__shared_ptr_Promise_RequestConfig___const_MediaTransformParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<RequestConfig>>(const MediaTransformParams& /* params */)>>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::vector<NativeRouteEntry>>
+  // pragma MARK: std::optional<ImageQueryParams>
   /**
-   * Specialized version of `std::optional<std::vector<NativeRouteEntry>>`.
+   * Specialized version of `std::optional<ImageQueryParams>`.
    */
-  using std__optional_std__vector_NativeRouteEntry__ = std::optional<std::vector<NativeRouteEntry>>;
-  inline std::optional<std::vector<NativeRouteEntry>> create_std__optional_std__vector_NativeRouteEntry__(const std::vector<NativeRouteEntry>& value) noexcept {
-    return std::optional<std::vector<NativeRouteEntry>>(value);
+  using std__optional_ImageQueryParams_ = std::optional<ImageQueryParams>;
+  inline std::optional<ImageQueryParams> create_std__optional_ImageQueryParams_(const ImageQueryParams& value) noexcept {
+    return std::optional<ImageQueryParams>(value);
   }
-  inline bool has_value_std__optional_std__vector_NativeRouteEntry__(const std::optional<std::vector<NativeRouteEntry>>& optional) noexcept {
+  inline bool has_value_std__optional_ImageQueryParams_(const std::optional<ImageQueryParams>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::vector<NativeRouteEntry> get_std__optional_std__vector_NativeRouteEntry__(const std::optional<std::vector<NativeRouteEntry>>& optional) noexcept {
+  inline ImageQueryParams get_std__optional_ImageQueryParams_(const std::optional<ImageQueryParams>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::vector<NativeRouteEntry>
-  /**
-   * Specialized version of `std::vector<NativeRouteEntry>`.
-   */
-  using std__vector_NativeRouteEntry_ = std::vector<NativeRouteEntry>;
-  inline std::vector<NativeRouteEntry> create_std__vector_NativeRouteEntry_(size_t size) noexcept {
-    std::vector<NativeRouteEntry> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>
+  // pragma MARK: std::optional<ArtworkRequestConfig>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& / * param * /)>>`.
+   * Specialized version of `std::optional<ArtworkRequestConfig>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______const_BrowserSourceCallbackParam_____param______ = std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______const_BrowserSourceCallbackParam_____param______(const std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>(value);
+  using std__optional_ArtworkRequestConfig_ = std::optional<ArtworkRequestConfig>;
+  inline std::optional<ArtworkRequestConfig> create_std__optional_ArtworkRequestConfig_(const ArtworkRequestConfig& value) noexcept {
+    return std::optional<ArtworkRequestConfig>(value);
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______const_BrowserSourceCallbackParam_____param______(const std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>& optional) noexcept {
+  inline bool has_value_std__optional_ArtworkRequestConfig_(const std::optional<ArtworkRequestConfig>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)> get_std__optional_std__function_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______const_BrowserSourceCallbackParam_____param______(const std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>& optional) noexcept {
+  inline ArtworkRequestConfig get_std__optional_ArtworkRequestConfig_(const std::optional<ArtworkRequestConfig>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>
-  /**
-   * Specialized version of `std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam&)>`.
-   */
-  using Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam = std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>;
+  // pragma MARK: std::variant<ResolvedTrack, BrowseError>
   /**
-   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& / * param * /)>`, this can be used from Swift.
+   * Wrapper struct for `std::variant<ResolvedTrack, BrowseError>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
    */
-  class Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam_Wrapper final {
-  public:
-    explicit Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam_Wrapper(std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>(std::move(func))) {}
-    inline std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>> call(BrowserSourceCallbackParam param) const noexcept {
-      auto __result = _function->operator()(param);
-      return __result;
+  struct std__variant_ResolvedTrack__BrowseError_ final {
+    std::variant<ResolvedTrack, BrowseError> variant;
+    std__variant_ResolvedTrack__BrowseError_(std::variant<ResolvedTrack, BrowseError> variant): variant(variant) { }
+    operator std::variant<ResolvedTrack, BrowseError>() const noexcept {
+      return variant;
     }
-  private:
-    std::unique_ptr<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam create_Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam_Wrapper wrap_Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam(Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam value) noexcept {
-    return Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam_Wrapper(std::move(value));
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline ResolvedTrack get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline BrowseError get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_ResolvedTrack__BrowseError_ create_std__variant_ResolvedTrack__BrowseError_(const ResolvedTrack& value) noexcept {
+    return std__variant_ResolvedTrack__BrowseError_(value);
+  }
+  inline std__variant_ResolvedTrack__BrowseError_ create_std__variant_ResolvedTrack__BrowseError_(const BrowseError& value) noexcept {
+    return std__variant_ResolvedTrack__BrowseError_(value);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>
+  // pragma MARK: std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>`.
    */
-  using std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______ = std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>;
-  inline std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>> create_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______() noexcept {
-    return Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>::create();
+  using std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___ = std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>;
+  inline std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>> create_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___() noexcept {
+    return Promise<std::variant<ResolvedTrack, BrowseError>>::create();
   }
-  inline PromiseHolder<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>> wrap_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______(std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>> promise) noexcept {
-    return PromiseHolder<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(std::move(promise));
+  inline PromiseHolder<std::variant<ResolvedTrack, BrowseError>> wrap_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___(std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>> promise) noexcept {
+    return PromiseHolder<std::variant<ResolvedTrack, BrowseError>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<ResolvedTrack, BrowseError>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>&)>`.
+   * Specialized version of `std::function<void(const std::variant<ResolvedTrack, BrowseError>&)>`.
    */
-  using Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____ = std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& /* result */)>;
+  using Func_void_std__variant_ResolvedTrack__BrowseError_ = std::function<void(const std::variant<ResolvedTrack, BrowseError>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<ResolvedTrack, BrowseError>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____Wrapper final {
+  class Func_void_std__variant_ResolvedTrack__BrowseError__Wrapper final {
   public:
-    explicit Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____Wrapper(std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& /* result */)>>(std::move(func))) {}
-    inline void call(std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>> result) const noexcept {
+    explicit Func_void_std__variant_ResolvedTrack__BrowseError__Wrapper(std::function<void(const std::variant<ResolvedTrack, BrowseError>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<ResolvedTrack, BrowseError>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<ResolvedTrack, BrowseError> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::variant<ResolvedTrack, BrowseError>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____ create_Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____Wrapper wrap_Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____(Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____ value) noexcept {
-    return Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____Wrapper(std::move(value));
+  Func_void_std__variant_ResolvedTrack__BrowseError_ create_Func_void_std__variant_ResolvedTrack__BrowseError_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_ResolvedTrack__BrowseError__Wrapper wrap_Func_void_std__variant_ResolvedTrack__BrowseError_(Func_void_std__variant_ResolvedTrack__BrowseError_ value) noexcept {
+    return Func_void_std__variant_ResolvedTrack__BrowseError__Wrapper(std::move(value));
   }
   
   // pragma MARK: std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>
@@ -1375,81 +1448,90 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____(value);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>`.
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam&)>`.
    */
-  using std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___ = std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>;
-  inline std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>> create_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___() noexcept {
-    return Promise<std::variant<ResolvedTrack, BrowseError>>::create();
+  using Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam = std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& / * param * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam_Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam_Wrapper(std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>> call(BrowserSourceCallbackParam param) const noexcept {
+      auto __result = _function->operator()(param);
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam create_Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam_Wrapper wrap_Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam(Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam value) noexcept {
+    return Func_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______BrowserSourceCallbackParam_Wrapper(std::move(value));
   }
-  inline PromiseHolder<std::variant<ResolvedTrack, BrowseError>> wrap_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___(std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>> promise) noexcept {
-    return PromiseHolder<std::variant<ResolvedTrack, BrowseError>>(std::move(promise));
+  
+  // pragma MARK: std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>`.
+   */
+  using std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______ = std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>;
+  inline std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>> create_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______() noexcept {
+    return Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>::create();
+  }
+  inline PromiseHolder<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>> wrap_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______(std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>> promise) noexcept {
+    return PromiseHolder<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::variant<ResolvedTrack, BrowseError>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::variant<ResolvedTrack, BrowseError>&)>`.
+   * Specialized version of `std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>&)>`.
    */
-  using Func_void_std__variant_ResolvedTrack__BrowseError_ = std::function<void(const std::variant<ResolvedTrack, BrowseError>& /* result */)>;
+  using Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____ = std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::variant<ResolvedTrack, BrowseError>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__variant_ResolvedTrack__BrowseError__Wrapper final {
+  class Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____Wrapper final {
   public:
-    explicit Func_void_std__variant_ResolvedTrack__BrowseError__Wrapper(std::function<void(const std::variant<ResolvedTrack, BrowseError>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<ResolvedTrack, BrowseError>& /* result */)>>(std::move(func))) {}
-    inline void call(std::variant<ResolvedTrack, BrowseError> result) const noexcept {
+    explicit Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____Wrapper(std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::unique_ptr<std::function<void(const std::variant<ResolvedTrack, BrowseError>& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__variant_ResolvedTrack__BrowseError_ create_Func_void_std__variant_ResolvedTrack__BrowseError_(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__variant_ResolvedTrack__BrowseError__Wrapper wrap_Func_void_std__variant_ResolvedTrack__BrowseError_(Func_void_std__variant_ResolvedTrack__BrowseError_ value) noexcept {
-    return Func_void_std__variant_ResolvedTrack__BrowseError__Wrapper(std::move(value));
+  Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____ create_Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____Wrapper wrap_Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____(Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____ value) noexcept {
+    return Func_void_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::variant<ResolvedTrack, BrowseError>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>
   /**
-   * Wrapper struct for `std::variant<ResolvedTrack, BrowseError>`.
-   * std::variant cannot be used in Swift because of a Swift bug.
-   * Not even specializing it works. So we create a wrapper struct.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& / * param * /)>>`.
    */
-  struct std__variant_ResolvedTrack__BrowseError_ final {
-    std::variant<ResolvedTrack, BrowseError> variant;
-    std__variant_ResolvedTrack__BrowseError_(std::variant<ResolvedTrack, BrowseError> variant): variant(variant) { }
-    operator std::variant<ResolvedTrack, BrowseError>() const noexcept {
-      return variant;
-    }
-    inline size_t index() const noexcept {
-      return variant.index();
-    }
-    inline ResolvedTrack get_0() const noexcept {
-      return std::get<0>(variant);
-    }
-    inline BrowseError get_1() const noexcept {
-      return std::get<1>(variant);
-    }
-  };
-  inline std__variant_ResolvedTrack__BrowseError_ create_std__variant_ResolvedTrack__BrowseError_(const ResolvedTrack& value) noexcept {
-    return std__variant_ResolvedTrack__BrowseError_(value);
+  using std__optional_std__function_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______const_BrowserSourceCallbackParam_____param______ = std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______const_BrowserSourceCallbackParam_____param______(const std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>(value);
   }
-  inline std__variant_ResolvedTrack__BrowseError_ create_std__variant_ResolvedTrack__BrowseError_(const BrowseError& value) noexcept {
-    return std__variant_ResolvedTrack__BrowseError_(value);
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______const_BrowserSourceCallbackParam_____param______(const std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)> get_std__optional_std__function_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError__std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_______const_BrowserSourceCallbackParam_____param______(const std::optional<std::function<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError, std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>>(const BrowserSourceCallbackParam& /* param */)>>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>
+  // pragma MARK: std::optional<SearchMode>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& / * params * /)>>`.
+   * Specialized version of `std::optional<SearchMode>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______const_SearchParams_____params______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______const_SearchParams_____params______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>(value);
+  using std__optional_SearchMode_ = std::optional<SearchMode>;
+  inline std::optional<SearchMode> create_std__optional_SearchMode_(const SearchMode& value) noexcept {
+    return std::optional<SearchMode>(value);
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______const_SearchParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>& optional) noexcept {
+  inline bool has_value_std__optional_SearchMode_(const std::optional<SearchMode>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______const_SearchParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>& optional) noexcept {
+  inline SearchMode get_std__optional_SearchMode_(const std::optional<SearchMode>& optional) noexcept {
     return optional.value();
   }
   
@@ -1510,36 +1592,81 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_void_std__shared_ptr_Promise_std__vector_Track____Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<SearchMode>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>
   /**
-   * Specialized version of `std::optional<SearchMode>`.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& / * params * /)>>`.
    */
-  using std__optional_SearchMode_ = std::optional<SearchMode>;
-  inline std::optional<SearchMode> create_std__optional_SearchMode_(const SearchMode& value) noexcept {
-    return std::optional<SearchMode>(value);
+  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______const_SearchParams_____params______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______const_SearchParams_____params______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>(value);
   }
-  inline bool has_value_std__optional_SearchMode_(const std::optional<SearchMode>& optional) noexcept {
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______const_SearchParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>& optional) noexcept {
     return optional.has_value();
   }
-  inline SearchMode get_std__optional_SearchMode_(const std::optional<SearchMode>& optional) noexcept {
+  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______const_SearchParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>>
+  // pragma MARK: std::vector<NativeRouteEntry>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& / * event * /)>>`.
+   * Specialized version of `std::vector<NativeRouteEntry>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_void_____const_TrackLoadEvent_____event______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_void_____const_TrackLoadEvent_____event______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>>(value);
+  using std__vector_NativeRouteEntry_ = std::vector<NativeRouteEntry>;
+  inline std::vector<NativeRouteEntry> create_std__vector_NativeRouteEntry_(size_t size) noexcept {
+    std::vector<NativeRouteEntry> vector;
+    vector.reserve(size);
+    return vector;
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_void_____const_TrackLoadEvent_____event______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>>& optional) noexcept {
+  
+  // pragma MARK: std::optional<std::vector<NativeRouteEntry>>
+  /**
+   * Specialized version of `std::optional<std::vector<NativeRouteEntry>>`.
+   */
+  using std__optional_std__vector_NativeRouteEntry__ = std::optional<std::vector<NativeRouteEntry>>;
+  inline std::optional<std::vector<NativeRouteEntry>> create_std__optional_std__vector_NativeRouteEntry__(const std::vector<NativeRouteEntry>& value) noexcept {
+    return std::optional<std::vector<NativeRouteEntry>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_NativeRouteEntry__(const std::optional<std::vector<NativeRouteEntry>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_void_____const_TrackLoadEvent_____event______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>>& optional) noexcept {
+  inline std::vector<NativeRouteEntry> get_std__optional_std__vector_NativeRouteEntry__(const std::optional<std::vector<NativeRouteEntry>>& optional) noexcept {
     return optional.value();
   }
   
+  // pragma MARK: std::shared_ptr<Promise<void>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   */
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
+    return Promise<void>::create();
+  }
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
+    }
+  private:
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>
   /**
    * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent&)>`.
@@ -1597,52 +1724,68 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_void_std__shared_ptr_Promise_void___Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<void>>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& / * event * /)>>`.
    */
-  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
-  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
-    return Promise<void>::create();
+  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_void_____const_TrackLoadEvent_____event______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_void_____const_TrackLoadEvent_____event______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>>(value);
   }
-  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
-    return PromiseHolder<void>(std::move(promise));
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_void_____const_TrackLoadEvent_____event______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_void_____const_TrackLoadEvent_____event______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<void>>>>(const TrackLoadEvent& /* event */)>>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::function<void()>
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::string>>()>
   /**
-   * Specialized version of `std::function<void()>`.
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::string>>()>`.
    */
-  using Func_void = std::function<void()>;
+  using Func_std__shared_ptr_Promise_std__string__ = std::function<std::shared_ptr<Promise<std::string>>()>;
   /**
-   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::string>>()>`, this can be used from Swift.
    */
-  class Func_void_Wrapper final {
+  class Func_std__shared_ptr_Promise_std__string___Wrapper final {
   public:
-    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
-    inline void call() const noexcept {
-      _function->operator()();
+    explicit Func_std__shared_ptr_Promise_std__string___Wrapper(std::function<std::shared_ptr<Promise<std::string>>()>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::string>>()>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::string>> call() const noexcept {
+      auto __result = _function->operator()();
+      return __result;
     }
   private:
-    std::unique_ptr<std::function<void()>> _function;
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::string>>()>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
-    return Func_void_Wrapper(std::move(value));
+  Func_std__shared_ptr_Promise_std__string__ create_Func_std__shared_ptr_Promise_std__string__(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__string___Wrapper wrap_Func_std__shared_ptr_Promise_std__string__(Func_std__shared_ptr_Promise_std__string__ value) noexcept {
+    return Func_std__shared_ptr_Promise_std__string___Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>>
+  // pragma MARK: std::shared_ptr<Promise<std::string>>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& / * track * /)>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_std__optional_std__string____const_Track_____track______ = std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__optional_std__string____const_Track_____track______(const std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>>(value);
+  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
+  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() noexcept {
+    return Promise<std::string>::create();
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__optional_std__string____const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>>& optional) noexcept {
+  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) noexcept {
+    return PromiseHolder<std::string>(std::move(promise));
+  }
+  
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::string>>()>>
+  /**
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::string>>()>>`.
+   */
+  using std__optional_std__function_std__shared_ptr_Promise_std__string______ = std::optional<std::function<std::shared_ptr<Promise<std::string>>()>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::string>>()>> create_std__optional_std__function_std__shared_ptr_Promise_std__string______(const std::function<std::shared_ptr<Promise<std::string>>()>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::string>>()>>(value);
+  }
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__string______(const std::optional<std::function<std::shared_ptr<Promise<std::string>>()>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)> get_std__optional_std__function_std__shared_ptr_Promise_std__optional_std__string____const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>>& optional) noexcept {
+  inline std::function<std::shared_ptr<Promise<std::string>>()> get_std__optional_std__function_std__shared_ptr_Promise_std__string______(const std::optional<std::function<std::shared_ptr<Promise<std::string>>()>>& optional) noexcept {
     return optional.value();
   }
   
@@ -1703,18 +1846,18 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_void_std__optional_std__string__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& / * params * /)>>`.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& / * track * /)>>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_std__optional_FormattedNavigationError____const_FormatNavigationErrorParams_____params______ = std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__optional_FormattedNavigationError____const_FormatNavigationErrorParams_____params______(const std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>(value);
+  using std__optional_std__function_std__shared_ptr_Promise_std__optional_std__string____const_Track_____track______ = std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__optional_std__string____const_Track_____track______(const std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>>(value);
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__optional_FormattedNavigationError____const_FormatNavigationErrorParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>& optional) noexcept {
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__optional_std__string____const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)> get_std__optional_std__function_std__shared_ptr_Promise_std__optional_FormattedNavigationError____const_FormatNavigationErrorParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>& optional) noexcept {
+  inline std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)> get_std__optional_std__function_std__shared_ptr_Promise_std__optional_std__string____const_Track_____track______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& /* track */)>>& optional) noexcept {
     return optional.value();
   }
   
@@ -1753,6 +1896,21 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return PromiseHolder<std::optional<FormattedNavigationError>>(std::move(promise));
   }
   
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>
+  /**
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& / * params * /)>>`.
+   */
+  using std__optional_std__function_std__shared_ptr_Promise_std__optional_FormattedNavigationError____const_FormatNavigationErrorParams_____params______ = std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__optional_FormattedNavigationError____const_FormatNavigationErrorParams_____params______(const std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__optional_FormattedNavigationError____const_FormatNavigationErrorParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)> get_std__optional_std__function_std__shared_ptr_Promise_std__optional_FormattedNavigationError____const_FormatNavigationErrorParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<Gate>
   /**
    * Specialized version of `std::optional<Gate>`.
@@ -1918,36 +2076,6 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_void_bool_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<NativeAndroidSetupOptions>
-  /**
-   * Specialized version of `std::optional<NativeAndroidSetupOptions>`.
-   */
-  using std__optional_NativeAndroidSetupOptions_ = std::optional<NativeAndroidSetupOptions>;
-  inline std::optional<NativeAndroidSetupOptions> create_std__optional_NativeAndroidSetupOptions_(const NativeAndroidSetupOptions& value) noexcept {
-    return std::optional<NativeAndroidSetupOptions>(value);
-  }
-  inline bool has_value_std__optional_NativeAndroidSetupOptions_(const std::optional<NativeAndroidSetupOptions>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline NativeAndroidSetupOptions get_std__optional_NativeAndroidSetupOptions_(const std::optional<NativeAndroidSetupOptions>& optional) noexcept {
-    return optional.value();
-  }
-  
-  // pragma MARK: std::optional<std::variant<bool, AndroidAudioOffloadSettings>>
-  /**
-   * Specialized version of `std::optional<std::variant<bool, AndroidAudioOffloadSettings>>`.
-   */
-  using std__optional_std__variant_bool__AndroidAudioOffloadSettings__ = std::optional<std::variant<bool, AndroidAudioOffloadSettings>>;
-  inline std::optional<std::variant<bool, AndroidAudioOffloadSettings>> create_std__optional_std__variant_bool__AndroidAudioOffloadSettings__(const std::variant<bool, AndroidAudioOffloadSettings>& value) noexcept {
-    return std::optional<std::variant<bool, AndroidAudioOffloadSettings>>(value);
-  }
-  inline bool has_value_std__optional_std__variant_bool__AndroidAudioOffloadSettings__(const std::optional<std::variant<bool, AndroidAudioOffloadSettings>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::variant<bool, AndroidAudioOffloadSettings> get_std__optional_std__variant_bool__AndroidAudioOffloadSettings__(const std::optional<std::variant<bool, AndroidAudioOffloadSettings>>& optional) noexcept {
-    return optional.value();
-  }
-  
   // pragma MARK: std::variant<bool, AndroidAudioOffloadSettings>
   /**
    * Wrapper struct for `std::variant<bool, AndroidAudioOffloadSettings>`.
@@ -1977,18 +2105,18 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return std__variant_bool__AndroidAudioOffloadSettings_(value);
   }
   
-  // pragma MARK: std::optional<std::variant<nitro::NullType, double>>
+  // pragma MARK: std::optional<std::variant<bool, AndroidAudioOffloadSettings>>
   /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, double>>`.
+   * Specialized version of `std::optional<std::variant<bool, AndroidAudioOffloadSettings>>`.
    */
-  using std__optional_std__variant_nitro__NullType__double__ = std::optional<std::variant<nitro::NullType, double>>;
-  inline std::optional<std::variant<nitro::NullType, double>> create_std__optional_std__variant_nitro__NullType__double__(const std::variant<nitro::NullType, double>& value) noexcept {
-    return std::optional<std::variant<nitro::NullType, double>>(value);
+  using std__optional_std__variant_bool__AndroidAudioOffloadSettings__ = std::optional<std::variant<bool, AndroidAudioOffloadSettings>>;
+  inline std::optional<std::variant<bool, AndroidAudioOffloadSettings>> create_std__optional_std__variant_bool__AndroidAudioOffloadSettings__(const std::variant<bool, AndroidAudioOffloadSettings>& value) noexcept {
+    return std::optional<std::variant<bool, AndroidAudioOffloadSettings>>(value);
   }
-  inline bool has_value_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_bool__AndroidAudioOffloadSettings__(const std::optional<std::variant<bool, AndroidAudioOffloadSettings>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::variant<nitro::NullType, double> get_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+  inline std::variant<bool, AndroidAudioOffloadSettings> get_std__optional_std__variant_bool__AndroidAudioOffloadSettings__(const std::optional<std::variant<bool, AndroidAudioOffloadSettings>>& optional) noexcept {
     return optional.value();
   }
   
@@ -2021,6 +2149,21 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return std__variant_nitro__NullType__double_(value);
   }
   
+  // pragma MARK: std::optional<std::variant<nitro::NullType, double>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, double>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__double__ = std::optional<std::variant<nitro::NullType, double>>;
+  inline std::optional<std::variant<nitro::NullType, double>> create_std__optional_std__variant_nitro__NullType__double__(const std::variant<nitro::NullType, double>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, double>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, double> get_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<AndroidAudioContentType>
   /**
    * Specialized version of `std::optional<AndroidAudioContentType>`.
@@ -2051,18 +2194,18 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<NativeIOSSetupOptions>
+  // pragma MARK: std::optional<NativeAndroidSetupOptions>
   /**
-   * Specialized version of `std::optional<NativeIOSSetupOptions>`.
+   * Specialized version of `std::optional<NativeAndroidSetupOptions>`.
    */
-  using std__optional_NativeIOSSetupOptions_ = std::optional<NativeIOSSetupOptions>;
-  inline std::optional<NativeIOSSetupOptions> create_std__optional_NativeIOSSetupOptions_(const NativeIOSSetupOptions& value) noexcept {
-    return std::optional<NativeIOSSetupOptions>(value);
+  using std__optional_NativeAndroidSetupOptions_ = std::optional<NativeAndroidSetupOptions>;
+  inline std::optional<NativeAndroidSetupOptions> create_std__optional_NativeAndroidSetupOptions_(const NativeAndroidSetupOptions& value) noexcept {
+    return std::optional<NativeAndroidSetupOptions>(value);
   }
-  inline bool has_value_std__optional_NativeIOSSetupOptions_(const std::optional<NativeIOSSetupOptions>& optional) noexcept {
+  inline bool has_value_std__optional_NativeAndroidSetupOptions_(const std::optional<NativeAndroidSetupOptions>& optional) noexcept {
     return optional.has_value();
   }
-  inline NativeIOSSetupOptions get_std__optional_NativeIOSSetupOptions_(const std::optional<NativeIOSSetupOptions>& optional) noexcept {
+  inline NativeAndroidSetupOptions get_std__optional_NativeAndroidSetupOptions_(const std::optional<NativeAndroidSetupOptions>& optional) noexcept {
     return optional.value();
   }
   
@@ -2096,21 +2239,6 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::vector<IOSCategoryOptions>>
-  /**
-   * Specialized version of `std::optional<std::vector<IOSCategoryOptions>>`.
-   */
-  using std__optional_std__vector_IOSCategoryOptions__ = std::optional<std::vector<IOSCategoryOptions>>;
-  inline std::optional<std::vector<IOSCategoryOptions>> create_std__optional_std__vector_IOSCategoryOptions__(const std::vector<IOSCategoryOptions>& value) noexcept {
-    return std::optional<std::vector<IOSCategoryOptions>>(value);
-  }
-  inline bool has_value_std__optional_std__vector_IOSCategoryOptions__(const std::optional<std::vector<IOSCategoryOptions>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::vector<IOSCategoryOptions> get_std__optional_std__vector_IOSCategoryOptions__(const std::optional<std::vector<IOSCategoryOptions>>& optional) noexcept {
-    return optional.value();
-  }
-  
   // pragma MARK: std::vector<IOSCategoryOptions>
   /**
    * Specialized version of `std::vector<IOSCategoryOptions>`.
@@ -2122,48 +2250,48 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<IOSCategoryPolicy>
+  // pragma MARK: std::optional<std::vector<IOSCategoryOptions>>
   /**
-   * Specialized version of `std::optional<IOSCategoryPolicy>`.
+   * Specialized version of `std::optional<std::vector<IOSCategoryOptions>>`.
    */
-  using std__optional_IOSCategoryPolicy_ = std::optional<IOSCategoryPolicy>;
-  inline std::optional<IOSCategoryPolicy> create_std__optional_IOSCategoryPolicy_(const IOSCategoryPolicy& value) noexcept {
-    return std::optional<IOSCategoryPolicy>(value);
+  using std__optional_std__vector_IOSCategoryOptions__ = std::optional<std::vector<IOSCategoryOptions>>;
+  inline std::optional<std::vector<IOSCategoryOptions>> create_std__optional_std__vector_IOSCategoryOptions__(const std::vector<IOSCategoryOptions>& value) noexcept {
+    return std::optional<std::vector<IOSCategoryOptions>>(value);
   }
-  inline bool has_value_std__optional_IOSCategoryPolicy_(const std::optional<IOSCategoryPolicy>& optional) noexcept {
+  inline bool has_value_std__optional_std__vector_IOSCategoryOptions__(const std::optional<std::vector<IOSCategoryOptions>>& optional) noexcept {
     return optional.has_value();
   }
-  inline IOSCategoryPolicy get_std__optional_IOSCategoryPolicy_(const std::optional<IOSCategoryPolicy>& optional) noexcept {
+  inline std::vector<IOSCategoryOptions> get_std__optional_std__vector_IOSCategoryOptions__(const std::optional<std::vector<IOSCategoryOptions>>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<NativeUpdateOptions>
+  // pragma MARK: std::optional<IOSCategoryPolicy>
   /**
-   * Specialized version of `std::optional<NativeUpdateOptions>`.
+   * Specialized version of `std::optional<IOSCategoryPolicy>`.
    */
-  using std__optional_NativeUpdateOptions_ = std::optional<NativeUpdateOptions>;
-  inline std::optional<NativeUpdateOptions> create_std__optional_NativeUpdateOptions_(const NativeUpdateOptions& value) noexcept {
-    return std::optional<NativeUpdateOptions>(value);
+  using std__optional_IOSCategoryPolicy_ = std::optional<IOSCategoryPolicy>;
+  inline std::optional<IOSCategoryPolicy> create_std__optional_IOSCategoryPolicy_(const IOSCategoryPolicy& value) noexcept {
+    return std::optional<IOSCategoryPolicy>(value);
   }
-  inline bool has_value_std__optional_NativeUpdateOptions_(const std::optional<NativeUpdateOptions>& optional) noexcept {
+  inline bool has_value_std__optional_IOSCategoryPolicy_(const std::optional<IOSCategoryPolicy>& optional) noexcept {
     return optional.has_value();
   }
-  inline NativeUpdateOptions get_std__optional_NativeUpdateOptions_(const std::optional<NativeUpdateOptions>& optional) noexcept {
+  inline IOSCategoryPolicy get_std__optional_IOSCategoryPolicy_(const std::optional<IOSCategoryPolicy>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<NitroAndroidUpdateOptions>
+  // pragma MARK: std::optional<NativeIOSSetupOptions>
   /**
-   * Specialized version of `std::optional<NitroAndroidUpdateOptions>`.
+   * Specialized version of `std::optional<NativeIOSSetupOptions>`.
    */
-  using std__optional_NitroAndroidUpdateOptions_ = std::optional<NitroAndroidUpdateOptions>;
-  inline std::optional<NitroAndroidUpdateOptions> create_std__optional_NitroAndroidUpdateOptions_(const NitroAndroidUpdateOptions& value) noexcept {
-    return std::optional<NitroAndroidUpdateOptions>(value);
+  using std__optional_NativeIOSSetupOptions_ = std::optional<NativeIOSSetupOptions>;
+  inline std::optional<NativeIOSSetupOptions> create_std__optional_NativeIOSSetupOptions_(const NativeIOSSetupOptions& value) noexcept {
+    return std::optional<NativeIOSSetupOptions>(value);
   }
-  inline bool has_value_std__optional_NitroAndroidUpdateOptions_(const std::optional<NitroAndroidUpdateOptions>& optional) noexcept {
+  inline bool has_value_std__optional_NativeIOSSetupOptions_(const std::optional<NativeIOSSetupOptions>& optional) noexcept {
     return optional.has_value();
   }
-  inline NitroAndroidUpdateOptions get_std__optional_NitroAndroidUpdateOptions_(const std::optional<NitroAndroidUpdateOptions>& optional) noexcept {
+  inline NativeIOSSetupOptions get_std__optional_NativeIOSSetupOptions_(const std::optional<NativeIOSSetupOptions>& optional) noexcept {
     return optional.value();
   }
   
@@ -2182,31 +2310,42 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>
+  // pragma MARK: std::optional<RemoteButton>
   /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>`.
+   * Specialized version of `std::optional<RemoteButton>`.
    */
-  using std__optional_std__variant_nitro__NullType__NotificationButtonLayout__ = std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>;
-  inline std::optional<std::variant<nitro::NullType, NotificationButtonLayout>> create_std__optional_std__variant_nitro__NullType__NotificationButtonLayout__(const std::variant<nitro::NullType, NotificationButtonLayout>& value) noexcept {
-    return std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>(value);
+  using std__optional_RemoteButton_ = std::optional<RemoteButton>;
+  inline std::optional<RemoteButton> create_std__optional_RemoteButton_(const RemoteButton& value) noexcept {
+    return std::optional<RemoteButton>(value);
   }
-  inline bool has_value_std__optional_std__variant_nitro__NullType__NotificationButtonLayout__(const std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>& optional) noexcept {
+  inline bool has_value_std__optional_RemoteButton_(const std::optional<RemoteButton>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::variant<nitro::NullType, NotificationButtonLayout> get_std__optional_std__variant_nitro__NullType__NotificationButtonLayout__(const std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>& optional) noexcept {
+  inline RemoteButton get_std__optional_RemoteButton_(const std::optional<RemoteButton>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::variant<nitro::NullType, NotificationButtonLayout>
+  // pragma MARK: std::vector<RemoteButton>
   /**
-   * Wrapper struct for `std::variant<nitro::NullType, NotificationButtonLayout>`.
+   * Specialized version of `std::vector<RemoteButton>`.
+   */
+  using std__vector_RemoteButton_ = std::vector<RemoteButton>;
+  inline std::vector<RemoteButton> create_std__vector_RemoteButton_(size_t size) noexcept {
+    std::vector<RemoteButton> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, RemoteButtonLayout>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, RemoteButtonLayout>`.
    * std::variant cannot be used in Swift because of a Swift bug.
    * Not even specializing it works. So we create a wrapper struct.
    */
-  struct std__variant_nitro__NullType__NotificationButtonLayout_ final {
-    std::variant<nitro::NullType, NotificationButtonLayout> variant;
-    std__variant_nitro__NullType__NotificationButtonLayout_(std::variant<nitro::NullType, NotificationButtonLayout> variant): variant(variant) { }
-    operator std::variant<nitro::NullType, NotificationButtonLayout>() const noexcept {
+  struct std__variant_nitro__NullType__RemoteButtonLayout_ final {
+    std::variant<nitro::NullType, RemoteButtonLayout> variant;
+    std__variant_nitro__NullType__RemoteButtonLayout_(std::variant<nitro::NullType, RemoteButtonLayout> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, RemoteButtonLayout>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
@@ -2215,73 +2354,58 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     inline nitro::NullType get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline NotificationButtonLayout get_1() const noexcept {
+    inline RemoteButtonLayout get_1() const noexcept {
       return std::get<1>(variant);
     }
   };
-  inline std__variant_nitro__NullType__NotificationButtonLayout_ create_std__variant_nitro__NullType__NotificationButtonLayout_(nitro::NullType value) noexcept {
-    return std__variant_nitro__NullType__NotificationButtonLayout_(value);
+  inline std__variant_nitro__NullType__RemoteButtonLayout_ create_std__variant_nitro__NullType__RemoteButtonLayout_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__RemoteButtonLayout_(value);
   }
-  inline std__variant_nitro__NullType__NotificationButtonLayout_ create_std__variant_nitro__NullType__NotificationButtonLayout_(const NotificationButtonLayout& value) noexcept {
-    return std__variant_nitro__NullType__NotificationButtonLayout_(value);
+  inline std__variant_nitro__NullType__RemoteButtonLayout_ create_std__variant_nitro__NullType__RemoteButtonLayout_(const RemoteButtonLayout& value) noexcept {
+    return std__variant_nitro__NullType__RemoteButtonLayout_(value);
   }
   
-  // pragma MARK: std::optional<NotificationButton>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, RemoteButtonLayout>>
   /**
-   * Specialized version of `std::optional<NotificationButton>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, RemoteButtonLayout>>`.
    */
-  using std__optional_NotificationButton_ = std::optional<NotificationButton>;
-  inline std::optional<NotificationButton> create_std__optional_NotificationButton_(const NotificationButton& value) noexcept {
-    return std::optional<NotificationButton>(value);
+  using std__optional_std__variant_nitro__NullType__RemoteButtonLayout__ = std::optional<std::variant<nitro::NullType, RemoteButtonLayout>>;
+  inline std::optional<std::variant<nitro::NullType, RemoteButtonLayout>> create_std__optional_std__variant_nitro__NullType__RemoteButtonLayout__(const std::variant<nitro::NullType, RemoteButtonLayout>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, RemoteButtonLayout>>(value);
   }
-  inline bool has_value_std__optional_NotificationButton_(const std::optional<NotificationButton>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_nitro__NullType__RemoteButtonLayout__(const std::optional<std::variant<nitro::NullType, RemoteButtonLayout>>& optional) noexcept {
     return optional.has_value();
   }
-  inline NotificationButton get_std__optional_NotificationButton_(const std::optional<NotificationButton>& optional) noexcept {
+  inline std::variant<nitro::NullType, RemoteButtonLayout> get_std__optional_std__variant_nitro__NullType__RemoteButtonLayout__(const std::optional<std::variant<nitro::NullType, RemoteButtonLayout>>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::vector<NotificationButton>>
+  // pragma MARK: std::optional<NitroAndroidUpdateOptions>
   /**
-   * Specialized version of `std::optional<std::vector<NotificationButton>>`.
+   * Specialized version of `std::optional<NitroAndroidUpdateOptions>`.
    */
-  using std__optional_std__vector_NotificationButton__ = std::optional<std::vector<NotificationButton>>;
-  inline std::optional<std::vector<NotificationButton>> create_std__optional_std__vector_NotificationButton__(const std::vector<NotificationButton>& value) noexcept {
-    return std::optional<std::vector<NotificationButton>>(value);
+  using std__optional_NitroAndroidUpdateOptions_ = std::optional<NitroAndroidUpdateOptions>;
+  inline std::optional<NitroAndroidUpdateOptions> create_std__optional_NitroAndroidUpdateOptions_(const NitroAndroidUpdateOptions& value) noexcept {
+    return std::optional<NitroAndroidUpdateOptions>(value);
   }
-  inline bool has_value_std__optional_std__vector_NotificationButton__(const std::optional<std::vector<NotificationButton>>& optional) noexcept {
+  inline bool has_value_std__optional_NitroAndroidUpdateOptions_(const std::optional<NitroAndroidUpdateOptions>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::vector<NotificationButton> get_std__optional_std__vector_NotificationButton__(const std::optional<std::vector<NotificationButton>>& optional) noexcept {
+  inline NitroAndroidUpdateOptions get_std__optional_NitroAndroidUpdateOptions_(const std::optional<NitroAndroidUpdateOptions>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::vector<NotificationButton>
+  // pragma MARK: std::vector<double>
   /**
-   * Specialized version of `std::vector<NotificationButton>`.
+   * Specialized version of `std::vector<double>`.
    */
-  using std__vector_NotificationButton_ = std::vector<NotificationButton>;
-  inline std::vector<NotificationButton> create_std__vector_NotificationButton_(size_t size) noexcept {
-    std::vector<NotificationButton> vector;
+  using std__vector_double_ = std::vector<double>;
+  inline std::vector<double> create_std__vector_double_(size_t size) noexcept {
+    std::vector<double> vector;
     vector.reserve(size);
     return vector;
   }
   
-  // pragma MARK: std::optional<NitroIOSUpdateOptions>
-  /**
-   * Specialized version of `std::optional<NitroIOSUpdateOptions>`.
-   */
-  using std__optional_NitroIOSUpdateOptions_ = std::optional<NitroIOSUpdateOptions>;
-  inline std::optional<NitroIOSUpdateOptions> create_std__optional_NitroIOSUpdateOptions_(const NitroIOSUpdateOptions& value) noexcept {
-    return std::optional<NitroIOSUpdateOptions>(value);
-  }
-  inline bool has_value_std__optional_NitroIOSUpdateOptions_(const std::optional<NitroIOSUpdateOptions>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline NitroIOSUpdateOptions get_std__optional_NitroIOSUpdateOptions_(const std::optional<NitroIOSUpdateOptions>& optional) noexcept {
-    return optional.value();
-  }
-  
   // pragma MARK: std::optional<std::vector<double>>
   /**
    * Specialized version of `std::optional<std::vector<double>>`.
@@ -2297,13 +2421,13 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::vector<double>
+  // pragma MARK: std::vector<CarPlayNowPlayingButton>
   /**
-   * Specialized version of `std::vector<double>`.
+   * Specialized version of `std::vector<CarPlayNowPlayingButton>`.
    */
-  using std__vector_double_ = std::vector<double>;
-  inline std::vector<double> create_std__vector_double_(size_t size) noexcept {
-    std::vector<double> vector;
+  using std__vector_CarPlayNowPlayingButton_ = std::vector<CarPlayNowPlayingButton>;
+  inline std::vector<CarPlayNowPlayingButton> create_std__vector_CarPlayNowPlayingButton_(size_t size) noexcept {
+    std::vector<CarPlayNowPlayingButton> vector;
     vector.reserve(size);
     return vector;
   }
@@ -2323,15 +2447,34 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::vector<CarPlayNowPlayingButton>
+  // pragma MARK: std::optional<CarPlayPlayingIndicatorLocation>
   /**
-   * Specialized version of `std::vector<CarPlayNowPlayingButton>`.
+   * Specialized version of `std::optional<CarPlayPlayingIndicatorLocation>`.
    */
-  using std__vector_CarPlayNowPlayingButton_ = std::vector<CarPlayNowPlayingButton>;
-  inline std::vector<CarPlayNowPlayingButton> create_std__vector_CarPlayNowPlayingButton_(size_t size) noexcept {
-    std::vector<CarPlayNowPlayingButton> vector;
-    vector.reserve(size);
-    return vector;
+  using std__optional_CarPlayPlayingIndicatorLocation_ = std::optional<CarPlayPlayingIndicatorLocation>;
+  inline std::optional<CarPlayPlayingIndicatorLocation> create_std__optional_CarPlayPlayingIndicatorLocation_(const CarPlayPlayingIndicatorLocation& value) noexcept {
+    return std::optional<CarPlayPlayingIndicatorLocation>(value);
+  }
+  inline bool has_value_std__optional_CarPlayPlayingIndicatorLocation_(const std::optional<CarPlayPlayingIndicatorLocation>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline CarPlayPlayingIndicatorLocation get_std__optional_CarPlayPlayingIndicatorLocation_(const std::optional<CarPlayPlayingIndicatorLocation>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<NitroIOSUpdateOptions>
+  /**
+   * Specialized version of `std::optional<NitroIOSUpdateOptions>`.
+   */
+  using std__optional_NitroIOSUpdateOptions_ = std::optional<NitroIOSUpdateOptions>;
+  inline std::optional<NitroIOSUpdateOptions> create_std__optional_NitroIOSUpdateOptions_(const NitroIOSUpdateOptions& value) noexcept {
+    return std::optional<NitroIOSUpdateOptions>(value);
+  }
+  inline bool has_value_std__optional_NitroIOSUpdateOptions_(const std::optional<NitroIOSUpdateOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline NitroIOSUpdateOptions get_std__optional_NitroIOSUpdateOptions_(const std::optional<NitroIOSUpdateOptions>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::optional<PlayerCapabilities>
@@ -2349,62 +2492,78 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::variant<bool, FavoriteConfig>>
+  // pragma MARK: std::optional<NativeUpdateOptions>
   /**
-   * Specialized version of `std::optional<std::variant<bool, FavoriteConfig>>`.
+   * Specialized version of `std::optional<NativeUpdateOptions>`.
    */
-  using std__optional_std__variant_bool__FavoriteConfig__ = std::optional<std::variant<bool, FavoriteConfig>>;
-  inline std::optional<std::variant<bool, FavoriteConfig>> create_std__optional_std__variant_bool__FavoriteConfig__(const std::variant<bool, FavoriteConfig>& value) noexcept {
-    return std::optional<std::variant<bool, FavoriteConfig>>(value);
+  using std__optional_NativeUpdateOptions_ = std::optional<NativeUpdateOptions>;
+  inline std::optional<NativeUpdateOptions> create_std__optional_NativeUpdateOptions_(const NativeUpdateOptions& value) noexcept {
+    return std::optional<NativeUpdateOptions>(value);
   }
-  inline bool has_value_std__optional_std__variant_bool__FavoriteConfig__(const std::optional<std::variant<bool, FavoriteConfig>>& optional) noexcept {
+  inline bool has_value_std__optional_NativeUpdateOptions_(const std::optional<NativeUpdateOptions>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::variant<bool, FavoriteConfig> get_std__optional_std__variant_bool__FavoriteConfig__(const std::optional<std::variant<bool, FavoriteConfig>>& optional) noexcept {
+  inline NativeUpdateOptions get_std__optional_NativeUpdateOptions_(const std::optional<NativeUpdateOptions>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::variant<bool, FavoriteConfig>
+  // pragma MARK: std::optional<NowPlayingUpdate>
   /**
-   * Wrapper struct for `std::variant<bool, FavoriteConfig>`.
-   * std::variant cannot be used in Swift because of a Swift bug.
-   * Not even specializing it works. So we create a wrapper struct.
+   * Specialized version of `std::optional<NowPlayingUpdate>`.
    */
-  struct std__variant_bool__FavoriteConfig_ final {
-    std::variant<bool, FavoriteConfig> variant;
-    std__variant_bool__FavoriteConfig_(std::variant<bool, FavoriteConfig> variant): variant(variant) { }
-    operator std::variant<bool, FavoriteConfig>() const noexcept {
-      return variant;
-    }
-    inline size_t index() const noexcept {
-      return variant.index();
-    }
-    inline bool get_0() const noexcept {
-      return std::get<0>(variant);
-    }
-    inline FavoriteConfig get_1() const noexcept {
-      return std::get<1>(variant);
-    }
-  };
-  inline std__variant_bool__FavoriteConfig_ create_std__variant_bool__FavoriteConfig_(bool value) noexcept {
-    return std__variant_bool__FavoriteConfig_(value);
+  using std__optional_NowPlayingUpdate_ = std::optional<NowPlayingUpdate>;
+  inline std::optional<NowPlayingUpdate> create_std__optional_NowPlayingUpdate_(const NowPlayingUpdate& value) noexcept {
+    return std::optional<NowPlayingUpdate>(value);
+  }
+  inline bool has_value_std__optional_NowPlayingUpdate_(const std::optional<NowPlayingUpdate>& optional) noexcept {
+    return optional.has_value();
   }
-  inline std__variant_bool__FavoriteConfig_ create_std__variant_bool__FavoriteConfig_(const FavoriteConfig& value) noexcept {
-    return std__variant_bool__FavoriteConfig_(value);
+  inline NowPlayingUpdate get_std__optional_NowPlayingUpdate_(const std::optional<NowPlayingUpdate>& optional) noexcept {
+    return optional.value();
   }
   
-  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>
+  // pragma MARK: std::optional<TimedMetadata>
   /**
-   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& / * params * /)>>`.
+   * Specialized version of `std::optional<TimedMetadata>`.
    */
-  using std__optional_std__function_std__shared_ptr_Promise_std__optional_NowPlayingUpdate____const_FormatNowPlayingParams_____params______ = std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>;
-  inline std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__optional_NowPlayingUpdate____const_FormatNowPlayingParams_____params______(const std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>& value) noexcept {
-    return std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>(value);
+  using std__optional_TimedMetadata_ = std::optional<TimedMetadata>;
+  inline std::optional<TimedMetadata> create_std__optional_TimedMetadata_(const TimedMetadata& value) noexcept {
+    return std::optional<TimedMetadata>(value);
   }
-  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__optional_NowPlayingUpdate____const_FormatNowPlayingParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>& optional) noexcept {
+  inline bool has_value_std__optional_TimedMetadata_(const std::optional<TimedMetadata>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)> get_std__optional_std__function_std__shared_ptr_Promise_std__optional_NowPlayingUpdate____const_FormatNowPlayingParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>& optional) noexcept {
+  inline TimedMetadata get_std__optional_TimedMetadata_(const std::optional<TimedMetadata>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<StallReason>
+  /**
+   * Specialized version of `std::optional<StallReason>`.
+   */
+  using std__optional_StallReason_ = std::optional<StallReason>;
+  inline std::optional<StallReason> create_std__optional_StallReason_(const StallReason& value) noexcept {
+    return std::optional<StallReason>(value);
+  }
+  inline bool has_value_std__optional_StallReason_(const std::optional<StallReason>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline StallReason get_std__optional_StallReason_(const std::optional<StallReason>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<PlaybackError>
+  /**
+   * Specialized version of `std::optional<PlaybackError>`.
+   */
+  using std__optional_PlaybackError_ = std::optional<PlaybackError>;
+  inline std::optional<PlaybackError> create_std__optional_PlaybackError_(const PlaybackError& value) noexcept {
+    return std::optional<PlaybackError>(value);
+  }
+  inline bool has_value_std__optional_PlaybackError_(const std::optional<PlaybackError>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline PlaybackError get_std__optional_PlaybackError_(const std::optional<PlaybackError>& optional) noexcept {
     return optional.value();
   }
   
@@ -2465,63 +2624,18 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_void_std__optional_NowPlayingUpdate__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<NowPlayingUpdate>
-  /**
-   * Specialized version of `std::optional<NowPlayingUpdate>`.
-   */
-  using std__optional_NowPlayingUpdate_ = std::optional<NowPlayingUpdate>;
-  inline std::optional<NowPlayingUpdate> create_std__optional_NowPlayingUpdate_(const NowPlayingUpdate& value) noexcept {
-    return std::optional<NowPlayingUpdate>(value);
-  }
-  inline bool has_value_std__optional_NowPlayingUpdate_(const std::optional<NowPlayingUpdate>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline NowPlayingUpdate get_std__optional_NowPlayingUpdate_(const std::optional<NowPlayingUpdate>& optional) noexcept {
-    return optional.value();
-  }
-  
-  // pragma MARK: std::optional<TimedMetadata>
-  /**
-   * Specialized version of `std::optional<TimedMetadata>`.
-   */
-  using std__optional_TimedMetadata_ = std::optional<TimedMetadata>;
-  inline std::optional<TimedMetadata> create_std__optional_TimedMetadata_(const TimedMetadata& value) noexcept {
-    return std::optional<TimedMetadata>(value);
-  }
-  inline bool has_value_std__optional_TimedMetadata_(const std::optional<TimedMetadata>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline TimedMetadata get_std__optional_TimedMetadata_(const std::optional<TimedMetadata>& optional) noexcept {
-    return optional.value();
-  }
-  
-  // pragma MARK: std::optional<StallReason>
-  /**
-   * Specialized version of `std::optional<StallReason>`.
-   */
-  using std__optional_StallReason_ = std::optional<StallReason>;
-  inline std::optional<StallReason> create_std__optional_StallReason_(const StallReason& value) noexcept {
-    return std::optional<StallReason>(value);
-  }
-  inline bool has_value_std__optional_StallReason_(const std::optional<StallReason>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline StallReason get_std__optional_StallReason_(const std::optional<StallReason>& optional) noexcept {
-    return optional.value();
-  }
-  
-  // pragma MARK: std::optional<PlaybackError>
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>
   /**
-   * Specialized version of `std::optional<PlaybackError>`.
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& / * params * /)>>`.
    */
-  using std__optional_PlaybackError_ = std::optional<PlaybackError>;
-  inline std::optional<PlaybackError> create_std__optional_PlaybackError_(const PlaybackError& value) noexcept {
-    return std::optional<PlaybackError>(value);
+  using std__optional_std__function_std__shared_ptr_Promise_std__optional_NowPlayingUpdate____const_FormatNowPlayingParams_____params______ = std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__optional_NowPlayingUpdate____const_FormatNowPlayingParams_____params______(const std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>(value);
   }
-  inline bool has_value_std__optional_PlaybackError_(const std::optional<PlaybackError>& optional) noexcept {
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__optional_NowPlayingUpdate____const_FormatNowPlayingParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>& optional) noexcept {
     return optional.has_value();
   }
-  inline PlaybackError get_std__optional_PlaybackError_(const std::optional<PlaybackError>& optional) noexcept {
+  inline std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)> get_std__optional_std__function_std__shared_ptr_Promise_std__optional_NowPlayingUpdate____const_FormatNowPlayingParams_____params______(const std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>& optional) noexcept {
     return optional.value();
   }
   
@@ -2540,21 +2654,6 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::variant<bool, RetryConfig>>
-  /**
-   * Specialized version of `std::optional<std::variant<bool, RetryConfig>>`.
-   */
-  using std__optional_std__variant_bool__RetryConfig__ = std::optional<std::variant<bool, RetryConfig>>;
-  inline std::optional<std::variant<bool, RetryConfig>> create_std__optional_std__variant_bool__RetryConfig__(const std::variant<bool, RetryConfig>& value) noexcept {
-    return std::optional<std::variant<bool, RetryConfig>>(value);
-  }
-  inline bool has_value_std__optional_std__variant_bool__RetryConfig__(const std::optional<std::variant<bool, RetryConfig>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::variant<bool, RetryConfig> get_std__optional_std__variant_bool__RetryConfig__(const std::optional<std::variant<bool, RetryConfig>>& optional) noexcept {
-    return optional.value();
-  }
-  
   // pragma MARK: std::variant<bool, RetryConfig>
   /**
    * Wrapper struct for `std::variant<bool, RetryConfig>`.
@@ -2584,6 +2683,21 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return std__variant_bool__RetryConfig_(value);
   }
   
+  // pragma MARK: std::optional<std::variant<bool, RetryConfig>>
+  /**
+   * Specialized version of `std::optional<std::variant<bool, RetryConfig>>`.
+   */
+  using std__optional_std__variant_bool__RetryConfig__ = std::optional<std::variant<bool, RetryConfig>>;
+  inline std::optional<std::variant<bool, RetryConfig>> create_std__optional_std__variant_bool__RetryConfig__(const std::variant<bool, RetryConfig>& value) noexcept {
+    return std::optional<std::variant<bool, RetryConfig>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_bool__RetryConfig__(const std::optional<std::variant<bool, RetryConfig>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<bool, RetryConfig> get_std__optional_std__variant_bool__RetryConfig__(const std::optional<std::variant<bool, RetryConfig>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<AndroidOptions>
   /**
    * Specialized version of `std::optional<AndroidOptions>`.