react-native-audio-browser 0.2.0-next.2 → 0.2.0-next.21

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.
@@ -108,10 +112,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 +146,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 +176,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 +197,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 +213,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 +222,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 +235,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 +245,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"
@@ -248,8 +260,6 @@ namespace AudioBrowser { class HybridAudioBrowserSpec_cxx; }
 #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 +277,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 +292,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"
@@ -453,21 +468,6 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<bool>
-  /**
-   * Specialized version of `std::optional<bool>`.
-   */
-  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_bool_(const std::optional<bool>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
-    return optional.value();
-  }
-  
   // pragma MARK: std::optional<double>
   /**
    * Specialized version of `std::optional<double>`.
@@ -498,30 +498,79 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::vector<ImageRowItem>>
+  // pragma MARK: std::optional<StyleDisplay>
   /**
-   * Specialized version of `std::optional<std::vector<ImageRowItem>>`.
+   * Specialized version of `std::optional<StyleDisplay>`.
    */
-  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_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_std__vector_ImageRowItem__(const std::optional<std::vector<ImageRowItem>>& optional) noexcept {
+  inline bool has_value_std__optional_StyleDisplay_(const std::optional<StyleDisplay>& 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 StyleDisplay get_std__optional_StyleDisplay_(const std::optional<StyleDisplay>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::vector<ImageRowItem>
+  // pragma MARK: std::optional<ArtworkRendering>
   /**
-   * Specialized version of `std::vector<ImageRowItem>`.
+   * Specialized version of `std::optional<ArtworkRendering>`.
    */
-  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;
+  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<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  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_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.value();
   }
   
   // pragma MARK: std::vector<Track>
@@ -606,6 +655,62 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(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::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<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::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<CarPlaySiriListButtonPosition>
   /**
    * Specialized version of `std::optional<CarPlaySiriListButtonPosition>`.
@@ -1631,6 +1736,56 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return Func_void_Wrapper(std::move(value));
   }
   
+  // 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::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();
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::string>>()>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::string>>()>`.
+   */
+  using Func_std__shared_ptr_Promise_std__string__ = std::function<std::shared_ptr<Promise<std::string>>()>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::string>>()>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__string___Wrapper final {
+  public:
+    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<std::shared_ptr<Promise<std::string>>()>> _function;
+  } SWIFT_NONCOPYABLE;
+  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::shared_ptr<Promise<std::string>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
+   */
+  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 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::optional<std::string>>>(const Track& /* track */)>>
   /**
    * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::optional<std::string>>>(const Track& / * track * /)>>`.
@@ -2182,31 +2337,31 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, RemoteButtonLayout>>
   /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, RemoteButtonLayout>>`.
    */
-  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_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_std__variant_nitro__NullType__NotificationButtonLayout__(const std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>& 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 std::variant<nitro::NullType, NotificationButtonLayout> get_std__optional_std__variant_nitro__NullType__NotificationButtonLayout__(const std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>& 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::variant<nitro::NullType, NotificationButtonLayout>
+  // pragma MARK: std::variant<nitro::NullType, RemoteButtonLayout>
   /**
-   * Wrapper struct for `std::variant<nitro::NullType, NotificationButtonLayout>`.
+   * 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,54 +2370,39 @@ 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<RemoteButton>
   /**
-   * Specialized version of `std::optional<NotificationButton>`.
+   * Specialized version of `std::optional<RemoteButton>`.
    */
-  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_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_NotificationButton_(const std::optional<NotificationButton>& optional) noexcept {
+  inline bool has_value_std__optional_RemoteButton_(const std::optional<RemoteButton>& optional) noexcept {
     return optional.has_value();
   }
-  inline NotificationButton get_std__optional_NotificationButton_(const std::optional<NotificationButton>& optional) noexcept {
+  inline RemoteButton get_std__optional_RemoteButton_(const std::optional<RemoteButton>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::vector<NotificationButton>>
+  // pragma MARK: std::vector<RemoteButton>
   /**
-   * Specialized version of `std::optional<std::vector<NotificationButton>>`.
+   * Specialized version of `std::vector<RemoteButton>`.
    */
-  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);
-  }
-  inline bool has_value_std__optional_std__vector_NotificationButton__(const std::optional<std::vector<NotificationButton>>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::vector<NotificationButton> get_std__optional_std__vector_NotificationButton__(const std::optional<std::vector<NotificationButton>>& optional) noexcept {
-    return optional.value();
-  }
-  
-  // pragma MARK: std::vector<NotificationButton>
-  /**
-   * Specialized version of `std::vector<NotificationButton>`.
-   */
-  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_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;
   }
@@ -2334,65 +2474,36 @@ namespace margelo::nitro::audiobrowser::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<PlayerCapabilities>
+  // pragma MARK: std::optional<CarPlayPlayingIndicatorLocation>
   /**
-   * Specialized version of `std::optional<PlayerCapabilities>`.
+   * Specialized version of `std::optional<CarPlayPlayingIndicatorLocation>`.
    */
-  using std__optional_PlayerCapabilities_ = std::optional<PlayerCapabilities>;
-  inline std::optional<PlayerCapabilities> create_std__optional_PlayerCapabilities_(const PlayerCapabilities& value) noexcept {
-    return std::optional<PlayerCapabilities>(value);
+  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_PlayerCapabilities_(const std::optional<PlayerCapabilities>& optional) noexcept {
+  inline bool has_value_std__optional_CarPlayPlayingIndicatorLocation_(const std::optional<CarPlayPlayingIndicatorLocation>& optional) noexcept {
     return optional.has_value();
   }
-  inline PlayerCapabilities get_std__optional_PlayerCapabilities_(const std::optional<PlayerCapabilities>& optional) noexcept {
+  inline CarPlayPlayingIndicatorLocation get_std__optional_CarPlayPlayingIndicatorLocation_(const std::optional<CarPlayPlayingIndicatorLocation>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::variant<bool, FavoriteConfig>>
+  // pragma MARK: std::optional<PlayerCapabilities>
   /**
-   * Specialized version of `std::optional<std::variant<bool, FavoriteConfig>>`.
+   * Specialized version of `std::optional<PlayerCapabilities>`.
    */
-  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_PlayerCapabilities_ = std::optional<PlayerCapabilities>;
+  inline std::optional<PlayerCapabilities> create_std__optional_PlayerCapabilities_(const PlayerCapabilities& value) noexcept {
+    return std::optional<PlayerCapabilities>(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_PlayerCapabilities_(const std::optional<PlayerCapabilities>& 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 PlayerCapabilities get_std__optional_PlayerCapabilities_(const std::optional<PlayerCapabilities>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::variant<bool, FavoriteConfig>
-  /**
-   * 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.
-   */
-  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);
-  }
-  inline std__variant_bool__FavoriteConfig_ create_std__variant_bool__FavoriteConfig_(const FavoriteConfig& value) noexcept {
-    return std__variant_bool__FavoriteConfig_(value);
-  }
-  
   // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& /* params */)>>
   /**
    * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::optional<NowPlayingUpdate>>>(const FormatNowPlayingParams& / * params * /)>>`.